protocol-quic 0.0.0

data/ext/ngtcp2/examples/server.h

@@ -0,0 +1,256 @@
+/*
+ * 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 SERVER_H
+#define SERVER_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif // HAVE_CONFIG_H
+
+#include <vector>
+#include <unordered_map>
+#include <string>
+#include <deque>
+#include <string_view>
+#include <memory>
+
+#include <ngtcp2/ngtcp2.h>
+#include <ngtcp2/ngtcp2_crypto.h>
+#include <nghttp3/nghttp3.h>
+
+#include <ev.h>
+
+#include "server_base.h"
+#include "tls_server_context.h"
+#include "network.h"
+#include "shared.h"
+
+using namespace ngtcp2;
+
+struct HTTPHeader {
+  HTTPHeader(const std::string_view &name, const std::string_view &value)
+      : name(name), value(value) {}
+
+  std::string_view name;
+  std::string_view value;
+};
+
+class Handler;
+struct FileEntry;
+
+struct Stream {
+  Stream(int64_t stream_id, Handler *handler);
+
+  int start_response(nghttp3_conn *conn);
+  std::pair<FileEntry, int> open_file(const std::string &path);
+  void map_file(const FileEntry &fe);
+  int send_status_response(nghttp3_conn *conn, unsigned int status_code,
+                           const std::vector<HTTPHeader> &extra_headers = {});
+  int send_redirect_response(nghttp3_conn *conn, unsigned int status_code,
+                             const std::string_view &path);
+  int64_t find_dyn_length(const std::string_view &path);
+  void http_acked_stream_data(uint64_t datalen);
+
+  int64_t stream_id;
+  Handler *handler;
+  // uri is request uri/path.
+  std::string uri;
+  std::string method;
+  std::string authority;
+  std::string status_resp_body;
+  // data is a pointer to the memory which maps file denoted by fd.
+  uint8_t *data;
+  // datalen is the length of mapped file by data.
+  uint64_t datalen;
+  // dynresp is true if dynamic data response is enabled.
+  bool dynresp;
+  // dyndataleft is the number of dynamic data left to send.
+  uint64_t dyndataleft;
+  // dynbuflen is the number of bytes in-flight.
+  uint64_t dynbuflen;
+};
+
+class Server;
+
+// Endpoint is a local endpoint.
+struct Endpoint {
+  Address addr;
+  ev_io rev;
+  Server *server;
+  int fd;
+  // ecn is the last ECN bits set to fd.
+  unsigned int ecn;
+};
+
+class Handler : public HandlerBase {
+public:
+  Handler(struct ev_loop *loop, Server *server);
+  ~Handler();
+
+  int init(const Endpoint &ep, const Address &local_addr, const sockaddr *sa,
+           socklen_t salen, const ngtcp2_cid *dcid, const ngtcp2_cid *scid,
+           const ngtcp2_cid *ocid, const uint8_t *token, size_t tokenlen,
+           uint32_t version, TLSServerContext &tls_ctx);
+
+  int on_read(const Endpoint &ep, const Address &local_addr, const sockaddr *sa,
+              socklen_t salen, const ngtcp2_pkt_info *pi, uint8_t *data,
+              size_t datalen);
+  int on_write();
+  int write_streams();
+  int feed_data(const Endpoint &ep, const Address &local_addr,
+                const sockaddr *sa, socklen_t salen, const ngtcp2_pkt_info *pi,
+                uint8_t *data, size_t datalen);
+  void update_timer();
+  int handle_expiry();
+  void signal_write();
+  int handshake_completed();
+
+  Server *server() const;
+  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);
+  uint32_t version() const;
+  void on_stream_open(int64_t stream_id);
+  int on_stream_close(int64_t stream_id, uint64_t app_error_code);
+  void start_draining_period();
+  int start_closing_period();
+  int handle_error();
+  int send_conn_close();
+
+  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 setup_httpconn();
+  void http_consume(int64_t stream_id, size_t nconsumed);
+  void extend_max_remote_streams_bidi(uint64_t max_streams);
+  Stream *find_stream(int64_t stream_id);
+  void http_begin_request_headers(int64_t stream_id);
+  void http_recv_request_header(Stream *stream, int32_t token,
+                                nghttp3_rcbuf *name, nghttp3_rcbuf *value);
+  int http_end_request_headers(Stream *stream);
+  int http_end_stream(Stream *stream);
+  int start_response(Stream *stream);
+  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);
+  void shutdown_read(int64_t stream_id, int app_error_code);
+  void http_acked_stream_data(Stream *stream, uint64_t datalen);
+  void http_stream_close(int64_t stream_id, uint64_t app_error_code);
+  int http_stop_sending(int64_t stream_id, uint64_t app_error_code);
+  int http_reset_stream(int64_t stream_id, uint64_t app_error_code);
+
+  void write_qlog(const void *data, size_t datalen);
+
+  void on_send_blocked(Endpoint &ep, const ngtcp2_addr &local_addr,
+                       const ngtcp2_addr &remote_addr, unsigned int ecn,
+                       const uint8_t *data, size_t datalen, size_t gso_size);
+  void start_wev_endpoint(const Endpoint &ep);
+  int send_blocked_packet();
+
+private:
+  struct ev_loop *loop_;
+  Server *server_;
+  ev_io wev_;
+  ev_timer timer_;
+  FILE *qlog_;
+  ngtcp2_cid scid_;
+  nghttp3_conn *httpconn_;
+  std::unordered_map<int64_t, std::unique_ptr<Stream>> streams_;
+  // conn_closebuf_ contains a packet which contains CONNECTION_CLOSE.
+  // This packet is repeatedly sent as a response to the incoming
+  // packet in draining period.
+  std::unique_ptr<Buffer> conn_closebuf_;
+  // nkey_update_ is the number of key update occurred.
+  size_t nkey_update_;
+  bool no_gso_;
+
+  struct {
+    bool send_blocked;
+    size_t num_blocked;
+    size_t num_blocked_sent;
+    // blocked field is effective only when send_blocked is true.
+    struct {
+      Endpoint *endpoint;
+      Address local_addr;
+      Address remote_addr;
+      unsigned int ecn;
+      const uint8_t *data;
+      size_t datalen;
+      size_t gso_size;
+    } blocked[2];
+    std::unique_ptr<uint8_t[]> data;
+  } tx_;
+};
+
+class Server {
+public:
+  Server(struct ev_loop *loop, TLSServerContext &tls_ctx);
+  ~Server();
+
+  int init(const char *addr, const char *port);
+  void disconnect();
+  void close();
+
+  int on_read(Endpoint &ep);
+  int send_version_negotiation(uint32_t version, const uint8_t *dcid,
+                               size_t dcidlen, const uint8_t *scid,
+                               size_t scidlen, Endpoint &ep,
+                               const Address &local_addr, const sockaddr *sa,
+                               socklen_t salen);
+  int send_retry(const ngtcp2_pkt_hd *chd, Endpoint &ep,
+                 const Address &local_addr, const sockaddr *sa, socklen_t salen,
+                 size_t max_pktlen);
+  int send_stateless_connection_close(const ngtcp2_pkt_hd *chd, Endpoint &ep,
+                                      const Address &local_addr,
+                                      const sockaddr *sa, socklen_t salen);
+  int verify_retry_token(ngtcp2_cid *ocid, const ngtcp2_pkt_hd *hd,
+                         const sockaddr *sa, socklen_t salen);
+  int verify_token(const ngtcp2_pkt_hd *hd, const sockaddr *sa,
+                   socklen_t salen);
+  int send_packet(Endpoint &ep, const ngtcp2_addr &local_addr,
+                  const ngtcp2_addr &remote_addr, unsigned int ecn,
+                  const uint8_t *data, size_t datalen);
+  std::pair<size_t, int> send_packet(Endpoint &ep, bool &no_gso,
+                                     const ngtcp2_addr &local_addr,
+                                     const ngtcp2_addr &remote_addr,
+                                     unsigned int ecn, const uint8_t *data,
+                                     size_t datalen, size_t gso_size);
+  void remove(const Handler *h);
+
+  void associate_cid(const ngtcp2_cid *cid, Handler *h);
+  void dissociate_cid(const ngtcp2_cid *cid);
+
+private:
+  std::unordered_map<std::string, Handler *> handlers_;
+  struct ev_loop *loop_;
+  std::vector<Endpoint> endpoints_;
+  TLSServerContext &tls_ctx_;
+  ev_signal sigintev_;
+};
+
+#endif // SERVER_H

data/ext/ngtcp2/examples/server_base.cc

@@ -0,0 +1,58 @@
+/*
+ * 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 "server_base.h"
+
+#include <cassert>
+#include <array>
+#include <iostream>
+
+#include "debug.h"
+
+using namespace ngtcp2;
+
+extern Config config;
+
+Buffer::Buffer(const uint8_t *data, size_t datalen)
+    : buf{data, data + datalen}, begin(buf.data()), tail(begin + datalen) {}
+Buffer::Buffer(size_t datalen) : buf(datalen), begin(buf.data()), tail(begin) {}
+
+static ngtcp2_conn *get_conn(ngtcp2_crypto_conn_ref *conn_ref) {
+  auto h = static_cast<HandlerBase *>(conn_ref->user_data);
+  return h->conn();
+}
+
+HandlerBase::HandlerBase() : conn_ref_{get_conn, this}, conn_(nullptr) {
+  ngtcp2_connection_close_error_default(&last_error_);
+}
+
+HandlerBase::~HandlerBase() {
+  if (conn_) {
+    ngtcp2_conn_del(conn_);
+  }
+}
+
+ngtcp2_conn *HandlerBase::conn() const { return conn_; }
+
+ngtcp2_crypto_conn_ref *HandlerBase::conn_ref() { return &conn_ref_; }

data/ext/ngtcp2/examples/server_base.h

@@ -0,0 +1,195 @@
+/*
+ * 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 SERVER_BASE_H
+#define SERVER_BASE_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif // HAVE_CONFIG_H
+
+#include <vector>
+#include <deque>
+#include <unordered_map>
+#include <string>
+#include <string_view>
+#include <functional>
+
+#include <ngtcp2/ngtcp2_crypto.h>
+
+#include "tls_server_session.h"
+#include "network.h"
+#include "shared.h"
+
+using namespace ngtcp2;
+
+struct Config {
+  Address preferred_ipv4_addr;
+  Address preferred_ipv6_addr;
+  // 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;
+  // ciphers is the list of enabled ciphers.
+  const char *ciphers;
+  // groups is the list of supported groups.
+  const char *groups;
+  // htdocs is a root directory to serve documents.
+  std::string htdocs;
+  // mime_types_file is a path to "MIME media types and the
+  // extensions" file.  Ubuntu mime-support package includes it in
+  // /etc/mime/types.
+  std::string_view mime_types_file;
+  // mime_types maps file extension to MIME media type.
+  std::unordered_map<std::string, std::string> mime_types;
+  // port is the port number which server listens on for incoming
+  // connections.
+  uint16_t port;
+  // quiet suppresses the output normally shown except for the error
+  // messages.
+  bool quiet;
+  // timeout is an idle timeout for QUIC connection.
+  ngtcp2_duration timeout;
+  // show_secret is true if transport secrets should be printed out.
+  bool show_secret;
+  // validate_addr is true if server requires address validation.
+  bool validate_addr;
+  // early_response is true if server starts sending response when it
+  // receives HTTP header fields without waiting for request body.  If
+  // HTTP response data is written before receiving request body,
+  // STOP_SENDING is sent.
+  bool early_response;
+  // verify_client is true if server verifies client with X.509
+  // certificate based authentication.
+  bool verify_client;
+  // qlog_dir is the path to directory where qlog is stored.
+  std::string_view qlog_dir;
+  // 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;
+  // 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;
+  // max_dyn_length is the maximum length of dynamically generated
+  // response.
+  uint64_t max_dyn_length;
+  // static_secret is used to derive keying materials for Retry and
+  // Stateless Retry token.
+  std::array<uint8_t, 32> static_secret;
+  // cc_algo is the congestion controller algorithm.
+  ngtcp2_cc_algo cc_algo;
+  // initial_rtt is an initial RTT.
+  ngtcp2_duration initial_rtt;
+  // max_udp_payload_size is the maximum UDP payload size that server
+  // transmits.
+  size_t max_udp_payload_size;
+  // send_trailers controls whether server sends trailer fields or
+  // not.
+  bool send_trailers;
+  // max_gso_dgrams is the maximum number of UDP datagrams in one GSO
+  // sendmsg call.
+  size_t max_gso_dgrams;
+  // 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.  Server negotiates one of those versions if a client
+  // initially selects a less preferred version.
+  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;
+};
+
+struct Buffer {
+  Buffer(const uint8_t *data, size_t datalen);
+  explicit Buffer(size_t datalen);
+
+  size_t size() const { return tail - begin; }
+  size_t left() const { return buf.data() + buf.size() - tail; }
+  uint8_t *const wpos() { return tail; }
+  const uint8_t *rpos() const { return begin; }
+  void push(size_t len) { tail += len; }
+  void reset() { tail = begin; }
+
+  std::vector<uint8_t> buf;
+  // begin points to the beginning of the buffer.  This might point to
+  // buf.data() if a buffer space is allocated by this object.  It is
+  // also allowed to point to the external shared buffer.
+  uint8_t *begin;
+  // tail points to the position of the buffer where write should
+  // occur.
+  uint8_t *tail;
+};
+
+class HandlerBase {
+public:
+  HandlerBase();
+  ~HandlerBase();
+
+  ngtcp2_conn *conn() const;
+
+  TLSServerSession *get_session() { return &tls_session_; }
+
+  ngtcp2_crypto_conn_ref *conn_ref();
+
+protected:
+  ngtcp2_crypto_conn_ref conn_ref_;
+  TLSServerSession tls_session_;
+  ngtcp2_conn *conn_;
+  ngtcp2_connection_close_error last_error_;
+};
+
+#endif // SERVER_BASE_H