1// Copyright (c) 2012 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// Stream-based listen socket implementation that handles reading and writing
6// to the socket, but does not handle creating the socket nor connecting
7// sockets, which are handled by subclasses on creation and in Accept,
8// respectively.
9
10// StreamListenSocket handles IO asynchronously in the specified MessageLoop.
11// This class is NOT thread safe. It uses WSAEVENT handles to monitor activity
12// in a given MessageLoop. This means that callbacks will happen in that loop's
13// thread always and that all other methods (including constructor and
14// destructor) should also be called from the same thread.
15
16#ifndef NET_SOCKET_STREAM_LISTEN_SOCKET_H_
17#define NET_SOCKET_STREAM_LISTEN_SOCKET_H_
18
19#include "build/build_config.h"
20
21#if defined(OS_WIN)
22#include <winsock2.h>
23#endif
24#include <string>
25#if defined(OS_WIN)
26#include "base/win/object_watcher.h"
27#elif defined(OS_POSIX)
28#include "base/message_loop/message_loop.h"
29#endif
30
31#include "base/basictypes.h"
32#include "base/compiler_specific.h"
33#include "base/memory/scoped_ptr.h"
34#include "net/base/net_export.h"
35#include "net/socket/socket_descriptor.h"
36
37namespace net {
38
39class IPEndPoint;
40
41class NET_EXPORT StreamListenSocket
42    :
43#if defined(OS_WIN)
44      public base::win::ObjectWatcher::Delegate {
45#elif defined(OS_POSIX)
46      public base::MessageLoopForIO::Watcher {
47#endif
48
49 public:
50  virtual ~StreamListenSocket();
51
52  // TODO(erikkay): this delegate should really be split into two parts
53  // to split up the listener from the connected socket.  Perhaps this class
54  // should be split up similarly.
55  class Delegate {
56   public:
57    // |server| is the original listening Socket, connection is the new
58    // Socket that was created.
59    virtual void DidAccept(StreamListenSocket* server,
60                           scoped_ptr<StreamListenSocket> connection) = 0;
61    virtual void DidRead(StreamListenSocket* connection,
62                         const char* data,
63                         int len) = 0;
64    virtual void DidClose(StreamListenSocket* sock) = 0;
65
66   protected:
67    virtual ~Delegate() {}
68  };
69
70  // Send data to the socket.
71  void Send(const char* bytes, int len, bool append_linefeed = false);
72  void Send(const std::string& str, bool append_linefeed = false);
73
74  // Copies the local address to |address|. Returns a network error code.
75  // This method is virtual to support unit testing.
76  virtual int GetLocalAddress(IPEndPoint* address);
77  // Copies the peer address to |address|. Returns a network error code.
78  // This method is virtual to support unit testing.
79  virtual int GetPeerAddress(IPEndPoint* address);
80
81  static const int kSocketError;
82
83 protected:
84  enum WaitState {
85    NOT_WAITING      = 0,
86    WAITING_ACCEPT   = 1,
87    WAITING_READ     = 2
88  };
89
90  StreamListenSocket(SocketDescriptor s, Delegate* del);
91
92  SocketDescriptor AcceptSocket();
93  virtual void Accept() = 0;
94
95  void Listen();
96  void Read();
97  void Close();
98  void CloseSocket();
99
100  // Pass any value in case of Windows, because in Windows
101  // we are not using state.
102  void WatchSocket(WaitState state);
103  void UnwatchSocket();
104
105  Delegate* const socket_delegate_;
106
107 private:
108  friend class TransportClientSocketTest;
109
110  void SendInternal(const char* bytes, int len);
111
112#if defined(OS_WIN)
113  // ObjectWatcher delegate.
114  virtual void OnObjectSignaled(HANDLE object);
115  base::win::ObjectWatcher watcher_;
116  HANDLE socket_event_;
117#elif defined(OS_POSIX)
118  // Called by MessagePumpLibevent when the socket is ready to do I/O.
119  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
120  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
121  WaitState wait_state_;
122  // The socket's libevent wrapper.
123  base::MessageLoopForIO::FileDescriptorWatcher watcher_;
124#endif
125
126  // NOTE: This is for unit test use only!
127  // Pause/Resume calling Read(). Note that ResumeReads() will also call
128  // Read() if there is anything to read.
129  void PauseReads();
130  void ResumeReads();
131
132  const SocketDescriptor socket_;
133  bool reads_paused_;
134  bool has_pending_reads_;
135
136  DISALLOW_COPY_AND_ASSIGN(StreamListenSocket);
137};
138
139// Abstract factory that must be subclassed for each subclass of
140// StreamListenSocket.
141class NET_EXPORT StreamListenSocketFactory {
142 public:
143  virtual ~StreamListenSocketFactory() {}
144
145  // Returns a new instance of StreamListenSocket or NULL if an error occurred.
146  virtual scoped_ptr<StreamListenSocket> CreateAndListen(
147      StreamListenSocket::Delegate* delegate) const = 0;
148};
149
150}  // namespace net
151
152#endif  // NET_SOCKET_STREAM_LISTEN_SOCKET_H_
153