fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor Class Reference

Inheritance diagram for fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor:

Public Member Functions
	ActionMoveVisitor (AsyncFizzClientT< SM > &client)
void	operator() (DeliverAppData &)
void	operator() (WriteToSocket &)
void	operator() (ReportEarlyHandshakeSuccess &)
void	operator() (ReportHandshakeSuccess &)
void	operator() (ReportEarlyWriteFailed &)
void	operator() (ReportError &)
void	operator() (WaitForData &)
void	operator() (MutateState &)
void	operator() (NewCachedPsk &)

Private Attributes
AsyncFizzClientT< SM > &	client_

Detailed Description

template<typename SM>
class fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor

Definition at line 164 of file AsyncFizzClient.h.

Constructor & Destructor Documentation

template<typename SM>

fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::ActionMoveVisitor ( AsyncFizzClientT< SM > &  client )

inlineexplicit

Definition at line 166 of file AsyncFizzClient.h.

        : client_(client) {}

Member Function Documentation

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

DeliverAppData &

data

)

Definition at line 396 of file AsyncFizzClient-inl.h.

References fizz::DeliverAppData::data, and folly::gen::move.

                                                                           {
  client_.deliverAppData(std::move(data.data));
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

WriteToSocket &

data

)

Definition at line 401 of file AsyncFizzClient-inl.h.

References fizz::WriteToSocket::callback, fizz::WriteToSocket::contents, fizz::WriteToSocket::flags, i, and folly::gen::move.

                                                                          {
  DCHECK(!data.contents.empty());
  Buf allData = std::move(data.contents.front().data);
  for (size_t i = 1; i < data.contents.size(); ++i) {
    allData->prependChain(std::move(data.contents[i].data));
  }
  client_.transport_->writeChain(data.callback, std::move(allData), data.flags);
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

ReportEarlyHandshakeSuccess &

earlySuccess

)

Definition at line 411 of file AsyncFizzClient-inl.h.

References fizz::client::AsyncFizzClientT< SM >::HandshakeCallback::fizzHandshakeSuccess(), fizz::client::ReportEarlyHandshakeSuccess::maxEarlyDataSize, folly::none, and folly::variant_match().

                                               {
  client_.earlyDataState_ = EarlyDataState();
  client_.earlyDataState_->remainingEarlyData = earlySuccess.maxEarlyDataSize;
  if (client_.callback_) {
    auto cb = *client_.callback_;
    client_.callback_ = folly::none;
    folly::variant_match(
        cb,
        [this](HandshakeCallback* callback) {
          callback->fizzHandshakeSuccess(&client_);
        },
        [](folly::AsyncSocket::ConnectCallback* callback) {
          callback->connectSuccess();
        });
  }
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

ReportHandshakeSuccess &

success

)

Definition at line 457 of file AsyncFizzClient-inl.h.

References fizz::client::ReportHandshakeSuccess::earlyDataAccepted, fizz::client::AsyncFizzClientT< SM >::HandshakeCallback::fizzHandshakeSuccess(), folly::gen::move, folly::none, and folly::variant_match().

                                     {
  client_.cancelHandshakeTimeout();
  if (client_.earlyDataState_) {
    if (!success.earlyDataAccepted) {
      auto ex = client_.handleEarlyReject();
      if (ex) {
        if (client_.pskIdentity_) {
          client_.fizzContext_->removePsk(*client_.pskIdentity_);
        }
        client_.deliverAllErrors(*ex, false);
        client_.transport_->closeNow();
        return;
      }
    }

    while (!client_.earlyDataState_->pendingAppWrites.empty()) {
      auto w = std::move(client_.earlyDataState_->pendingAppWrites.front());
      client_.earlyDataState_->pendingAppWrites.pop_front();
      client_.fizzClient_.appWrite(std::move(w));
    }
    client_.earlyDataState_.clear();
  }
  if (client_.callback_) {
    auto cb = *client_.callback_;
    client_.callback_ = folly::none;
    folly::variant_match(
        cb,
        [this](HandshakeCallback* callback) {
          callback->fizzHandshakeSuccess(&client_);
        },
        [](folly::AsyncSocket::ConnectCallback* callback) {
          callback->connectSuccess();
        });
  }
  if (client_.replaySafetyCallback_) {
    auto callback = client_.replaySafetyCallback_;
    client_.replaySafetyCallback_ = nullptr;
    callback->onReplaySafe();
  }
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

ReportEarlyWriteFailed &

write

)

Definition at line 500 of file AsyncFizzClient-inl.h.

References fizz::EarlyAppWrite::callback, fizz::client::ReportEarlyWriteFailed::write, and folly::AsyncWriter::WriteCallback::writeSuccess().

                                   {
  // If the state machine reports that an early write happened after early data
  // was already rejected, we need to invoke some write callback so that the
  // write isn't leaked. For now we just call writeSuccess and let the actual
  // rejection or early data get sorted out after full handshake success.
  //
  // TODO: buffer these callbacks until full handshake success, and call
  //       writeSuccess/writeErr depending on whether we are treating rejection
  //       as a fatal error.
  if (write.write.callback) {
    write.write.callback->writeSuccess();
  }
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

ReportError &

error

)

Definition at line 516 of file AsyncFizzClient-inl.h.

References fizz::ReportError::error, folly::gen::move, folly::AsyncSocketException::SSL_ERROR, folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                                                                         {
  folly::AsyncSocketException ase(
      folly::AsyncSocketException::SSL_ERROR, error.error.what().toStdString());
  client_.deliverHandshakeError(std::move(error.error));
  client_.deliverAllErrors(ase);
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

WaitForData &

)

Definition at line 524 of file AsyncFizzClient-inl.h.

                                                                   {
  client_.fizzClient_.waitForData();

  if (client_.callback_) {
    // Make sure that the read callback is installed.
    client_.startTransportReads();
  }
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

MutateState &

mutator

)

Definition at line 534 of file AsyncFizzClient-inl.h.

                                                                           {
  mutator(client_.state_);
}

template<typename SM >

void fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()

(

NewCachedPsk &

newCachedPsk

)

Definition at line 539 of file AsyncFizzClient-inl.h.

References folly::gen::move, and fizz::client::NewCachedPsk::psk.

                                {
  if (client_.pskIdentity_) {
    client_.fizzContext_->putPsk(
        *client_.pskIdentity_, std::move(newCachedPsk.psk));
  }
}

Member Data Documentation

template<typename SM>

AsyncFizzClientT<SM>& fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::client_

private

Definition at line 180 of file AsyncFizzClient.h.

---

The documentation for this class was generated from the following files:

• proxygen/fizz/fizz/client/AsyncFizzClient.h
• proxygen/fizz/fizz/client/AsyncFizzClient-inl.h