1. 29 Mar, 2021 1 commit
  2. 03 Sep, 2020 1 commit
  3. 07 Aug, 2020 1 commit
  4. 05 Aug, 2020 1 commit
    • Alessandro Ghedini's avatar
      ignore failure to parse payload length · 204d693b
      Alessandro Ghedini authored
      When the type field in a long header packet is corrupted from Handshake
      to Initial, the payload length field is instead interpreted as token
      length which leads to failure when we try to actually parse the payload
      length.
      
      Instead use the `drop_pkt_on_err()` trick when parsing the payload
      length fails.
      
      Fixes #614.
      204d693b
  5. 04 Aug, 2020 1 commit
  6. 21 Jul, 2020 2 commits
  7. 20 Jul, 2020 1 commit
  8. 17 Jul, 2020 3 commits
  9. 16 Jul, 2020 4 commits
    • Alessandro Ghedini's avatar
    • Junho Choi's avatar
      build: simplify Android build · 58eb9656
      Junho Choi authored
      We only need Android NDK to build quiche for Android platform.
      Simply use rust image from Travis and install NDK on top of it.
      58eb9656
    • Alessandro Ghedini's avatar
      deps: use 'master-with-bazel' branch of BoringSSL · 740e2a6f
      Alessandro Ghedini authored
      It should be more or less the same as master, but it also has a less
      strict build configuration and doesn't require go and perl for build.
      
      Fixes #589.
      740e2a6f
    • Lucas Pardue's avatar
      examples: align retry mechanism with Rust examples (#592) · 6d7bab44
      Lucas Pardue authored
      Previously, when doing stateless retry the C example server would
      reuse the dcid for new_scid. Once a client sent back the token
      and we validated it, a new connection ID would be generated and
      sent back to the client as part of the handshake. The client would
      detect an error when validating retry_source_connection_id and
      close the connection.
      
      This change aligns the C examples to the Rust examples. A new
      connection ID is generated and sent in the retry. Once a client
      sends back the toked and we validate it, we use the information
      at hand instead of generating anything again.
      
      Fixes #566 and #582.
      6d7bab44
  10. 14 Jul, 2020 3 commits
  11. 13 Jul, 2020 4 commits
    • Alessandro Ghedini's avatar
      recovery: send PTO probes based on PTO count · f6608a93
      Alessandro Ghedini authored
      Instead of always sending 2 PTO probes, we should start by sending one
      probe, and increase to 2 if the previous probe was lost.
      
      This is done by using the current PTO count to determine how many probes
      should be sent (up to 2).
      f6608a93
    • Alessandro Ghedini's avatar
      bundle ACK with PTO probes · 74458c6d
      Alessandro Ghedini authored
      74458c6d
    • Alessandro Ghedini's avatar
      recovery: retransmit frames from 2 oldest unacked packets on PTO · 7c3d7b29
      Alessandro Ghedini authored
      In 39905083 we implemented support for retransmitting unacked data in
      PTO probes if no new data is available.
      
      However after discussion it seems that prioritizing new data is not
      actually necessary, and simply retransmitting old data first might be
      the better strategy (if anything it's easier to implement).
      
      This reverts the changes from the previous commit, and simply implements
      logic to reschedule the frames from the 2 oldest sent packets when the
      PTO expires.
      
      Besides having a much simpler implementation, this also has the
      advantage of allowing other frames to be sent in the probe packet (e.g.
      ACKs), without risking that the original data frame wouldn't fit in the
      output packet, since we won't retransmit CRYPTO and STREAM frames as-is
      but will go through the normal packetization procedure (including e.g.
      respecting STREAM priorities).
      
      This also means that we won't retransmit the same data in both probe
      packets. Though if there aren't enough packets with data frames
      available we might still end-up sending a PING frame only in the second
      probe packet.
      7c3d7b29
    • Junho Choi's avatar
      build: move Android helper scripts into a directory · 7acb9c7d
      Junho Choi authored
      Move Android helper scripts into tools/android.
      No functional changes.
      7acb9c7d
  12. 02 Jul, 2020 1 commit
  13. 26 Jun, 2020 1 commit
  14. 24 Jun, 2020 1 commit
  15. 23 Jun, 2020 3 commits
    • Alessandro Ghedini's avatar
      docker: bump rust image to latest stable · 50c9f9c4
      Alessandro Ghedini authored
      Some indirect dependency requires a newer Rust version to build:
      https://github.com/BurntSushi/aho-corasick/issues/62
      50c9f9c4
    • Alessandro Ghedini's avatar
      try to retransmit old frames on PTO · 39905083
      Alessandro Ghedini authored
      Currently when sending a PTO probe we either include new data frames or
      a PING frame in the packet to make sure that the probe is ack-eliciting.
      However if no new data is availabe, we should try to include old data
      that has not been marked as lost yet if there is any, instead of just
      sending a PING.
      
      This changes that by iterating over old sent packets (that have not been
      acked or lost yet) and copying CRYPTO and STREAM frames into the outgoing
      packet when creating PTO probes.
      
      This requires cloning the frames, which is somewhat unfortunate, but it
      should only happen when PTO expires, which has exponential backoff so it
      shouldn't be possible to use this as a DoS vector.
      39905083
    • Alessandro Ghedini's avatar
      reject invalid STREAMS_BLOCKED frames · 4e269f03
      Alessandro Ghedini authored
      This also changes the error used when the stream limit is exceeded as
      per the latest draft.
      
      Also slightly refactor existing check to avoid repeating the same
      constant over and over.
      
      Fixes #565.
      4e269f03
  16. 15 Jun, 2020 1 commit
    • lucas's avatar
      h3: initial version of extensible priority scheme · 8b2f212b
      lucas authored
      This builds on top of the QUIC-level priority support.
      
      This change adds a new method `send_response_with_priority()`to
      the HTTP/3 API. This takes a `priority` argument, a string that
      contains the Extensible Priority header field value formatted
      as Structured Headers e.g. "u=2, i". The contents of `priority`
      is used for scheduling when sending response body bytes with
      `send_body`.
      
      The Extensible Priority scheme defines the defaults u=3 and i=?0.
      Providing an empty value for `priority` will cause the defaults
      to be used. The existing method `send_response()` has been updated
      to send responses using defaults.
      
      At this time, once a response is initiated it's priority cannot
      changed.
      
      No new API method is provided for clients to set request priority.
      Clients can provide the `Priority` HTTP header in the `Headers`
      argument of the `send_request()` method. This will be passed through
      unmodified.
      
      The quiche-client and quiche-server applications have been updated...
      8b2f212b
  17. 13 Jun, 2020 1 commit
    • Alessandro Ghedini's avatar
      apps: increase max idle timeout · a4b0172f
      Alessandro Ghedini authored
      Other implementations running in the interop runner have higher timeouts
      which kind of puts us at a disadvantage.
      
      In the future we might want to make this configurable, but for now there
      is not much point.
      a4b0172f
  18. 12 Jun, 2020 1 commit
    • Alessandro Ghedini's avatar
      stream: initial support for prioritization · 6a4f14db
      Alessandro Ghedini authored
      Featuring fixes by @LPardue.
      
      This implements a very simple scheme for stream prioritization at the
      transport layer. Each stream can be prioritized with an urgency level (a
      number from 0 to 255 where lower is more important), as well as an
      "incremental" flag.
      
      Internally, instead of keeping a single queue for all scheduled streams,
      an ordered map of lists is used instead. Each list holds the streams
      that are scheduled at a given urgency level. When flushing data, the
      non-empty list with the lower urgency level is used first.
      
      Each urgency list is in turn split into two queues, one for
      non-incremental streams, that are flushed fully in a FIFO order, and one
      for incremental ones that are round-robined. Non-incremental streams at
      the same urgency level take priority.
      
      Currently priority is only used when flushing streams to the wire, but
      not when streams are reported as readable or writable to the application
      (yet).
      
      Re-prioritization is not implemented yet.
      6a4f14db
  19. 11 Jun, 2020 2 commits
  20. 10 Jun, 2020 4 commits
  21. 08 Jun, 2020 1 commit
    • Alessandro Ghedini's avatar
      improve keylog API · 8f4eb8d6
      Alessandro Ghedini authored
      When an application enables key logging in the Config object, quiche
      will automatically read the SSLKEYLOGFILE variable and create the
      corresponding file to log to.
      
      However this is slightly dangerous as the application is not necessarily
      in control of the environment variable, so keys might accidentally end
      up being logged without the application saying so. And it generally
      doesn't seem to be good form for a library to depend on environment
      variables.
      
      The current API is also not very flexible, as it only allows
      applications to log to files, and doesn't allow enabling/disabling
      logging on a per-connection basis.
      
      So, in addition to calling `log_keys()` on the Config object,
      applications now also need to call the `set_keylog()` method on each
      connection they wish to log keys for, passing the `Writer` object that
      will receive the actual data from quiche.
      8f4eb8d6
  22. 05 Jun, 2020 2 commits