Home | History | Annotate | Download | only in socket 
      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 
     37 namespace net {
     38 
     39 class IPEndPoint;
     40 
     41 class 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.
    141 class 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