Method accept

3rdparty/libprocess/src/ssl/openssl_socket.cpp:545–656

Future<std::shared_ptr<SocketImpl>> OpenSSLSocketImpl::accept()
{
  if (!accept_loop_started.once()) {
    // Hold a weak pointer since we do not want this accept loop to extend
    // the lifetime of `this` unnecessarily.
    std::weak_ptr<OpenSSLSocketImpl> weak_self(shared(this));

    // We start accepting incoming connections in a loop here because a socket
    // must complete the SSL handshake (or be downgraded) before the socket is
    // considered ready. In case the incoming socket never writes any data,
    // we do not wait for the accept logic to complete before accepting a
    // new socket.
    process::loop(
        compute_thread,
        [weak_self]() -> Future<std::shared_ptr<SocketImpl>> {
          std::shared_ptr<OpenSSLSocketImpl> self(weak_self.lock());

          if (self == nullptr) {
            return Failure("Socket destructed");
          }

          return self->PollSocketImpl::accept();
        },
        [weak_self](const std::shared_ptr<SocketImpl>& socket)
            -> Future<ControlFlow<Nothing>> {
          std::shared_ptr<OpenSSLSocketImpl> self(weak_self.lock());

          if (self == nullptr) {
            return Break();
          }

          // If we support downgrading the connection, first wait for this
          // socket to become readable. We will then MSG_PEEK it to test
          // whether we want to dispatch as SSL or non-SSL.
          if (openssl::flags().support_downgrade) {
            io::poll(socket->get(), process::io::READ)
              .onReady([weak_self, socket]() {
                std::shared_ptr<OpenSSLSocketImpl> self(weak_self.lock());

                if (self == nullptr) {
                  return;
                }

                char data[6];

                // Try to peek the first 6 bytes of the message.
                ssize_t size = ::recv(socket->get(), data, 6, MSG_PEEK);

                // Based on the function 'ssl23_get_client_hello' in openssl, we
                // test whether to dispatch to the SSL or non-SSL based accept
                // based on the following rules:
                //   1. If there are fewer than 3 bytes: non-SSL.
                //   2. If the 1st bit of the 1st byte is set AND the 3rd byte
                //      is equal to SSL2_MT_CLIENT_HELLO: SSL.
                //   3. If the 1st byte is equal to SSL3_RT_HANDSHAKE AND the
                //      2nd byte is equal to SSL3_VERSION_MAJOR and the 6th byte
                //      is equal to SSL3_MT_CLIENT_HELLO: SSL.
                //   4. Otherwise: non-SSL.