proxygen: wangle::TransportInfo Struct Reference

#include <TransportInfo.h>

Public Member Functions
std::chrono::milliseconds	getRttMs () const

bool	initWithSocket (const folly::AsyncSocket *sock)

Static Public Member Functions
static int64_t	readRTT (const folly::AsyncSocket *sock)

Public Attributes
std::chrono::steady_clock::time_point	acceptTime {}

std::chrono::microseconds	rtt {0}

int64_t	rtt_var {-1}

int64_t	rtx {-1}

int64_t	rtx_tm {-1}

int64_t	rto {-1}

int64_t	cwnd {-1}

int64_t	cwndBytes {-1}

int64_t	mss {-1}

int64_t	ssthresh {-1}

std::chrono::milliseconds	setupTime {0}

std::chrono::milliseconds	sslSetupTime {0}

std::shared_ptr< std::string >	sslCipher {nullptr}

std::shared_ptr< std::string >	sslServerName {nullptr}

std::shared_ptr< std::string >	sslClientCiphers {nullptr}

std::shared_ptr< std::string >	sslClientCiphersHex {nullptr}

std::shared_ptr< std::string >	sslClientComprMethods {nullptr}

std::shared_ptr< std::string >	sslClientExts {nullptr}

std::shared_ptr< std::string >	sslClientSigAlgs {nullptr}

std::shared_ptr< std::string >	sslClientSupportedVersions {nullptr}

std::shared_ptr< std::string >	sslSignature {nullptr}

std::shared_ptr< std::string >	sslServerCiphers {nullptr}

std::shared_ptr< std::string >	guessedUserAgent {nullptr}

std::shared_ptr< std::string >	appProtocol {nullptr}

int64_t	totalBytes {0}

std::shared_ptr< folly::SocketAddress >	remoteAddr

std::shared_ptr< folly::SocketAddress >	localAddr

std::shared_ptr< folly::SocketAddress >	clientAddrOriginal

HTTPHeaderSize	ingressHeader

HTTPHeaderSize	egressHeader

int32_t	timeToFirstHeaderByte {-1}

int32_t	timeToFirstByte {-1}

int32_t	timeToLastByte {-1}

int32_t	timeToLastBodyByteAck {-1}

int32_t	lastByteAckLatency {-1}

int32_t	proxyLatency {-1}

int32_t	clientLatency {-1}

int32_t	serverLatency {-1}

int32_t	connectLatency {-1}

uint32_t	egressBodySize {0}

int	tcpinfoErrno {0}

uint32_t	sslSetupBytesWritten {0}

uint32_t	sslSetupBytesRead {0}

std::string	sslError

uint32_t	ingressBodySize {0}

uint16_t	sslVersion {0}

std::shared_ptr< std::string >	sslCertSigAlgName {nullptr}

uint16_t	sslCertSize {0}

uint16_t	statusCode {0}

SSLResumeEnum	sslResume {SSLResumeEnum::NA}

bool	validTcpinfo {false}

bool	secure {false}

std::string	securityType

std::shared_ptr< ProtocolInfo >	protocolInfo {nullptr}

std::shared_ptr< std::string >	tcpSignature {nullptr}

bool	tfoSucceded {false}

folly::Optional< uint8_t >	negotiatedTokenBindingKeyParameters

Detailed Description

Definition at line 61 of file TransportInfo.h.

Member Function Documentation

std::chrono::milliseconds wangle::TransportInfo::getRttMs ( ) const

inline

Definition at line 400 of file TransportInfo.h.

References int64_t.

                                          {
     return std::chrono::duration_cast<std::chrono::milliseconds>(rtt);
   }

bool wangle::TransportInfo::initWithSocket ( const folly::AsyncSocket * sock )

Definition at line 28 of file TransportInfo.cpp.

References cwnd, cwndBytes, mss, rto, rtt, rtt_var, rtx, rtx_tm, ssthresh, tcpinfoErrno, and validTcpinfo.

Referenced by wangle::Acceptor::connectionReady(), and proxygen::HTTPSession::getCurrentTransportInfoWithoutUpdate().

                                                                {
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
   if (!TransportInfo::readTcpInfo(&tcpinfo, sock)) {
     tcpinfoErrno = errno;
     return false;
   }
 #ifdef __APPLE__
   rtt = microseconds(tcpinfo.tcpi_srtt * 1000);
   rtt_var = tcpinfo.tcpi_rttvar * 1000;
   rto = tcpinfo.tcpi_rto * 1000;
   rtx_tm = -1;
   mss = tcpinfo.tcpi_maxseg;
   cwndBytes = tcpinfo.tcpi_snd_cwnd;
   if (mss > 0) {
     cwnd = (cwndBytes + mss - 1) / mss;
   }
 #else
   rtt = microseconds(tcpinfo.tcpi_rtt);
   rtt_var = tcpinfo.tcpi_rttvar;
   rto = tcpinfo.tcpi_rto;
   rtx_tm = tcpinfo.tcpi_retransmits;
   mss = tcpinfo.tcpi_snd_mss;
   cwnd = tcpinfo.tcpi_snd_cwnd;
   cwndBytes = cwnd * mss;
 #endif // __APPLE__
   ssthresh = tcpinfo.tcpi_snd_ssthresh;
 #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 17
   rtx = tcpinfo.tcpi_total_retrans;
 #else
   rtx = -1;
 #endif  // __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 17
   validTcpinfo = true;
 #else
   tcpinfoErrno = EINVAL;
   rtt = microseconds(-1);
   rtt_var = -1;
   rtx = -1;
   rtx_tm = -1;
   rto = -1;
   cwnd = -1;
   mss = -1;
   ssthresh = -1;
 #endif
   return true;
 }

int64_t wangle::TransportInfo::readRTT ( const folly::AsyncSocket * sock )

static

Definition at line 74 of file TransportInfo.cpp.

References folly::AsyncSocket::getFd(), and folly::netops::getsockopt().

                                                            {
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
   tcp_info tcpinfo;
   if (!TransportInfo::readTcpInfo(&tcpinfo, sock)) {
     return -1;
   }
 #endif
 #if defined(__linux__) || defined(__FreeBSD__)
   return tcpinfo.tcpi_rtt;
 #elif defined(__APPLE__)
   return tcpinfo.tcpi_srtt;
 #else
   return -1;
 #endif
 }