tor-browser

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

NeqoHttp3Conn.h (11072B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #ifndef NeqoHttp3Conn_h__
      6 #define NeqoHttp3Conn_h__
      7 
      8 #include <cstdint>
      9 #include "mozilla/net/neqo_glue_ffi_generated.h"
     10 
     11 namespace mozilla {
     12 namespace net {
     13 
     14 class NeqoHttp3Conn final {
     15 public:
     16  static nsresult InitUseNSPRForIO(
     17      const nsACString& aOrigin, const nsACString& aAlpn,
     18      const NetAddr& aLocalAddr, const NetAddr& aRemoteAddr,
     19      uint32_t aMaxTableSize, uint16_t aMaxBlockedStreams, uint64_t aMaxData,
     20      uint64_t aMaxStreamData, bool aVersionNegotiation, bool aWebTransport,
     21      const nsACString& aQlogDir, uint32_t aProviderFlags,
     22      uint32_t aIdleTimeout, NeqoHttp3Conn** aConn) {
     23    return neqo_http3conn_new_use_nspr_for_io(
     24        &aOrigin, &aAlpn, &aLocalAddr, &aRemoteAddr, aMaxTableSize,
     25        aMaxBlockedStreams, aMaxData, aMaxStreamData, aVersionNegotiation,
     26        aWebTransport, &aQlogDir, aProviderFlags, aIdleTimeout,
     27        (const mozilla::net::NeqoHttp3Conn**)aConn);
     28  }
     29 
     30  static nsresult Init(const nsACString& aOrigin, const nsACString& aAlpn,
     31                       const NetAddr& aLocalAddr, const NetAddr& aRemoteAddr,
     32                       uint32_t aMaxTableSize, uint16_t aMaxBlockedStreams,
     33                       uint64_t aMaxData, uint64_t aMaxStreamData,
     34                       bool aVersionNegotiation, bool aWebTransport,
     35                       const nsACString& aQlogDir, uint32_t aProviderFlags,
     36                       uint32_t aIdleTimeout, int64_t socket,
     37                       bool aPMTUDEnabled, NeqoHttp3Conn** aConn) {
     38    return neqo_http3conn_new(
     39        &aOrigin, &aAlpn, &aLocalAddr, &aRemoteAddr, aMaxTableSize,
     40        aMaxBlockedStreams, aMaxData, aMaxStreamData, aVersionNegotiation,
     41        aWebTransport, &aQlogDir, aProviderFlags, aIdleTimeout, socket,
     42        aPMTUDEnabled, (const mozilla::net::NeqoHttp3Conn**)aConn);
     43  }
     44 
     45  void Close(uint64_t aError) { neqo_http3conn_close(this, aError); }
     46 
     47  nsresult GetSecInfo(NeqoSecretInfo* aSecInfo) {
     48    return neqo_http3conn_tls_info(this, aSecInfo);
     49  }
     50 
     51  nsresult PeerCertificateInfo(NeqoCertificateInfo* aCertInfo) {
     52    return neqo_http3conn_peer_certificate_info(this, aCertInfo);
     53  }
     54 
     55  void PeerAuthenticated(PRErrorCode aError) {
     56    neqo_http3conn_authenticated(this, aError);
     57  }
     58 
     59  nsresult ProcessInputUseNSPRForIO(const NetAddr& aRemoteAddr,
     60                                    const nsTArray<uint8_t>& aPacket) {
     61    return neqo_http3conn_process_input_use_nspr_for_io(this, &aRemoteAddr,
     62                                                        &aPacket);
     63  }
     64 
     65  ProcessInputResult ProcessInput() {
     66    return neqo_http3conn_process_input(this);
     67  }
     68 
     69  nsresult ProcessOutputAndSendUseNSPRForIO(void* aContext, SendFunc aSendFunc,
     70                                            SetTimerFunc aSetTimerFunc) {
     71    return neqo_http3conn_process_output_and_send_use_nspr_for_io(
     72        this, aContext, aSendFunc, aSetTimerFunc);
     73  }
     74 
     75  ProcessOutputAndSendResult ProcessOutputAndSend(void* aContext,
     76                                                  SetTimerFunc aSetTimerFunc) {
     77    return neqo_http3conn_process_output_and_send(this, aContext,
     78                                                  aSetTimerFunc);
     79  }
     80 
     81  nsresult GetEvent(Http3Event* aEvent, nsTArray<uint8_t>& aData) {
     82    return neqo_http3conn_event(this, aEvent, &aData);
     83  }
     84 
     85  nsresult Fetch(const nsACString& aMethod, const nsACString& aScheme,
     86                 const nsACString& aHost, const nsACString& aPath,
     87                 const nsACString& aHeaders, uint64_t* aStreamId,
     88                 uint8_t aUrgency, bool aIncremental) {
     89    return neqo_http3conn_fetch(this, &aMethod, &aScheme, &aHost, &aPath,
     90                                &aHeaders, aStreamId, aUrgency, aIncremental);
     91  }
     92 
     93  nsresult Connect(const nsACString& aHost, const nsACString& aHeaders,
     94                   uint64_t* aStreamId, uint8_t aUrgency, bool aIncremental) {
     95    return neqo_http3conn_connect(this, &aHost, &aHeaders, aStreamId, aUrgency,
     96                                  aIncremental);
     97  }
     98 
     99  nsresult PriorityUpdate(uint64_t aStreamId, uint8_t aUrgency,
    100                          bool aIncremental) {
    101    return neqo_http3conn_priority_update(this, aStreamId, aUrgency,
    102                                          aIncremental);
    103  }
    104 
    105  nsresult SendRequestBody(uint64_t aStreamId, const uint8_t* aBuf,
    106                           uint32_t aCount, uint32_t* aCountRead) {
    107    return neqo_htttp3conn_send_request_body(this, aStreamId, aBuf, aCount,
    108                                             aCountRead);
    109  }
    110 
    111  // This closes only the sending side of a stream.
    112  nsresult CloseStream(uint64_t aStreamId) {
    113    return neqo_http3conn_close_stream(this, aStreamId);
    114  }
    115 
    116  nsresult ReadResponseData(uint64_t aStreamId, uint8_t* aBuf, uint32_t aLen,
    117                            uint32_t* aRead, bool* aFin) {
    118    return neqo_http3conn_read_response_data(this, aStreamId, aBuf, aLen, aRead,
    119                                             aFin);
    120  }
    121 
    122  void CancelFetch(uint64_t aStreamId, uint64_t aError) {
    123    neqo_http3conn_cancel_fetch(this, aStreamId, aError);
    124  }
    125 
    126  void ResetStream(uint64_t aStreamId, uint64_t aError) {
    127    neqo_http3conn_reset_stream(this, aStreamId, aError);
    128  }
    129 
    130  void StreamStopSending(uint64_t aStreamId, uint64_t aError) {
    131    neqo_http3conn_stream_stop_sending(this, aStreamId, aError);
    132  }
    133 
    134  void SetResumptionToken(nsTArray<uint8_t>& aToken) {
    135    neqo_http3conn_set_resumption_token(this, &aToken);
    136  }
    137 
    138  void SetEchConfig(nsTArray<uint8_t>& aEchConfig) {
    139    neqo_http3conn_set_ech_config(this, &aEchConfig);
    140  }
    141 
    142  bool IsZeroRtt() { return neqo_http3conn_is_zero_rtt(this); }
    143 
    144  void AddRef() { neqo_http3conn_addref(this); }
    145  void Release() { neqo_http3conn_release(this); }
    146 
    147  void GetStats(Http3Stats* aStats) {
    148    return neqo_http3conn_get_stats(this, aStats);
    149  }
    150 
    151  nsresult CreateWebTransport(const nsACString& aHost, const nsACString& aPath,
    152                              const nsACString& aHeaders,
    153                              uint64_t* aSessionId) {
    154    return neqo_http3conn_webtransport_create_session(this, &aHost, &aPath,
    155                                                      &aHeaders, aSessionId);
    156  }
    157 
    158  nsresult CreateConnectUdp(const nsACString& aHost, const nsACString& aPath,
    159                            const nsACString& aHeaders, uint64_t* aSessionId) {
    160    return neqo_http3conn_connect_udp_create_session(this, &aHost, &aPath,
    161                                                     &aHeaders, aSessionId);
    162  }
    163 
    164  nsresult CloseWebTransport(uint64_t aSessionId, uint32_t aError,
    165                             const nsACString& aMessage) {
    166    return neqo_http3conn_webtransport_close_session(this, aSessionId, aError,
    167                                                     &aMessage);
    168  }
    169 
    170  nsresult CloseConnectUdp(uint64_t aSessionId, uint32_t aError,
    171                           const nsACString& aMessage) {
    172    return neqo_http3conn_connect_udp_close_session(this, aSessionId, aError,
    173                                                    &aMessage);
    174  }
    175 
    176  nsresult CreateWebTransportStream(uint64_t aSessionId,
    177                                    WebTransportStreamType aStreamType,
    178                                    uint64_t* aStreamId) {
    179    return neqo_http3conn_webtransport_create_stream(this, aSessionId,
    180                                                     aStreamType, aStreamId);
    181  }
    182 
    183  nsresult WebTransportSendDatagram(uint64_t aSessionId,
    184                                    nsTArray<uint8_t>& aData,
    185                                    uint64_t aTrackingId) {
    186    return neqo_http3conn_webtransport_send_datagram(this, aSessionId, &aData,
    187                                                     aTrackingId);
    188  }
    189 
    190  nsresult ConnectUdpSendDatagram(uint64_t aSessionId, nsTArray<uint8_t>& aData,
    191                                  uint64_t aTrackingId) {
    192    return neqo_http3conn_connect_udp_send_datagram(this, aSessionId, &aData,
    193                                                    aTrackingId);
    194  }
    195 
    196  nsresult WebTransportMaxDatagramSize(uint64_t aSessionId, uint64_t* aResult) {
    197    return neqo_http3conn_webtransport_max_datagram_size(this, aSessionId,
    198                                                         aResult);
    199  }
    200 
    201  nsresult WebTransportSetSendOrder(uint64_t aSessionId,
    202                                    Maybe<int64_t> aSendOrder) {
    203    return neqo_http3conn_webtransport_set_sendorder(this, aSessionId,
    204                                                     aSendOrder.ptrOr(nullptr));
    205  }
    206 
    207 private:
    208  NeqoHttp3Conn() = delete;
    209  ~NeqoHttp3Conn() = delete;
    210  NeqoHttp3Conn(const NeqoHttp3Conn&) = delete;
    211  NeqoHttp3Conn& operator=(const NeqoHttp3Conn&) = delete;
    212 };
    213 
    214 class NeqoEncoder final {
    215 public:
    216  static void Init(NeqoEncoder** aEncoder) {
    217    neqo_encoder_new((const mozilla::net::NeqoEncoder**)aEncoder);
    218  }
    219 
    220  void EncodeByte(uint8_t aData) { neqo_encode_byte(this, aData); }
    221 
    222  void EncodeVarint(uint64_t aData) { neqo_encode_varint(this, aData); }
    223 
    224  void EncodeUint(uint32_t aSize, uint64_t aData) {
    225    neqo_encode_uint(this, aSize, aData);
    226  }
    227 
    228  void EncodeBuffer(const uint8_t* aBuf, uint32_t aCount) {
    229    neqo_encode_buffer(this, aBuf, aCount);
    230  }
    231 
    232  void EncodeBufferWithVarintLen(const uint8_t* aBuf, uint32_t aCount) {
    233    neqo_encode_vvec(this, aBuf, aCount);
    234  }
    235 
    236  void GetData(const uint8_t** aBuf, uint32_t* aLength) {
    237    return neqo_encode_get_data(this, aBuf, aLength);
    238  }
    239 
    240  static size_t VarintLength(uint64_t aValue) {
    241    return neqo_encode_varint_len(aValue);
    242  }
    243 
    244  void AddRef() { neqo_encoder_addref(this); }
    245  void Release() { neqo_encoder_release(this); }
    246 
    247 private:
    248  NeqoEncoder() = delete;
    249  ~NeqoEncoder() = delete;
    250  NeqoEncoder(const NeqoEncoder&) = delete;
    251  NeqoEncoder& operator=(const NeqoEncoder&) = delete;
    252 };
    253 
    254 class NeqoDecoder final {
    255 public:
    256  static void Init(const uint8_t* aBuf, uint32_t aCount,
    257                   NeqoDecoder** aDecoder) {
    258    neqo_decoder_new(aBuf, aCount, (const mozilla::net::NeqoDecoder**)aDecoder);
    259  }
    260 
    261  bool DecodeVarint(uint64_t* aResult) {
    262    return neqo_decode_varint(this, aResult);
    263  }
    264 
    265  bool DecodeUint32(uint32_t* aResult) {
    266    return neqo_decode_uint32(this, aResult);
    267  }
    268 
    269  bool Decode(uint32_t aCount, const uint8_t** aBuf, uint32_t* aLength) {
    270    return neqo_decode(this, aCount, aBuf, aLength);
    271  }
    272 
    273  void DecodeRemainder(const uint8_t** aBuf, uint32_t* aLength) {
    274    neqo_decode_remainder(this, aBuf, aLength);
    275  }
    276 
    277  uint64_t Remaining() { return neqo_decoder_remaining(this); }
    278 
    279  uint64_t Offset() { return neqo_decoder_offset(this); }
    280 
    281  void AddRef() { neqo_decoder_addref(this); }
    282  void Release() { neqo_decoder_release(this); }
    283 
    284 private:
    285  NeqoDecoder() = delete;
    286  ~NeqoDecoder() = delete;
    287  NeqoDecoder(const NeqoDecoder&) = delete;
    288  NeqoDecoder& operator=(const NeqoDecoder&) = delete;
    289 };
    290 
    291 }  // namespace net
    292 }  // namespace mozilla
    293 
    294 #endif