tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

Capsule.cpp (4813B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set sw=2 ts=8 et tw=80 : */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "Capsule.h"
      8 #include "CapsuleEncoder.h"
      9 // For Http2Session::LogIO.
     10 #include "Http2Session.h"
     11 
     12 namespace mozilla::net {
     13 
     14 // static
     15 void Capsule::LogBuffer(const uint8_t* aBuffer, uint32_t aLength) {
     16 #ifdef DEBUG
     17  Http2Session::LogIO(nullptr, nullptr, "Capsule",
     18                      reinterpret_cast<const char*>(aBuffer), aLength);
     19 #endif
     20 }
     21 
     22 // static
     23 Capsule Capsule::CloseWebTransportSession(uint32_t aStatus,
     24                                          const nsACString& aReason) {
     25  CloseWebTransportSessionCapsule capsule;
     26  capsule.mStatus = aStatus;
     27  capsule.mReason = aReason;
     28  return Capsule(std::move(capsule));
     29 }
     30 
     31 // static
     32 Capsule Capsule::WebTransportMaxData(uint64_t aValue) {
     33  WebTransportMaxDataCapsule capsule;
     34  capsule.mMaxDataSize = aValue;
     35  return Capsule(std::move(capsule));
     36 }
     37 
     38 // static
     39 Capsule Capsule::WebTransportStreamData(uint64_t aID, bool aFin,
     40                                        nsTArray<uint8_t>&& aData) {
     41  WebTransportStreamDataCapsule capsule;
     42  capsule.mID = aID;
     43  capsule.mFin = aFin;
     44  capsule.mData.AppendElements(std::move(aData));
     45  return Capsule(std::move(capsule));
     46 }
     47 
     48 // static
     49 Capsule Capsule::WebTransportStreamsBlocked(uint64_t aLimit, bool aBidi) {
     50  WebTransportStreamsBlockedCapsule capsule;
     51  capsule.mLimit = aLimit;
     52  capsule.mBidi = aBidi;
     53  return Capsule(std::move(capsule));
     54 }
     55 
     56 // static
     57 Capsule Capsule::WebTransportMaxStreams(uint64_t aLimit, bool aBidi) {
     58  WebTransportMaxStreamsCapsule capsule;
     59  capsule.mLimit = aLimit;
     60  capsule.mBidi = aBidi;
     61  return Capsule(std::move(capsule));
     62 }
     63 
     64 // static
     65 Capsule Capsule::WebTransportStreamDataBlocked(uint64_t aLimit, uint64_t aID) {
     66  WebTransportStreamDataBlockedCapsule capsule;
     67  capsule.mLimit = aLimit;
     68  capsule.mID = aID;
     69  return Capsule(std::move(capsule));
     70 }
     71 
     72 // static
     73 Capsule Capsule::WebTransportMaxStreamData(uint64_t aLimit, uint64_t aID) {
     74  WebTransportMaxStreamDataCapsule capsule;
     75  capsule.mLimit = aLimit;
     76  capsule.mID = aID;
     77  return Capsule(std::move(capsule));
     78 }
     79 
     80 // static
     81 Capsule Capsule::WebTransportDataBlocked(uint64_t aLimit) {
     82  WebTransportDataBlockedCapsule capsule;
     83  capsule.mLimit = aLimit;
     84  return Capsule(std::move(capsule));
     85 }
     86 
     87 // static
     88 Capsule Capsule::WebTransportStopSending(uint64_t aError, uint64_t aID) {
     89  WebTransportStopSendingCapsule capsule;
     90  capsule.mErrorCode = aError;
     91  capsule.mID = aID;
     92  return Capsule(std::move(capsule));
     93 }
     94 
     95 // static
     96 Capsule Capsule::WebTransportResetStream(uint64_t aError, uint64_t aSize,
     97                                         uint64_t aID) {
     98  WebTransportResetStreamCapsule capsule;
     99  capsule.mErrorCode = aError;
    100  capsule.mReliableSize = aSize;
    101  capsule.mID = aID;
    102  return Capsule(std::move(capsule));
    103 }
    104 
    105 // static
    106 Capsule Capsule::WebTransportDatagram(nsTArray<uint8_t>&& aPayload) {
    107  Capsule capsule;
    108  capsule.mCapsule = AsVariant(WebTransportDatagramCapsule());
    109  capsule.mCapsule.as<WebTransportDatagramCapsule>().mPayload.AppendElements(
    110      std::move(aPayload));
    111  return capsule;
    112 }
    113 
    114 // static
    115 Capsule Capsule::Unknown(uint64_t aType, nsTArray<uint8_t>&& aData) {
    116  UnknownCapsule capsule;
    117  capsule.mType = aType;
    118  capsule.mData = std::move(aData);
    119  return Capsule(std::move(capsule));
    120 }
    121 
    122 CapsuleType Capsule::Type() const {
    123  return mCapsule.match(
    124      [](const UnknownCapsule& aCapsule) { return aCapsule.Type(); },
    125      [](const CloseWebTransportSessionCapsule& aCapsule) {
    126        return aCapsule.Type();
    127      },
    128      [](const WebTransportMaxDataCapsule& aCapsule) {
    129        return aCapsule.Type();
    130      },
    131      [](const WebTransportStreamDataCapsule& aCapsule) {
    132        return aCapsule.Type();
    133      },
    134      [](const WebTransportStreamsBlockedCapsule& aCapsule) {
    135        return aCapsule.Type();
    136      },
    137      [](const WebTransportMaxStreamsCapsule& aCapsule) {
    138        return aCapsule.Type();
    139      },
    140      [](const WebTransportStreamDataBlockedCapsule& aCapsule) {
    141        return aCapsule.Type();
    142      },
    143      [](const WebTransportMaxStreamDataCapsule& aCapsule) {
    144        return aCapsule.Type();
    145      },
    146      [](const WebTransportDataBlockedCapsule& aCapsule) {
    147        return aCapsule.Type();
    148      },
    149      [](const WebTransportStopSendingCapsule& aCapsule) {
    150        return aCapsule.Type();
    151      },
    152      [](const WebTransportResetStreamCapsule& aCapsule) {
    153        return aCapsule.Type();
    154      },
    155      [](const WebTransportDatagramCapsule& aCapsule) {
    156        return aCapsule.Type();
    157      });
    158 }
    159 
    160 }  // namespace mozilla::net