fizz::client Namespace Reference

Namespaces
	detail
	test

Classes
class	AsyncFizzClientT
class	BasicPskCache
struct	CachedPsk
class	ClientStateMachine
struct	ClientTypes
struct	EarlyDataParams
class	FizzClient
class	FizzClientContext
struct	NewCachedPsk
class	PskCache
struct	ReportEarlyHandshakeSuccess
struct	ReportEarlyWriteFailed
struct	ReportHandshakeSuccess
class	State
class	SynchronizedLruPskCache

Typedefs
using	MutateState = folly::Function< void(State &)>
using	Action = boost::variant< DeliverAppData, WriteToSocket, ReportHandshakeSuccess, ReportEarlyHandshakeSuccess, ReportEarlyWriteFailed, ReportError, MutateState, WaitForData, NewCachedPsk >
using	Actions = std::vector< Action >
using	AsyncFizzClient = AsyncFizzClientT< ClientStateMachine >

Enumerations
enum	EarlyDataRejectionPolicy { EarlyDataRejectionPolicy::FatalConnectionError, EarlyDataRejectionPolicy::AutomaticResend }
enum	StateEnum {   StateEnum::Uninitialized, StateEnum::ExpectingServerHello, StateEnum::ExpectingEncryptedExtensions, StateEnum::ExpectingCertificate,   StateEnum::ExpectingCertificateVerify, StateEnum::ExpectingFinished, StateEnum::Established, StateEnum::Error,   StateEnum::NUM_STATES }
enum	ClientAuthType { ClientAuthType::NotRequested, ClientAuthType::Sent, ClientAuthType::RequestedNoMatch, ClientAuthType::Stored }

Functions
static bool	certIdentityMatch (const Cert *a, const Cert *b)
bool	earlyParametersMatch (const State &state)
std::ostream &	operator<< (std::ostream &os, StateEnum state)
std::ostream &	operator<< (std::ostream &os, ClientAuthType auth)

Typedef Documentation

using fizz::client::Action = typedef boost::variant< DeliverAppData, WriteToSocket, ReportHandshakeSuccess, ReportEarlyHandshakeSuccess, ReportEarlyWriteFailed, ReportError, MutateState, WaitForData, NewCachedPsk>

Definition at line 79 of file Actions.h.

using fizz::client::Actions = typedef std::vector<Action>

Definition at line 81 of file Actions.h.

using fizz::client::AsyncFizzClient = typedef AsyncFizzClientT<ClientStateMachine>

Definition at line 226 of file AsyncFizzClient.h.

using fizz::client::MutateState = typedef folly::Function<void(State&)>

A lambda that should be invoked on State so that modification can be applied.

Definition at line 24 of file Actions.h.

Enumeration Type Documentation

enum fizz::client::ClientAuthType

strong

States for client authentication:

• NotRequested: server did not request client auth
• Sent: server requested client auth and a matching certificate was found
• RequestedNoMatch: server requested client auth but no matching certificate was found
• Stored: client used PSK auth, PSK has an associated client certificate

Enumerator
NotRequested
Sent
RequestedNoMatch
Stored

Definition at line 42 of file State.h.

{ NotRequested, Sent, RequestedNoMatch, Stored };

enum fizz::client::EarlyDataRejectionPolicy

strong

Enumerator
FatalConnectionError	Treat early data rejection as a fatal error. An EARLY_DATA_REJECTED AsyncSocketException will be delivered to the read callback.
AutomaticResend	Automatically resend early data as normal data. Will only be done if the following connection parameters match what was used for early data: Application Protocol TLS Protocol Version TLS Cipher Suite Client Identity Server Identity

Definition at line 16 of file EarlyDataRejectionPolicy.h.

                                    {
  FatalConnectionError,

  AutomaticResend,
};

enum fizz::client::StateEnum

strong

Enumerator
Uninitialized
ExpectingServerHello
ExpectingEncryptedExtensions
ExpectingCertificate
ExpectingCertificateVerify
ExpectingFinished
Established
Error
NUM_STATES

Definition at line 21 of file State.h.

                     {
  Uninitialized,
  ExpectingServerHello,
  ExpectingEncryptedExtensions,
  ExpectingCertificate,
  ExpectingCertificateVerify,
  ExpectingFinished,
  Established,
  Error,
  NUM_STATES
};

Function Documentation

static bool fizz::client::certIdentityMatch ( const Cert *  a, const Cert *  b  )

static

Definition at line 14 of file EarlyDataRejectionPolicy.cpp.

References b, and folly::AsyncTransportCertificate::getIdentity().

Referenced by earlyParametersMatch().

                                                            {
  if (!a || !b) {
    return a == b;
  }

  return a->getIdentity() == b->getIdentity();
}

bool fizz::client::earlyParametersMatch

(

const State &

state

)

Definition at line 22 of file EarlyDataRejectionPolicy.cpp.

References fizz::client::State::alpn(), certIdentityMatch(), fizz::client::State::cipher(), fizz::client::State::clientCert(), fizz::client::State::earlyDataParams(), fizz::client::State::serverCert(), and fizz::client::State::version().

Referenced by fizz::client::AsyncFizzClientT< SM >::handleEarlyReject().

                                              {
  if (*state.version() != state.earlyDataParams()->version) {
    return false;
  }

  if (*state.cipher() != state.earlyDataParams()->cipher) {
    return false;
  }

  if (state.alpn() != state.earlyDataParams()->alpn) {
    return false;
  }

  if (!certIdentityMatch(
          state.serverCert().get(),
          state.earlyDataParams()->serverCert.get())) {
    return false;
  }

  if (!certIdentityMatch(
          state.clientCert().get(),
          state.earlyDataParams()->clientCert.get())) {
    return false;
  }

  return true;
}

std::ostream& fizz::client::operator<< ( std::ostream &  os, StateEnum  state  )

inline

Definition at line 560 of file State.h.

References fizz::toString().

                                                               {
  os << toString(state);
  return os;
}

std::ostream& fizz::client::operator<< ( std::ostream &  os, ClientAuthType  auth  )

inline

Definition at line 565 of file State.h.

References fizz::toString().

                                                                   {
  os << toString(auth);
  return os;
}