Attn: Mike Belshe

net/socket/sctp_client_socket_libevent.h

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_SOCKET_SCTP_CLIENT_SOCKET_LIBEVENT_H_
+#define NET_SOCKET_SCTP_CLIENT_SOCKET_LIBEVENT_H_
+#pragma once
+
+#include <netinet/in.h>
+
+#include "base/message_loop.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/threading/non_thread_safe.h"
+#include "net/base/address_list.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_log.h"
+#include "net/socket/client_socket.h"
+
+struct event;  // From libevent
+
+namespace net {
+
+class BoundNetLog;
+
+// A client socket that uses SCTP as the transport layer.
+class SCTPClientSocketLibevent : public ClientSocket, base::NonThreadSafe {
+ public:
+  // The IP address(es) and port number to connect to.  The SCTP socket will try
+  // each IP address in the list until it succeeds in establishing a
+  // connection.
+  SCTPClientSocketLibevent(const AddressList& addresses,
+                          net::NetLog* net_log,
+                          const net::NetLog::Source& source);
+
+  virtual ~SCTPClientSocketLibevent();
+
+  // AdoptSocket causes the given, connected socket to be adopted as an SCTP
+  // socket. This object must not be connected. This object takes ownership of
+  // the given socket and then acts as if Connect() had been called. This
+  // function is intended for testing only.
+  void AdoptSocket(int socket);
+
+  // ClientSocket methods:
+  virtual int Connect(CompletionCallback* callback);
+  virtual void Disconnect();
+  virtual bool IsConnected() const;
+  virtual bool IsConnectedAndIdle() const;
+  virtual int GetPeerAddress(AddressList* address) const;
+  virtual const BoundNetLog& NetLog() const;
+  virtual void SetSubresourceSpeculation() {}
+  virtual void SetOmniboxSpeculation() {}
+  virtual bool WasEverUsed() const { return false; }
+  virtual bool UsingTCPFastOpen() const { return false; }
+  virtual int protocol() { return IPPROTO_SCTP; }
+  virtual bool using_sctp_control_stream() {
+    return using_sctp_control_stream_ ? true : false;
+  }
+  virtual void set_using_sctp_control_stream() {
+    using_sctp_control_stream_ = true;
+    return;
+  }
+
+  // Map a SPDY stream number to an SCTP stream ID.
+  virtual uint16 MapSpdyToSctp(uint32 stream_id);
+
+  // Socket methods:
+  // Multiple outstanding requests are not supported.
+  // Full duplex mode (reading and writing at the same time) is supported
+  virtual int Read(IOBuffer* buf, int buf_len, CompletionCallback* callback);
+  virtual int Write(IOBuffer* buf, int buf_len, CompletionCallback* callback);
+  virtual bool SetReceiveBufferSize(int32 size);
+  virtual bool SetSendBufferSize(int32 size);
+
+ private:
+  // State machine for connecting the socket.
+  enum ConnectState {
+    CONNECT_STATE_CONNECT,
+    CONNECT_STATE_CONNECT_COMPLETE,
+    CONNECT_STATE_NONE,
+  };
+
+  // State of SCTP association for the socket.
+  enum AssociationState {
+    SCTP_EMPTY,
+    SCTP_CLOSED,
+    SCTP_COOKIE_WAIT,
+    SCTP_COOKIE_ECHOED,
+    SCTP_ESTABLISHED,
+    SCTP_SHUTDOWN_PENDING,
+    SCTP_SHUTDOWN_SENT,
+    SCTP_SHUTDOWN_RECEIVED,
+    SCTP_SHUTDOWN_ACK_SENT,
+  };
+
+  class ReadWatcher : public MessageLoopForIO::Watcher {
+   public:
+    explicit ReadWatcher(SCTPClientSocketLibevent* socket) : socket_(socket) {}
+
+    // MessageLoopForIO::Watcher methods
+
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {
+      if (socket_->read_callback_)
+        socket_->DidCompleteRead();
+    }
+
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {}
+
+   private:
+    SCTPClientSocketLibevent* const socket_;
+
+    DISALLOW_COPY_AND_ASSIGN(ReadWatcher);
+  };
+
+  class WriteWatcher : public MessageLoopForIO::Watcher {
+   public:
+    explicit WriteWatcher(SCTPClientSocketLibevent* socket) : socket_(socket) {}
+
+    // MessageLoopForIO::Watcher methods
+
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) {}
+
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) {
+      if (socket_->waiting_connect()) {
+        socket_->DidCompleteConnect();
+      } else if (socket_->write_callback_) {
+        socket_->DidCompleteWrite();
+      }
+    }
+
+   private:
+    SCTPClientSocketLibevent* const socket_;
+
+    DISALLOW_COPY_AND_ASSIGN(WriteWatcher);
+  };
+
+  // State machine used by Connect().
+  int DoConnectLoop(int result);
+  int DoConnect();
+  int DoConnectComplete(int result);
+
+  // Helper used by Disconnect(), which disconnects minus the logging and
+  // resetting of current_ai_.
+  void DoDisconnect();
+
+  void DoReadCallback(int rv);
+  void DoWriteCallback(int rv);
+  void DidCompleteRead();
+  void DidCompleteWrite();
+  void DidCompleteConnect();
+
+  // Returns true if a Connect() is in progress.
+  bool waiting_connect() const {
+    return next_connect_state_ != CONNECT_STATE_NONE;
+  }
+
+  // Returns the OS error code (or 0 on success).
+  int CreateSocket(const struct addrinfo* ai);
+
+  // Returns the OS error code (or 0 on success).
+  int SetupSocket();
+
+  // Helper to add an SCTP_CONNECT (end) event to the NetLog.
+  void LogConnectCompletion(int net_error);
+
+  // Internal function to write to a socket.
+  int InternalWrite(IOBuffer* buf, int buf_len);
+  int InternalWrite(IOBuffer* buf, int buf_len, int sctp_stream_id);
+
+  int socket_;
+
+  // The list of addresses we should try in order to establish a connection.
+  AddressList addresses_;
+
+  // Where we are in above list, or NULL if all addrinfos have been tried.
+  const struct addrinfo* current_ai_;
+
+  // Flag to indicate whether or not we are sending SPDY control frames on SCTP
+  // stream 0.
+  bool using_sctp_control_stream_;
+
+  // Number of outgoing SCTP streams negotiated during association setup.
+  uint16 max_sctp_streams_;
+
+  // The socket's libevent wrappers
+  MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
+  MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_;
+
+  // The corresponding watchers for reads and writes.
+  ReadWatcher read_watcher_;
+  WriteWatcher write_watcher_;
+
+  // The buffer used by OnSocketReady to retry Read requests
+  scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
+
+  // The buffer used by OnSocketReady to retry Write requests
+  scoped_refptr<IOBuffer> write_buf_;
+  int write_buf_len_;
+
+  // External callback; called when read is complete.
+  CompletionCallback* read_callback_;
+
+  // External callback; called when write is complete.
+  CompletionCallback* write_callback_;
+
+  // The next state for the Connect() state machine.
+  ConnectState next_connect_state_;
+
+  // The OS error that CONNECT_STATE_CONNECT last completed with.
+  int connect_os_error_;
+
+  BoundNetLog net_log_;
+
+  // This socket was previously disconnected and has not been re-connected.
+  bool previously_disconnected_;
+
+  // Record of connectivity and transmissions, for use in speculative connection
+  // histograms.
+  UseHistory use_history_;
+
+  DISALLOW_COPY_AND_ASSIGN(SCTPClientSocketLibevent);
+};
+
+}  // namespace net
+
+#endif  // NET_SOCKET_SCTP_CLIENT_SOCKET_LIBEVENT_H_