protocol-quic 0.0.0

data/ext/ngtcp2/examples/client.h

@@ -0,0 +1,192 @@
+/*
+ * ngtcp2
+ *
+ * Copyright (c) 2017 ngtcp2 contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif // HAVE_CONFIG_H
+
+#include <vector>
+#include <deque>
+#include <map>
+#include <string_view>
+#include <memory>
+
+#include <ngtcp2/ngtcp2.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <nghttp3/nghttp3.h>
+
+#include <ev.h>
+
+#include "client_base.h"
+#include "tls_client_context.h"
+#include "tls_client_session.h"
+#include "network.h"
+#include "shared.h"
+#include "template.h"
+
+using namespace ngtcp2;
+
+struct Stream {
+  Stream(const Request &req, int64_t stream_id);
+  ~Stream();
+
+  int open_file(const std::string_view &path);
+
+  Request req;
+  int64_t stream_id;
+  int fd;
+};
+
+class Client;
+
+struct Endpoint {
+  Address addr;
+  ev_io rev;
+  Client *client;
+  int fd;
+};
+
+class Client : public ClientBase {
+public:
+  Client(struct ev_loop *loop, uint32_t client_chosen_version,
+         uint32_t original_version);
+  ~Client();
+
+  int init(int fd, const Address &local_addr, const Address &remote_addr,
+           const char *addr, const char *port, TLSClientContext &tls_ctx);
+  void disconnect();
+
+  int on_read(const Endpoint &ep);
+  int on_write();
+  int write_streams();
+  int feed_data(const Endpoint &ep, const sockaddr *sa, socklen_t salen,
+                const ngtcp2_pkt_info *pi, uint8_t *data, size_t datalen);
+  int handle_expiry();
+  void update_timer();
+  int handshake_completed();
+  int handshake_confirmed();
+  void recv_version_negotiation(const uint32_t *sv, size_t nsv);
+
+  int send_packet(const Endpoint &ep, const ngtcp2_addr &remote_addr,
+                  unsigned int ecn, const uint8_t *data, size_t datalen);
+  int on_stream_close(int64_t stream_id, uint64_t app_error_code);
+  int on_extend_max_streams();
+  int handle_error();
+  int make_stream_early();
+  int change_local_addr();
+  void start_change_local_addr_timer();
+  int update_key(uint8_t *rx_secret, uint8_t *tx_secret,
+                 ngtcp2_crypto_aead_ctx *rx_aead_ctx, uint8_t *rx_iv,
+                 ngtcp2_crypto_aead_ctx *tx_aead_ctx, uint8_t *tx_iv,
+                 const uint8_t *current_rx_secret,
+                 const uint8_t *current_tx_secret, size_t secretlen);
+  int initiate_key_update();
+  void start_key_update_timer();
+  void start_delay_stream_timer();
+
+  int select_preferred_address(Address &selected_addr,
+                               const ngtcp2_preferred_addr *paddr);
+
+  std::optional<Endpoint *> endpoint_for(const Address &remote_addr);
+
+  void set_remote_addr(const ngtcp2_addr &remote_addr);
+
+  int setup_httpconn();
+  int submit_http_request(const Stream *stream);
+  int recv_stream_data(uint32_t flags, int64_t stream_id, const uint8_t *data,
+                       size_t datalen);
+  int acked_stream_data_offset(int64_t stream_id, uint64_t datalen);
+  void http_consume(int64_t stream_id, size_t nconsumed);
+  void http_write_data(int64_t stream_id, const uint8_t *data, size_t datalen);
+  int on_stream_reset(int64_t stream_id);
+  int on_stream_stop_sending(int64_t stream_id);
+  int extend_max_stream_data(int64_t stream_id, uint64_t max_data);
+  int stop_sending(int64_t stream_id, uint64_t app_error_code);
+  int reset_stream(int64_t stream_id, uint64_t app_error_code);
+  int http_stream_close(int64_t stream_id, uint64_t app_error_code);
+
+  void on_send_blocked(const Endpoint &ep, const ngtcp2_addr &remote_addr,
+                       unsigned int ecn, size_t datalen);
+  void start_wev_endpoint(const Endpoint &ep);
+  int send_blocked_packet();
+
+  const std::vector<uint32_t> &get_offered_versions() const;
+
+  bool get_early_data() const;
+  void early_data_rejected();
+
+private:
+  std::vector<Endpoint> endpoints_;
+  Address remote_addr_;
+  ev_io wev_;
+  ev_timer timer_;
+  ev_timer change_local_addr_timer_;
+  ev_timer key_update_timer_;
+  ev_timer delay_stream_timer_;
+  ev_signal sigintev_;
+  struct ev_loop *loop_;
+  std::map<int64_t, std::unique_ptr<Stream>> streams_;
+  std::vector<uint32_t> offered_versions_;
+  nghttp3_conn *httpconn_;
+  // addr_ is the server host address.
+  const char *addr_;
+  // port_ is the server port.
+  const char *port_;
+  // nstreams_done_ is the number of streams opened.
+  size_t nstreams_done_;
+  // nstreams_closed_ is the number of streams get closed.
+  size_t nstreams_closed_;
+  // nkey_update_ is the number of key update occurred.
+  size_t nkey_update_;
+  uint32_t client_chosen_version_;
+  uint32_t original_version_;
+  // early_data_ is true if client attempts to do 0RTT data transfer.
+  bool early_data_;
+  // should_exit_ is true if client should exit rather than waiting
+  // for timeout.
+  bool should_exit_;
+  // should_exit_on_handshake_confirmed_ is true if client should exit
+  // when handshake confirmed.
+  bool should_exit_on_handshake_confirmed_;
+  // handshake_confirmed_ gets true after handshake has been
+  // confirmed.
+  bool handshake_confirmed_;
+
+  struct {
+    bool send_blocked;
+    // blocked field is effective only when send_blocked is true.
+    struct {
+      const Endpoint *endpoint;
+      Address remote_addr;
+      unsigned int ecn;
+      size_t datalen;
+    } blocked;
+    std::array<uint8_t, 64_k> data;
+  } tx_;
+};
+
+#endif // CLIENT_H

data/ext/ngtcp2/examples/client_base.cc

@@ -0,0 +1,202 @@
+/*
+ * ngtcp2
+ *
+ * Copyright (c) 2020 ngtcp2 contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "client_base.h"
+
+#include <cassert>
+#include <array>
+#include <iostream>
+#include <fstream>
+
+#include "debug.h"
+#include "template.h"
+#include "util.h"
+
+using namespace ngtcp2;
+using namespace std::literals;
+
+extern Config config;
+
+static ngtcp2_conn *get_conn(ngtcp2_crypto_conn_ref *conn_ref) {
+  auto c = static_cast<ClientBase *>(conn_ref->user_data);
+  return c->conn();
+}
+
+ClientBase::ClientBase()
+    : conn_ref_{get_conn, this}, qlog_(nullptr), conn_(nullptr) {
+  ngtcp2_connection_close_error_default(&last_error_);
+}
+
+ClientBase::~ClientBase() {
+  if (conn_) {
+    ngtcp2_conn_del(conn_);
+  }
+
+  if (qlog_) {
+    fclose(qlog_);
+  }
+}
+
+int ClientBase::write_transport_params(const char *path,
+                                       const ngtcp2_transport_params *params) {
+  auto f = std::ofstream(path);
+  if (!f) {
+    return -1;
+  }
+
+  f << "initial_max_streams_bidi=" << params->initial_max_streams_bidi << '\n'
+    << "initial_max_streams_uni=" << params->initial_max_streams_uni << '\n'
+    << "initial_max_stream_data_bidi_local="
+    << params->initial_max_stream_data_bidi_local << '\n'
+    << "initial_max_stream_data_bidi_remote="
+    << params->initial_max_stream_data_bidi_remote << '\n'
+    << "initial_max_stream_data_uni=" << params->initial_max_stream_data_uni
+    << '\n'
+    << "initial_max_data=" << params->initial_max_data << '\n'
+    << "active_connection_id_limit=" << params->active_connection_id_limit
+    << '\n'
+    << "max_datagram_frame_size=" << params->max_datagram_frame_size << '\n';
+
+  f.close();
+  if (!f) {
+    return -1;
+  }
+
+  return 0;
+}
+
+int ClientBase::read_transport_params(const char *path,
+                                      ngtcp2_transport_params *params) {
+  auto f = std::ifstream(path);
+  if (!f) {
+    return -1;
+  }
+
+  for (std::string line; std::getline(f, line);) {
+    if (util::istarts_with(line, "initial_max_streams_bidi="sv)) {
+      if (auto n = util::parse_uint(line.c_str() +
+                                    "initial_max_streams_bidi="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_streams_bidi = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "initial_max_streams_uni="sv)) {
+      if (auto n = util::parse_uint(line.c_str() +
+                                    "initial_max_streams_uni="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_streams_uni = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "initial_max_stream_data_bidi_local="sv)) {
+      if (auto n = util::parse_uint(
+              line.c_str() + "initial_max_stream_data_bidi_local="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_stream_data_bidi_local = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "initial_max_stream_data_bidi_remote="sv)) {
+      if (auto n = util::parse_uint(
+              line.c_str() + "initial_max_stream_data_bidi_remote="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_stream_data_bidi_remote = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "initial_max_stream_data_uni="sv)) {
+      if (auto n = util::parse_uint(line.c_str() +
+                                    "initial_max_stream_data_uni="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_stream_data_uni = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "initial_max_data="sv)) {
+      if (auto n =
+              util::parse_uint(line.c_str() + "initial_max_data="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->initial_max_data = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "active_connection_id_limit="sv)) {
+      if (auto n = util::parse_uint(line.c_str() +
+                                    "active_connection_id_limit="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->active_connection_id_limit = *n;
+      }
+      continue;
+    }
+
+    if (util::istarts_with(line, "max_datagram_frame_size="sv)) {
+      if (auto n = util::parse_uint(line.c_str() +
+                                    "max_datagram_frame_size="sv.size());
+          !n) {
+        return -1;
+      } else {
+        params->max_datagram_frame_size = *n;
+      }
+      continue;
+    }
+  }
+
+  return 0;
+}
+
+ngtcp2_conn *ClientBase::conn() const { return conn_; }
+
+void qlog_write_cb(void *user_data, uint32_t flags, const void *data,
+                   size_t datalen) {
+  auto c = static_cast<ClientBase *>(user_data);
+  c->write_qlog(data, datalen);
+}
+
+void ClientBase::write_qlog(const void *data, size_t datalen) {
+  assert(qlog_);
+  fwrite(data, 1, datalen, qlog_);
+}
+
+ngtcp2_crypto_conn_ref *ClientBase::conn_ref() { return &conn_ref_; }

data/ext/ngtcp2/examples/client_base.h

@@ -0,0 +1,213 @@
+/*
+ * ngtcp2
+ *
+ * Copyright (c) 2020 ngtcp2 contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef CLIENT_BASE_H
+#define CLIENT_BASE_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif // HAVE_CONFIG_H
+
+#include <vector>
+#include <deque>
+#include <string>
+#include <string_view>
+#include <functional>
+
+#include <ngtcp2/ngtcp2_crypto.h>
+
+#include "tls_client_session.h"
+#include "network.h"
+#include "shared.h"
+
+using namespace ngtcp2;
+
+struct Request {
+  std::string_view scheme;
+  std::string authority;
+  std::string path;
+};
+
+struct Config {
+  ngtcp2_cid dcid;
+  ngtcp2_cid scid;
+  bool scid_present;
+  // tx_loss_prob is probability of losing outgoing packet.
+  double tx_loss_prob;
+  // rx_loss_prob is probability of losing incoming packet.
+  double rx_loss_prob;
+  // fd is a file descriptor to read input for streams.
+  int fd;
+  // ciphers is the list of enabled ciphers.
+  const char *ciphers;
+  // groups is the list of supported groups.
+  const char *groups;
+  // nstreams is the number of streams to open.
+  size_t nstreams;
+  // data is the pointer to memory region which maps file denoted by
+  // fd.
+  uint8_t *data;
+  // datalen is the length of file denoted by fd.
+  size_t datalen;
+  // version is a QUIC version to use.
+  uint32_t version;
+  // quiet suppresses the output normally shown except for the error
+  // messages.
+  bool quiet;
+  // timeout is an idle timeout for QUIC connection.
+  ngtcp2_duration timeout;
+  // session_file is a path to a file to write, and read TLS session.
+  const char *session_file;
+  // tp_file is a path to a file to write, and read QUIC transport
+  // parameters.
+  const char *tp_file;
+  // show_secret is true if transport secrets should be printed out.
+  bool show_secret;
+  // change_local_addr is the duration after which client changes
+  // local address.
+  ngtcp2_duration change_local_addr;
+  // key_update is the duration after which client initiates key
+  // update.
+  ngtcp2_duration key_update;
+  // delay_stream is the duration after which client sends the first
+  // 1-RTT stream.
+  ngtcp2_duration delay_stream;
+  // nat_rebinding is true if simulated NAT rebinding is enabled.
+  bool nat_rebinding;
+  // no_preferred_addr is true if client do not follow preferred
+  // address offered by server.
+  bool no_preferred_addr;
+  std::string_view http_method;
+  // download is a path to a directory where a downloaded file is
+  // saved.  If it is empty, no file is saved.
+  std::string_view download;
+  // requests contains URIs to request.
+  std::vector<Request> requests;
+  // no_quic_dump is true if hexdump of QUIC STREAM and CRYPTO data
+  // should be disabled.
+  bool no_quic_dump;
+  // no_http_dump is true if hexdump of HTTP response body should be
+  // disabled.
+  bool no_http_dump;
+  // qlog_file is the path to write qlog.
+  std::string_view qlog_file;
+  // qlog_dir is the path to directory where qlog is stored.  qlog_dir
+  // and qlog_file are mutually exclusive.
+  std::string_view qlog_dir;
+  // max_data is the initial connection-level flow control window.
+  uint64_t max_data;
+  // max_stream_data_bidi_local is the initial stream-level flow
+  // control window for a bidirectional stream that the local endpoint
+  // initiates.
+  uint64_t max_stream_data_bidi_local;
+  // max_stream_data_bidi_remote is the initial stream-level flow
+  // control window for a bidirectional stream that the remote
+  // endpoint initiates.
+  uint64_t max_stream_data_bidi_remote;
+  // max_stream_data_uni is the initial stream-level flow control
+  // window for a unidirectional stream.
+  uint64_t max_stream_data_uni;
+  // max_streams_bidi is the number of the concurrent bidirectional
+  // streams.
+  uint64_t max_streams_bidi;
+  // max_streams_uni is the number of the concurrent unidirectional
+  // streams.
+  uint64_t max_streams_uni;
+  // max_window is the maximum connection-level flow control window
+  // size if auto-tuning is enabled.
+  uint64_t max_window;
+  // max_stream_window is the maximum stream-level flow control window
+  // size if auto-tuning is enabled.
+  uint64_t max_stream_window;
+  // exit_on_first_stream_close is the flag that if it is true, client
+  // exits when a first HTTP stream gets closed.  It is not
+  // necessarily the same time when the underlying QUIC stream closes
+  // due to the QPACK synchronization.
+  bool exit_on_first_stream_close;
+  // exit_on_all_streams_close is the flag that if it is true, client
+  // exits when all HTTP streams get closed.
+  bool exit_on_all_streams_close;
+  // disable_early_data disables early data.
+  bool disable_early_data;
+  // static_secret is used to derive keying materials for Stateless
+  // Retry token.
+  std::array<uint8_t, 32> static_secret;
+  // cc_algo is the congestion controller algorithm.
+  ngtcp2_cc_algo cc_algo;
+  // token_file is a path to file to read or write token from
+  // NEW_TOKEN frame.
+  std::string_view token_file;
+  // sni is the value sent in TLS SNI, overriding DNS name of the
+  // remote host.
+  std::string_view sni;
+  // initial_rtt is an initial RTT.
+  ngtcp2_duration initial_rtt;
+  // max_udp_payload_size is the maximum UDP payload size that client
+  // transmits.
+  size_t max_udp_payload_size;
+  // handshake_timeout is the period of time before giving up QUIC
+  // connection establishment.
+  ngtcp2_duration handshake_timeout;
+  // preferred_versions includes QUIC versions in the order of
+  // preference.  Client uses this field to select a version from the
+  // version set offered in Version Negotiation packet.
+  std::vector<uint32_t> preferred_versions;
+  // available_versions includes QUIC versions that are sent in
+  // available_versions field of version_information
+  // transport_parameter.
+  std::vector<uint32_t> available_versions;
+  // no_pmtud disables Path MTU Discovery.
+  bool no_pmtud;
+  // ack_thresh is the minimum number of the received ACK eliciting
+  // packets that triggers immediate acknowledgement.
+  size_t ack_thresh;
+};
+
+class ClientBase {
+public:
+  ClientBase();
+  ~ClientBase();
+
+  ngtcp2_conn *conn() const;
+
+  int write_transport_params(const char *path,
+                             const ngtcp2_transport_params *params);
+  int read_transport_params(const char *path, ngtcp2_transport_params *params);
+
+  void write_qlog(const void *data, size_t datalen);
+
+  ngtcp2_crypto_conn_ref *conn_ref();
+
+protected:
+  ngtcp2_crypto_conn_ref conn_ref_;
+  TLSClientSession tls_session_;
+  FILE *qlog_;
+  ngtcp2_conn *conn_;
+  ngtcp2_connection_close_error last_error_;
+};
+
+void qlog_write_cb(void *user_data, uint32_t flags, const void *data,
+                   size_t datalen);
+
+#endif // CLIENT_BASE_H