folly/io/async/AsyncSocket.h

   1 /*
   2  * Copyright 2015 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #pragma once
  18
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <glog/logging.h>
  22 #include <folly/SocketAddress.h>
  23 #include <folly/io/ShutdownSocketSet.h>
  24 #include <folly/io/IOBuf.h>
  25 #include <folly/io/async/AsyncTimeout.h>
  26 #include <folly/io/async/AsyncSocketException.h>
  27 #include <folly/io/async/AsyncTransport.h>
  28 #include <folly/io/async/EventHandler.h>
  29 #include <folly/io/async/DelayedDestruction.h>
  30
  31 #include <chrono>
  32 #include <memory>
  33 #include <map>
  34
  35 namespace folly {
  36
  37 /**
  38  * A class for performing asynchronous I/O on a socket.
  39  *
  40  * AsyncSocket allows users to asynchronously wait for data on a socket, and
  41  * to asynchronously send data.
  42  *
  43  * The APIs for reading and writing are intentionally asymmetric.  Waiting for
  44  * data to read is a persistent API: a callback is installed, and is notified
  45  * whenever new data is available.  It continues to be notified of new events
  46  * until it is uninstalled.
  47  *
  48  * AsyncSocket does not provide read timeout functionality, because it
  49  * typically cannot determine when the timeout should be active.  Generally, a
  50  * timeout should only be enabled when processing is blocked waiting on data
  51  * from the remote endpoint.  For server sockets, the timeout should not be
  52  * active if the server is currently processing one or more outstanding
  53  * requests for this socket.  For client sockets, the timeout should not be
  54  * active if there are no requests pending on the socket.  Additionally, if a
  55  * client has multiple pending requests, it will ususally want a separate
  56  * timeout for each request, rather than a single read timeout.
  57  *
  58  * The write API is fairly intuitive: a user can request to send a block of
  59  * data, and a callback will be informed once the entire block has been
  60  * transferred to the kernel, or on error.  AsyncSocket does provide a send
  61  * timeout, since most callers want to give up if the remote end stops
  62  * responding and no further progress can be made sending the data.
  63  */
  64
  65 class AsyncSocket : virtual public AsyncTransportWrapper {
  66  public:
  67   typedef std::unique_ptr<AsyncSocket, Destructor> UniquePtr;
  68
  69   class ConnectCallback {
  70    public:
  71     virtual ~ConnectCallback() = default;
  72
  73     /**
  74      * connectSuccess() will be invoked when the connection has been
  75      * successfully established.
  76      */
  77     virtual void connectSuccess() noexcept = 0;
  78
  79     /**
  80      * connectErr() will be invoked if the connection attempt fails.
  81      *
  82      * @param ex        An exception describing the error that occurred.
  83      */
  84     virtual void connectErr(const AsyncSocketException& ex)
  85       noexcept = 0;
  86   };
  87
  88   explicit AsyncSocket();
  89   /**
  90    * Create a new unconnected AsyncSocket.
  91    *
  92    * connect() must later be called on this socket to establish a connection.
  93    */
  94   explicit AsyncSocket(EventBase* evb);
  95
  96   void setShutdownSocketSet(ShutdownSocketSet* ss);
  97
  98   /**
  99    * Create a new AsyncSocket and begin the connection process.
 100    *
 101    * @param evb             EventBase that will manage this socket.
 102    * @param address         The address to connect to.
 103    * @param connectTimeout  Optional timeout in milliseconds for the connection
 104    *                        attempt.
 105    */
 106   AsyncSocket(EventBase* evb,
 107                const folly::SocketAddress& address,
 108                uint32_t connectTimeout = 0);
 109
 110   /**
 111    * Create a new AsyncSocket and begin the connection process.
 112    *
 113    * @param evb             EventBase that will manage this socket.
 114    * @param ip              IP address to connect to (dotted-quad).
 115    * @param port            Destination port in host byte order.
 116    * @param connectTimeout  Optional timeout in milliseconds for the connection
 117    *                        attempt.
 118    */
 119   AsyncSocket(EventBase* evb,
 120                const std::string& ip,
 121                uint16_t port,
 122                uint32_t connectTimeout = 0);
 123
 124   /**
 125    * Create a AsyncSocket from an already connected socket file descriptor.
 126    *
 127    * Note that while AsyncSocket enables TCP_NODELAY for sockets it creates
 128    * when connecting, it does not change the socket options when given an
 129    * existing file descriptor.  If callers want TCP_NODELAY enabled when using
 130    * this version of the constructor, they need to explicitly call
 131    * setNoDelay(true) after the constructor returns.
 132    *
 133    * @param evb EventBase that will manage this socket.
 134    * @param fd  File descriptor to take over (should be a connected socket).
 135    */
 136   AsyncSocket(EventBase* evb, int fd);
 137
 138   /**
 139    * Helper function to create a shared_ptr<AsyncSocket>.
 140    *
 141    * This passes in the correct destructor object, since AsyncSocket's
 142    * destructor is protected and cannot be invoked directly.
 143    */
 144   static std::shared_ptr<AsyncSocket> newSocket(EventBase* evb) {
 145     return std::shared_ptr<AsyncSocket>(new AsyncSocket(evb),
 146                                            Destructor());
 147   }
 148
 149   /**
 150    * Helper function to create a shared_ptr<AsyncSocket>.
 151    */
 152   static std::shared_ptr<AsyncSocket> newSocket(
 153       EventBase* evb,
 154       const folly::SocketAddress& address,
 155       uint32_t connectTimeout = 0) {
 156     return std::shared_ptr<AsyncSocket>(
 157         new AsyncSocket(evb, address, connectTimeout),
 158         Destructor());
 159   }
 160
 161   /**
 162    * Helper function to create a shared_ptr<AsyncSocket>.
 163    */
 164   static std::shared_ptr<AsyncSocket> newSocket(
 165       EventBase* evb,
 166       const std::string& ip,
 167       uint16_t port,
 168       uint32_t connectTimeout = 0) {
 169     return std::shared_ptr<AsyncSocket>(
 170         new AsyncSocket(evb, ip, port, connectTimeout),
 171         Destructor());
 172   }
 173
 174   /**
 175    * Helper function to create a shared_ptr<AsyncSocket>.
 176    */
 177   static std::shared_ptr<AsyncSocket> newSocket(EventBase* evb, int fd) {
 178     return std::shared_ptr<AsyncSocket>(new AsyncSocket(evb, fd),
 179                                            Destructor());
 180   }
 181
 182   /**
 183    * Destroy the socket.
 184    *
 185    * AsyncSocket::destroy() must be called to destroy the socket.
 186    * The normal destructor is private, and should not be invoked directly.
 187    * This prevents callers from deleting a AsyncSocket while it is invoking a
 188    * callback.
 189    */
 190   virtual void destroy() override;
 191
 192   /**
 193    * Get the EventBase used by this socket.
 194    */
 195   EventBase* getEventBase() const override {
 196     return eventBase_;
 197   }
 198
 199   /**
 200    * Get the file descriptor used by the AsyncSocket.
 201    */
 202   virtual int getFd() const {
 203     return fd_;
 204   }
 205
 206   /**
 207    * Extract the file descriptor from the AsyncSocket.
 208    *
 209    * This will immediately cause any installed callbacks to be invoked with an
 210    * error.  The AsyncSocket may no longer be used after the file descriptor
 211    * has been extracted.
 212    *
 213    * Returns the file descriptor.  The caller assumes ownership of the
 214    * descriptor, and it will not be closed when the AsyncSocket is destroyed.
 215    */
 216   virtual int detachFd();
 217
 218   /**
 219    * Uniquely identifies a handle to a socket option value. Each
 220    * combination of level and option name corresponds to one socket
 221    * option value.
 222    */
 223   class OptionKey {
 224    public:
 225     bool operator<(const OptionKey& other) const {
 226       if (level == other.level) {
 227         return optname < other.optname;
 228       }
 229       return level < other.level;
 230     }
 231     int apply(int fd, int val) const {
 232       return setsockopt(fd, level, optname, &val, sizeof(val));
 233     }
 234     int level;
 235     int optname;
 236   };
 237
 238   // Maps from a socket option key to its value
 239   typedef std::map<OptionKey, int> OptionMap;
 240
 241   static const OptionMap emptyOptionMap;
 242   static const folly::SocketAddress& anyAddress();
 243
 244   /**
 245    * Initiate a connection.
 246    *
 247    * @param callback  The callback to inform when the connection attempt
 248    *                  completes.
 249    * @param address   The address to connect to.
 250    * @param timeout   A timeout value, in milliseconds.  If the connection
 251    *                  does not succeed within this period,
 252    *                  callback->connectError() will be invoked.
 253    */
 254   virtual void connect(ConnectCallback* callback,
 255                const folly::SocketAddress& address,
 256                int timeout = 0,
 257                const OptionMap &options = emptyOptionMap,
 258                const folly::SocketAddress& bindAddr = anyAddress()
 259                ) noexcept;
 260   void connect(ConnectCallback* callback, const std::string& ip, uint16_t port,
 261                int timeout = 00,
 262                const OptionMap &options = emptyOptionMap) noexcept;
 263
 264   /**
 265    * If a connect request is in-flight, cancels it and closes the socket
 266    * immediately. Otherwise, this is a no-op.
 267    *
 268    * This does not invoke any connection related callbacks. Call this to
 269    * prevent any connect callback while cleaning up, etc.
 270    */
 271   void cancelConnect();
 272
 273   /**
 274    * Set the send timeout.
 275    *
 276    * If write requests do not make any progress for more than the specified
 277    * number of milliseconds, fail all pending writes and close the socket.
 278    *
 279    * If write requests are currently pending when setSendTimeout() is called,
 280    * the timeout interval is immediately restarted using the new value.
 281    *
 282    * (See the comments for AsyncSocket for an explanation of why AsyncSocket
 283    * provides setSendTimeout() but not setRecvTimeout().)
 284    *
 285    * @param milliseconds  The timeout duration, in milliseconds.  If 0, no
 286    *                      timeout will be used.
 287    */
 288   void setSendTimeout(uint32_t milliseconds) override;
 289
 290   /**
 291    * Get the send timeout.
 292    *
 293    * @return Returns the current send timeout, in milliseconds.  A return value
 294    *         of 0 indicates that no timeout is set.
 295    */
 296   uint32_t getSendTimeout() const override {
 297     return sendTimeout_;
 298   }
 299
 300   /**
 301    * Set the maximum number of reads to execute from the underlying
 302    * socket each time the EventBase detects that new ingress data is
 303    * available. The default is unlimited, but callers can use this method
 304    * to limit the amount of data read from the socket per event loop
 305    * iteration.
 306    *
 307    * @param maxReads  Maximum number of reads per data-available event;
 308    *                  a value of zero means unlimited.
 309    */
 310   void setMaxReadsPerEvent(uint16_t maxReads) {
 311     maxReadsPerEvent_ = maxReads;
 312   }
 313
 314   /**
 315    * Get the maximum number of reads this object will execute from
 316    * the underlying socket each time the EventBase detects that new
 317    * ingress data is available.
 318    *
 319    * @returns Maximum number of reads per data-available event; a value
 320    *          of zero means unlimited.
 321    */
 322   uint16_t getMaxReadsPerEvent() const {
 323     return maxReadsPerEvent_;
 324   }
 325
 326   // Read and write methods
 327   void setReadCB(ReadCallback* callback) override;
 328   ReadCallback* getReadCallback() const override;
 329
 330   void write(WriteCallback* callback, const void* buf, size_t bytes,
 331              WriteFlags flags = WriteFlags::NONE) override;
 332   void writev(WriteCallback* callback, const iovec* vec, size_t count,
 333               WriteFlags flags = WriteFlags::NONE) override;
 334   void writeChain(WriteCallback* callback,
 335                   std::unique_ptr<folly::IOBuf>&& buf,
 336                   WriteFlags flags = WriteFlags::NONE) override;
 337
 338   class WriteRequest;
 339   virtual void writeRequest(WriteRequest* req);
 340   void writeRequestReady() {
 341     handleWrite();
 342   }
 343
 344   // Methods inherited from AsyncTransport
 345   void close() override;
 346   void closeNow() override;
 347   void closeWithReset() override;
 348   void shutdownWrite() override;
 349   void shutdownWriteNow() override;
 350
 351   bool readable() const override;
 352   bool isPending() const override;
 353   virtual bool hangup() const;
 354   bool good() const override;
 355   bool error() const override;
 356   void attachEventBase(EventBase* eventBase) override;
 357   void detachEventBase() override;
 358   bool isDetachable() const override;
 359
 360   void getLocalAddress(
 361     folly::SocketAddress* address) const override;
 362   void getPeerAddress(
 363     folly::SocketAddress* address) const override;
 364
 365   bool isEorTrackingEnabled() const override { return false; }
 366
 367   void setEorTracking(bool /*track*/) override {}
 368
 369   bool connecting() const override {
 370     return (state_ == StateEnum::CONNECTING);
 371   }
 372
 373   virtual bool isClosedByPeer() const {
 374     return (state_ == StateEnum::CLOSED &&
 375             (readErr_ == READ_EOF || readErr_ == READ_ERROR));
 376   }
 377
 378   virtual bool isClosedBySelf() const {
 379     return (state_ == StateEnum::CLOSED &&
 380             (readErr_ != READ_EOF && readErr_ != READ_ERROR));
 381   }
 382
 383   size_t getAppBytesWritten() const override {
 384     return appBytesWritten_;
 385   }
 386
 387   size_t getRawBytesWritten() const override {
 388     return getAppBytesWritten();
 389   }
 390
 391   size_t getAppBytesReceived() const override {
 392     return appBytesReceived_;
 393   }
 394
 395   size_t getRawBytesReceived() const override {
 396     return getAppBytesReceived();
 397   }
 398
 399   std::chrono::nanoseconds getConnectTime() const {
 400     return connectEndTime_ - connectStartTime_;
 401   }
 402
 403   // Methods controlling socket options
 404
 405   /**
 406    * Force writes to be transmitted immediately.
 407    *
 408    * This controls the TCP_NODELAY socket option.  When enabled, TCP segments
 409    * are sent as soon as possible, even if it is not a full frame of data.
 410    * When disabled, the data may be buffered briefly to try and wait for a full
 411    * frame of data.
 412    *
 413    * By default, TCP_NODELAY is enabled for AsyncSocket objects.
 414    *
 415    * This method will fail if the socket is not currently open.
 416    *
 417    * @return Returns 0 if the TCP_NODELAY flag was successfully updated,
 418    *         or a non-zero errno value on error.
 419    */
 420   int setNoDelay(bool noDelay);
 421
 422
 423   /**
 424    * Set the FD_CLOEXEC flag so that the socket will be closed if the program
 425    * later forks and execs.
 426    */
 427   void setCloseOnExec();
 428
 429   /*
 430    * Set the Flavor of Congestion Control to be used for this Socket
 431    * Please check '/lib/modules/<kernel>/kernel/net/ipv4' for tcp_*.ko
 432    * first to make sure the module is available for plugging in
 433    * Alternatively you can choose from net.ipv4.tcp_allowed_congestion_control
 434    */
 435   int setCongestionFlavor(const std::string &cname);
 436
 437   /*
 438    * Forces ACKs to be sent immediately
 439    *
 440    * @return Returns 0 if the TCP_QUICKACK flag was successfully updated,
 441    *         or a non-zero errno value on error.
 442    */
 443   int setQuickAck(bool quickack);
 444
 445   /**
 446    * Set the send bufsize
 447    */
 448   int setSendBufSize(size_t bufsize);
 449
 450   /**
 451    * Set the recv bufsize
 452    */
 453   int setRecvBufSize(size_t bufsize);
 454
 455   /**
 456    * Sets a specific tcp personality
 457    * Available only on kernels 3.2 and greater
 458    */
 459   #define SO_SET_NAMESPACE        41
 460   int setTCPProfile(int profd);
 461
 462   /**
 463    * Set TCP_CORK on the socket, and turn on/off the persistentCork_ flag
 464    *
 465    * When persistentCork_ is true, CorkGuard in AsyncSSLSocket will not be
 466    * able to toggle TCP_CORK
 467    *
 468    */
 469   void setPersistentCork(bool cork);
 470
 471   /**
 472    * Generic API for reading a socket option.
 473    *
 474    * @param level     same as the "level" parameter in getsockopt().
 475    * @param optname   same as the "optname" parameter in getsockopt().
 476    * @param optval    pointer to the variable in which the option value should
 477    *                  be returned.
 478    * @param optlen    value-result argument, initially containing the size of
 479    *                  the buffer pointed to by optval, and modified on return
 480    *                  to indicate the actual size of the value returned.
 481    * @return          same as the return value of getsockopt().
 482    */
 483   template <typename T>
 484   int getSockOpt(int level, int optname, T* optval, socklen_t* optlen) {
 485     return getsockopt(fd_, level, optname, (void*) optval, optlen);
 486   }
 487
 488   /**
 489    * Generic API for setting a socket option.
 490    *
 491    * @param level     same as the "level" parameter in getsockopt().
 492    * @param optname   same as the "optname" parameter in getsockopt().
 493    * @param optval    the option value to set.
 494    * @return          same as the return value of setsockopt().
 495    */
 496   template <typename T>
 497   int setSockOpt(int  level,  int  optname,  const T *optval) {
 498     return setsockopt(fd_, level, optname, optval, sizeof(T));
 499   }
 500
 501   virtual void setPeek(bool peek) {
 502     peek_ = peek;
 503   }
 504
 505   enum class StateEnum : uint8_t {
 506     UNINIT,
 507     CONNECTING,
 508     ESTABLISHED,
 509     CLOSED,
 510     ERROR
 511   };
 512
 513   /**
 514    * A WriteRequest object tracks information about a pending write operation.
 515    */
 516   class WriteRequest {
 517    public:
 518     WriteRequest(AsyncSocket* socket, WriteCallback* callback) :
 519       socket_(socket), callback_(callback) {}
 520
 521     virtual void start() {};
 522
 523     virtual void destroy() = 0;
 524
 525     virtual bool performWrite() = 0;
 526
 527     virtual void consume() = 0;
 528
 529     virtual bool isComplete() = 0;
 530
 531     WriteRequest* getNext() const {
 532       return next_;
 533     }
 534
 535     WriteCallback* getCallback() const {
 536       return callback_;
 537     }
 538
 539     uint32_t getTotalBytesWritten() const {
 540       return totalBytesWritten_;
 541     }
 542
 543     void append(WriteRequest* next) {
 544       assert(next_ == nullptr);
 545       next_ = next;
 546     }
 547
 548     void fail(const char* fn, const AsyncSocketException& ex) {
 549       socket_->failWrite(fn, ex);
 550     }
 551
 552     void bytesWritten(size_t count) {
 553       totalBytesWritten_ += count;
 554       socket_->appBytesWritten_ += count;
 555     }
 556
 557    protected:
 558     // protected destructor, to ensure callers use destroy()
 559     virtual ~WriteRequest() {}
 560
 561     AsyncSocket* socket_;         ///< parent socket
 562     WriteRequest* next_{nullptr};          ///< pointer to next WriteRequest
 563     WriteCallback* callback_;     ///< completion callback
 564     uint32_t totalBytesWritten_{0};  ///< total bytes written
 565   };
 566
 567  protected:
 568   enum ReadResultEnum {
 569     READ_EOF = 0,
 570     READ_ERROR = -1,
 571     READ_BLOCKING = -2,
 572     READ_NO_ERROR = -3,
 573   };
 574
 575   /**
 576    * Protected destructor.
 577    *
 578    * Users of AsyncSocket must never delete it directly.  Instead, invoke
 579    * destroy() instead.  (See the documentation in DelayedDestruction.h for
 580    * more details.)
 581    */
 582   ~AsyncSocket();
 583
 584   friend std::ostream& operator << (std::ostream& os, const StateEnum& state);
 585
 586   enum ShutdownFlags {
 587     /// shutdownWrite() called, but we are still waiting on writes to drain
 588     SHUT_WRITE_PENDING = 0x01,
 589     /// writes have been completely shut down
 590     SHUT_WRITE = 0x02,
 591     /**
 592      * Reads have been shutdown.
 593      *
 594      * At the moment we don't distinguish between remote read shutdown
 595      * (received EOF from the remote end) and local read shutdown.  We can
 596      * only receive EOF when a read callback is set, and we immediately inform
 597      * it of the EOF.  Therefore there doesn't seem to be any reason to have a
 598      * separate state of "received EOF but the local side may still want to
 599      * read".
 600      *
 601      * We also don't currently provide any API for only shutting down the read
 602      * side of a socket.  (This is a no-op as far as TCP is concerned, anyway.)
 603      */
 604     SHUT_READ = 0x04,
 605   };
 606
 607   class BytesWriteRequest;
 608
 609   class WriteTimeout : public AsyncTimeout {
 610    public:
 611     WriteTimeout(AsyncSocket* socket, EventBase* eventBase)
 612       : AsyncTimeout(eventBase)
 613       , socket_(socket) {}
 614
 615     virtual void timeoutExpired() noexcept {
 616       socket_->timeoutExpired();
 617     }
 618
 619    private:
 620     AsyncSocket* socket_;
 621   };
 622
 623   class IoHandler : public EventHandler {
 624    public:
 625     IoHandler(AsyncSocket* socket, EventBase* eventBase)
 626       : EventHandler(eventBase, -1)
 627       , socket_(socket) {}
 628     IoHandler(AsyncSocket* socket, EventBase* eventBase, int fd)
 629       : EventHandler(eventBase, fd)
 630       , socket_(socket) {}
 631
 632     virtual void handlerReady(uint16_t events) noexcept {
 633       socket_->ioReady(events);
 634     }
 635
 636    private:
 637     AsyncSocket* socket_;
 638   };
 639
 640   void init();
 641
 642   class ImmediateReadCB : public folly::EventBase::LoopCallback {
 643    public:
 644     explicit ImmediateReadCB(AsyncSocket* socket) : socket_(socket) {}
 645     void runLoopCallback() noexcept override {
 646       DestructorGuard dg(socket_);
 647       socket_->checkForImmediateRead();
 648     }
 649    private:
 650     AsyncSocket* socket_;
 651   };
 652
 653   /**
 654    * Schedule checkForImmediateRead to be executed in the next loop
 655    * iteration.
 656    */
 657   void scheduleImmediateRead() noexcept {
 658     if (good()) {
 659       eventBase_->runInLoop(&immediateReadHandler_);
 660     }
 661   }
 662
 663   // event notification methods
 664   void ioReady(uint16_t events) noexcept;
 665   virtual void checkForImmediateRead() noexcept;
 666   virtual void handleInitialReadWrite() noexcept;
 667   virtual void prepareReadBuffer(void** buf, size_t* buflen) noexcept;
 668   virtual void handleRead() noexcept;
 669   virtual void handleWrite() noexcept;
 670   virtual void handleConnect() noexcept;
 671   void timeoutExpired() noexcept;
 672
 673   /**
 674    * Attempt to read from the socket.
 675    *
 676    * @param buf      The buffer to read data into.
 677    * @param buflen   The length of the buffer.
 678    *
 679    * @return Returns the number of bytes read, or READ_EOF on EOF, or
 680    * READ_ERROR on error, or READ_BLOCKING if the operation will
 681    * block.
 682    */
 683   virtual ssize_t performRead(void** buf, size_t* buflen, size_t* offset);
 684
 685   /**
 686    * Populate an iovec array from an IOBuf and attempt to write it.
 687    *
 688    * @param callback Write completion/error callback.
 689    * @param vec      Target iovec array; caller retains ownership.
 690    * @param count    Number of IOBufs to write, beginning at start of buf.
 691    * @param buf      Chain of iovecs.
 692    * @param flags    set of flags for the underlying write calls, like cork
 693    */
 694   void writeChainImpl(WriteCallback* callback, iovec* vec,
 695                       size_t count, std::unique_ptr<folly::IOBuf>&& buf,
 696                       WriteFlags flags);
 697
 698   /**
 699    * Write as much data as possible to the socket without blocking,
 700    * and queue up any leftover data to send when the socket can
 701    * handle writes again.
 702    *
 703    * @param callback The callback to invoke when the write is completed.
 704    * @param vec      Array of buffers to write; this method will make a
 705    *                 copy of the vector (but not the buffers themselves)
 706    *                 if the write has to be completed asynchronously.
 707    * @param count    Number of elements in vec.
 708    * @param buf      The IOBuf that manages the buffers referenced by
 709    *                 vec, or a pointer to nullptr if the buffers are not
 710    *                 associated with an IOBuf.  Note that ownership of
 711    *                 the IOBuf is transferred here; upon completion of
 712    *                 the write, the AsyncSocket deletes the IOBuf.
 713    * @param flags    Set of write flags.
 714    */
 715   void writeImpl(WriteCallback* callback, const iovec* vec, size_t count,
 716                  std::unique_ptr<folly::IOBuf>&& buf,
 717                  WriteFlags flags = WriteFlags::NONE);
 718
 719   /**
 720    * Attempt to write to the socket.
 721    *
 722    * @param vec             The iovec array pointing to the buffers to write.
 723    * @param count           The length of the iovec array.
 724    * @param flags           Set of write flags.
 725    * @param countWritten    On return, the value pointed to by this parameter
 726    *                          will contain the number of iovec entries that were
 727    *                          fully written.
 728    * @param partialWritten  On return, the value pointed to by this parameter
 729    *                          will contain the number of bytes written in the
 730    *                          partially written iovec entry.
 731    *
 732    * @return Returns the total number of bytes written, or -1 on error.  If no
 733    *     data can be written immediately, 0 is returned.
 734    */
 735   virtual ssize_t performWrite(const iovec* vec, uint32_t count,
 736                                WriteFlags flags, uint32_t* countWritten,
 737                                uint32_t* partialWritten);
 738
 739   bool updateEventRegistration();
 740
 741   /**
 742    * Update event registration.
 743    *
 744    * @param enable Flags of events to enable. Set it to 0 if no events
 745    * need to be enabled in this call.
 746    * @param disable Flags of events
 747    * to disable. Set it to 0 if no events need to be disabled in this
 748    * call.
 749    *
 750    * @return true iff the update is successful.
 751    */
 752   bool updateEventRegistration(uint16_t enable, uint16_t disable);
 753
 754   // Actually close the file descriptor and set it to -1 so we don't
 755   // accidentally close it again.
 756   void doClose();
 757
 758   // error handling methods
 759   void startFail();
 760   void finishFail();
 761   void fail(const char* fn, const AsyncSocketException& ex);
 762   void failConnect(const char* fn, const AsyncSocketException& ex);
 763   void failRead(const char* fn, const AsyncSocketException& ex);
 764   void failWrite(const char* fn, WriteCallback* callback, size_t bytesWritten,
 765                  const AsyncSocketException& ex);
 766   void failWrite(const char* fn, const AsyncSocketException& ex);
 767   void failAllWrites(const AsyncSocketException& ex);
 768   void invokeConnectErr(const AsyncSocketException& ex);
 769   void invokeConnectSuccess();
 770   void invalidState(ConnectCallback* callback);
 771   void invalidState(ReadCallback* callback);
 772   void invalidState(WriteCallback* callback);
 773
 774   std::string withAddr(const std::string& s);
 775
 776   /**
 777    * Set TCP_CORK on this socket
 778    *
 779    * @return 0 if Cork is turned on, or non-zero errno on error
 780    */
 781   int setCork(bool cork);
 782
 783   StateEnum state_;                     ///< StateEnum describing current state
 784   uint8_t shutdownFlags_;               ///< Shutdown state (ShutdownFlags)
 785   uint16_t eventFlags_;                 ///< EventBase::HandlerFlags settings
 786   int fd_;                              ///< The socket file descriptor
 787   mutable
 788     folly::SocketAddress addr_;    ///< The address we tried to connect to
 789   uint32_t sendTimeout_;                ///< The send timeout, in milliseconds
 790   uint16_t maxReadsPerEvent_;           ///< Max reads per event loop iteration
 791   EventBase* eventBase_;               ///< The EventBase
 792   WriteTimeout writeTimeout_;           ///< A timeout for connect and write
 793   IoHandler ioHandler_;                 ///< A EventHandler to monitor the fd
 794   ImmediateReadCB immediateReadHandler_; ///< LoopCallback for checking read
 795
 796   ConnectCallback* connectCallback_;    ///< ConnectCallback
 797   ReadCallback* readCallback_;          ///< ReadCallback
 798   WriteRequest* writeReqHead_;          ///< Chain of WriteRequests
 799   WriteRequest* writeReqTail_;          ///< End of WriteRequest chain
 800   ShutdownSocketSet* shutdownSocketSet_;
 801   size_t appBytesReceived_;             ///< Num of bytes received from socket
 802   size_t appBytesWritten_;              ///< Num of bytes written to socket
 803   bool isBufferMovable_{false};
 804
 805   bool peek_{false}; // Peek bytes.
 806
 807   int8_t readErr_{READ_NO_ERROR};      ///< The read error encountered, if any.
 808
 809   std::chrono::steady_clock::time_point connectStartTime_;
 810   std::chrono::steady_clock::time_point connectEndTime_;
 811
 812   // Whether this connection is persistently corked
 813   bool persistentCork_{false};
 814   // Whether we've applied the TCP_CORK option to the socket
 815   bool corked_{false};
 816 };
 817
 818
 819 } // folly