fizz::server::detail Namespace Reference

Enumerations
enum	CookieHasGroup : uint8_t { No = 0, Yes = 1 }

Functions
template<typename... Args>
Actions	actions (Args &&...act)
Buf	encodeCookie (const CookieState &state)
CookieState	decodeCookie (Buf cookie)
AsyncActions	processEvent (const State &state, Param param)
Actions	handleError (const State &state, ReportError error, Optional< AlertDescription > alertDesc)
Actions	handleAppClose (const State &state)
Actions	handleInvalidEvent (const State &state, Event event, Param param)

Enumeration Type Documentation

enum fizz::server::detail::CookieHasGroup : uint8_t

Enumerator
No
Yes

Definition at line 15 of file AeadCookieCipher-inl.h.

                    : uint8_t {
  No = 0,
  Yes = 1,
};

Function Documentation

template<typename... Args>

Actions fizz::server::detail::actions

(

Args &&...

act

)

Definition at line 57 of file Actions.h.

References fizz::detail::addAction().

Referenced by fizz::server::test::actions(), fizz::server::test::AsyncFizzServerTest::expectAppClose(), fizz::sm::generateTicket(), fizz::sm::getCertificateRequest(), handleAppClose(), handleError(), handleInvalidEvent(), fizz::server::FizzServer< ActionMoveVisitor, SM >::newTransportData(), processEvent(), fizz::server::ServerStateMachine::processSocketData(), and fizz::server::test::TEST_F().

                               {
  Actions acts;
  fizz::detail::addAction(acts, std::forward<Args>(act)...);
  return acts;
}

CookieState fizz::server::detail::decodeCookie ( Buf  cookie )

inline

Definition at line 40 of file AeadCookieCipher-inl.h.

References group, fizz::detail::read(), and Yes.

Referenced by fizz::server::AeadCookieCipher< AeadType, HkdfType >::decrypt().

                                            {
  folly::io::Cursor cursor(cookie.get());

  CookieState state;
  fizz::detail::read(state.version, cursor);
  fizz::detail::read(state.cipher, cursor);

  CookieHasGroup hasGroup;
  fizz::detail::read(hasGroup, cursor);
  if (hasGroup == CookieHasGroup::Yes) {
    NamedGroup group;
    fizz::detail::read(group, cursor);
    state.group = group;
  }

  fizz::detail::readBuf<uint16_t>(state.chloHash, cursor);
  fizz::detail::readBuf<uint16_t>(state.appToken, cursor);

  return state;
}

Buf fizz::server::detail::encodeCookie ( const CookieState &  state )

inline

Definition at line 20 of file AeadCookieCipher-inl.h.

References fizz::server::CookieState::appToken, fizz::server::CookieState::chloHash, fizz::server::CookieState::cipher, folly::IOBuf::create(), fizz::server::CookieState::group, No, fizz::server::CookieState::version, fizz::detail::write(), and Yes.

Referenced by fizz::server::AeadCookieCipher< AeadType, HkdfType >::getStatelessResponse().

                                                  {
  auto buf = folly::IOBuf::create(100);
  folly::io::Appender appender(buf.get(), 100);

  fizz::detail::write(state.version, appender);
  fizz::detail::write(state.cipher, appender);

  if (state.group) {
    fizz::detail::write(CookieHasGroup::Yes, appender);
    fizz::detail::write(*state.group, appender);
  } else {
    fizz::detail::write(CookieHasGroup::No, appender);
  }

  fizz::detail::writeBuf<uint16_t>(state.chloHash, appender);
  fizz::detail::writeBuf<uint16_t>(state.appToken, appender);

  return buf;
}

Actions fizz::server::detail::handleAppClose

(

const State &

state

)

Definition at line 243 of file ServerProtocol.cpp.

References actions(), fizz::alert, fizz::close_notify, fizz::WriteToSocket::contents, fizz::server::Error, folly::gen::move, fizz::detail::write(), fizz::WriteRecordLayer::writeAlert(), and fizz::server::State::writeRecordLayer().

Referenced by fizz::server::ServerStateMachine::processAppClose().

                                           {
  auto transition = [](State& newState) {
    newState.state() = StateEnum::Error;
    newState.writeRecordLayer() = nullptr;
    newState.readRecordLayer() = nullptr;
  };
  if (state.writeRecordLayer()) {
    Alert alert(AlertDescription::close_notify);
    WriteToSocket write;
    write.contents.emplace_back(
        state.writeRecordLayer()->writeAlert(std::move(alert)));
    return actions(std::move(transition), std::move(write));
  } else {
    return actions(std::move(transition));
  }
}

Actions fizz::server::detail::handleError	(	const State &	state,
		ReportError	error,
		Optional< AlertDescription >	alertDesc
	)

Definition at line 220 of file ServerProtocol.cpp.

References actions(), fizz::alert, fizz::WriteToSocket::contents, fizz::server::Error, folly::gen::move, fizz::server::State::state(), fizz::detail::write(), fizz::WriteRecordLayer::writeAlert(), and fizz::server::State::writeRecordLayer().

Referenced by processEvent(), and fizz::server::ServerStateMachine::processSocketData().

                                          {
  if (state.state() == StateEnum::Error) {
    return actions();
  }
  auto transition = [](State& newState) {
    newState.state() = StateEnum::Error;
    newState.writeRecordLayer() = nullptr;
    newState.readRecordLayer() = nullptr;
  };
  if (alertDesc && state.writeRecordLayer()) {
    Alert alert(*alertDesc);
    WriteToSocket write;
    write.contents.emplace_back(
        state.writeRecordLayer()->writeAlert(std::move(alert)));
    return actions(std::move(transition), std::move(write), std::move(error));
  } else {
    return actions(std::move(transition), std::move(error));
  }
}

Actions fizz::server::detail::handleInvalidEvent	(	const State &	state,
		Event	event,
		Param	param
	)

Definition at line 260 of file ServerProtocol.cpp.

References folly::netops::accept(), actions(), fizz::Alert, fizz::alert, context, folly::pushmi::executor, folly::gen::move, folly::none, fizz::server::State::state(), fizz::toString(), and fizz::unexpected_message.

                                                                         {
  if (event == Event::Alert) {
    auto& alert = boost::get<Alert>(param);
    throw FizzException(
        folly::to<std::string>(
            "received alert: ",
            toString(alert.description),
            ", in state ",
            toString(state.state())),
        folly::none);
  } else {
    throw FizzException(
        folly::to<std::string>(
            "invalid event: ",
            toString(event),
            ", in state ",
            toString(state.state())),
        AlertDescription::unexpected_message);
  }
}

AsyncActions fizz::server::detail::processEvent	(	const State &	state,
		Param	param
	)

Definition at line 180 of file ServerProtocol.cpp.

References actions(), folly::apply_visitor(), folly::exception_wrapper::get_exception(), fizz::FizzException::getAlert(), fizz::sm::StateMachine< SM >::getHandler(), handleError(), folly::gen::move, fizz::server::State::state(), fizz::unexpected_message, and folly::variant_match().

Referenced by fizz::server::ServerStateMachine::processAccept(), fizz::server::ServerStateMachine::processAppWrite(), fizz::server::ServerStateMachine::processEarlyAppWrite(), fizz::server::ServerStateMachine::processSocketData(), and fizz::server::ServerStateMachine::processWriteNewSessionTicket().

                                                           {
  auto event = boost::apply_visitor(EventVisitor(), param);
  // We can have an exception directly in the handler or in a future so we need
  // to handle both types.
  try {
    auto actions = sm::StateMachine<ServerTypes>::getHandler(
        state.state(), event)(state, std::move(param));

    return folly::variant_match(
        actions,
        [&state](folly::Future<Actions>& futureActions) -> AsyncActions {
          return std::move(futureActions)
              .onError([&state](folly::exception_wrapper ew) {
                auto ex = ew.get_exception<FizzException>();
                if (ex) {
                  return detail::handleError(
                      state, ReportError(std::move(ew)), ex->getAlert());
                }
                return detail::handleError(
                    state,
                    ReportError(std::move(ew)),
                    AlertDescription::unexpected_message);
              });
        },
        [](Actions& immediateActions) -> AsyncActions {
          return std::move(immediateActions);
        });
  } catch (const FizzException& e) {
    return detail::handleError(
        state,
        ReportError(folly::exception_wrapper(std::current_exception(), e)),
        e.getAlert());
  } catch (const std::exception& e) {
    return detail::handleError(
        state,
        ReportError(folly::exception_wrapper(std::current_exception(), e)),
        AlertDescription::unexpected_message);
  }
}