tor-browser

DashboardTypes.h (8316B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_net_DashboardTypes_h_
#define mozilla_net_DashboardTypes_h_

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsHttp.h"
#include "nsString.h"
#include "nsTArray.h"

namespace mozilla {
namespace net {

struct SocketInfo {
 nsCString host;
 uint64_t sent;
 uint64_t received;
 uint16_t port;
 bool active;
 nsCString type;
};

inline bool operator==(const SocketInfo& a, const SocketInfo& b) {
 return a.host == b.host && a.sent == b.sent && a.received == b.received &&
        a.port == b.port && a.active == b.active && a.type == b.type;
}

struct DnsAndConnectSockets {
 bool speculative;
};

struct DNSCacheEntries {
 nsCString hostname;
 nsTArray<nsCString> hostaddr;
 uint16_t family{0};
 int64_t expiration{0};
 bool TRR{false};
 nsCString originAttributesSuffix;
 nsCString flags;
 uint16_t resolveType{0};
};

struct HttpConnInfo {
 uint32_t ttl;
 uint32_t rtt;
 nsString protocolVersion;

 void SetHTTPProtocolVersion(HttpVersion pv);
};

struct HttpRetParams {
 nsCString host;
 CopyableTArray<HttpConnInfo> active;
 CopyableTArray<HttpConnInfo> idle;
 CopyableTArray<DnsAndConnectSockets> dnsAndSocks;
 uint32_t counter;
 uint16_t port;
 nsCString httpVersion;
 bool ssl;
};

struct Http3ConnStats {
 // Total packets received, including all the bad ones.
 uint64_t packetsRx;
 // Duplicate packets received.
 uint64_t dupsRx;
 // Dropped packets or dropped garbage.
 uint64_t droppedRx;
 // The number of packet that were saved for later processing.
 uint64_t savedDatagrams;
 // Total packets sent.
 uint64_t packetsTx;
 // Total number of packets that are declared lost.
 uint64_t lost;
 // Late acknowledgments, for packets that were declared lost already.
 uint64_t lateAck;
 // Acknowledgments for packets that contained data that was marked
 // for retransmission when the PTO timer popped.
 uint64_t ptoAck;
 // Count PTOs. Single PTOs, 2 PTOs in a row, 3 PTOs in row, etc. are counted
 // separately.
 CopyableTArray<uint64_t> ptoCounts;
 // The count of WouldBlock errors encountered during receive operations.
 uint64_t wouldBlockRx;
 // The count of WouldBlock errors encountered during transmit operations.
 uint64_t wouldBlockTx;
};

struct Http3ConnectionStatsParams {
 nsCString host;
 uint16_t port;
 CopyableTArray<Http3ConnStats> stats;
};

}  // namespace net
}  // namespace mozilla

namespace IPC {

template <>
struct ParamTraits<mozilla::net::SocketInfo> {
 typedef mozilla::net::SocketInfo paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.host);
   WriteParam(aWriter, aParam.sent);
   WriteParam(aWriter, aParam.received);
   WriteParam(aWriter, aParam.port);
   WriteParam(aWriter, aParam.active);
   WriteParam(aWriter, aParam.type);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->host) &&
          ReadParam(aReader, &aResult->sent) &&
          ReadParam(aReader, &aResult->received) &&
          ReadParam(aReader, &aResult->port) &&
          ReadParam(aReader, &aResult->active) &&
          ReadParam(aReader, &aResult->type);
 }
};

template <>
struct ParamTraits<mozilla::net::DNSCacheEntries> {
 typedef mozilla::net::DNSCacheEntries paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.hostname);
   WriteParam(aWriter, aParam.hostaddr);
   WriteParam(aWriter, aParam.family);
   WriteParam(aWriter, aParam.expiration);
   WriteParam(aWriter, aParam.TRR);
   WriteParam(aWriter, aParam.originAttributesSuffix);
   WriteParam(aWriter, aParam.flags);
   WriteParam(aWriter, aParam.resolveType);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->hostname) &&
          ReadParam(aReader, &aResult->hostaddr) &&
          ReadParam(aReader, &aResult->family) &&
          ReadParam(aReader, &aResult->expiration) &&
          ReadParam(aReader, &aResult->TRR) &&
          ReadParam(aReader, &aResult->originAttributesSuffix) &&
          ReadParam(aReader, &aResult->flags) &&
          ReadParam(aReader, &aResult->resolveType);
 }
};

template <>
struct ParamTraits<mozilla::net::DnsAndConnectSockets> {
 typedef mozilla::net::DnsAndConnectSockets paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.speculative);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->speculative);
 }
};

template <>
struct ParamTraits<mozilla::net::HttpConnInfo> {
 typedef mozilla::net::HttpConnInfo paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.ttl);
   WriteParam(aWriter, aParam.rtt);
   WriteParam(aWriter, aParam.protocolVersion);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->ttl) &&
          ReadParam(aReader, &aResult->rtt) &&
          ReadParam(aReader, &aResult->protocolVersion);
 }
};

template <>
struct ParamTraits<mozilla::net::HttpRetParams> {
 typedef mozilla::net::HttpRetParams paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.host);
   WriteParam(aWriter, aParam.active);
   WriteParam(aWriter, aParam.idle);
   WriteParam(aWriter, aParam.dnsAndSocks);
   WriteParam(aWriter, aParam.counter);
   WriteParam(aWriter, aParam.port);
   WriteParam(aWriter, aParam.httpVersion);
   WriteParam(aWriter, aParam.ssl);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->host) &&
          ReadParam(aReader, &aResult->active) &&
          ReadParam(aReader, &aResult->idle) &&
          ReadParam(aReader, &aResult->dnsAndSocks) &&
          ReadParam(aReader, &aResult->counter) &&
          ReadParam(aReader, &aResult->port) &&
          ReadParam(aReader, &aResult->httpVersion) &&
          ReadParam(aReader, &aResult->ssl);
 }
};

template <>
struct ParamTraits<mozilla::net::Http3ConnStats> {
 typedef mozilla::net::Http3ConnStats paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.packetsRx);
   WriteParam(aWriter, aParam.dupsRx);
   WriteParam(aWriter, aParam.droppedRx);
   WriteParam(aWriter, aParam.savedDatagrams);
   WriteParam(aWriter, aParam.packetsTx);
   WriteParam(aWriter, aParam.lost);
   WriteParam(aWriter, aParam.lateAck);
   WriteParam(aWriter, aParam.ptoAck);
   WriteParam(aWriter, aParam.ptoCounts);
   WriteParam(aWriter, aParam.wouldBlockRx);
   WriteParam(aWriter, aParam.wouldBlockTx);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->packetsRx) &&
          ReadParam(aReader, &aResult->dupsRx) &&
          ReadParam(aReader, &aResult->droppedRx) &&
          ReadParam(aReader, &aResult->savedDatagrams) &&
          ReadParam(aReader, &aResult->packetsTx) &&
          ReadParam(aReader, &aResult->lost) &&
          ReadParam(aReader, &aResult->lateAck) &&
          ReadParam(aReader, &aResult->ptoAck) &&
          ReadParam(aReader, &aResult->ptoCounts) &&
          ReadParam(aReader, &aResult->wouldBlockRx) &&
          ReadParam(aReader, &aResult->wouldBlockTx);
 }
};

template <>
struct ParamTraits<mozilla::net::Http3ConnectionStatsParams> {
 typedef mozilla::net::Http3ConnectionStatsParams paramType;

 static void Write(MessageWriter* aWriter, const paramType& aParam) {
   WriteParam(aWriter, aParam.host);
   WriteParam(aWriter, aParam.port);
   WriteParam(aWriter, aParam.stats);
 }

 static bool Read(MessageReader* aReader, paramType* aResult) {
   return ReadParam(aReader, &aResult->host) &&
          ReadParam(aReader, &aResult->port) &&
          ReadParam(aReader, &aResult->stats);
 }
};

}  // namespace IPC

#endif  // mozilla_net_DashboardTypes_h_