blob: 6dc01d8e1e2794694a595c062f721851aab48ab8 [file] [log] [blame]
// Copyright (C) 2019, Cloudflare, Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//! HTTP/3 wire protocol and QPACK implementation.
//!
//! This module provides a high level API for sending and receiving HTTP/3
//! requests and responses on top of the QUIC transport protocol.
//!
//! ## Connection setup
//!
//! HTTP/3 connections require a QUIC transport-layer connection, see
//! [Connection setup] for a full description of the setup process.
//!
//! To use HTTP/3, the QUIC connection must be configured with a suitable
//! Application Layer Protocol Negotiation (ALPN) Protocol ID:
//!
//! ```
//! let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION)?;
//! config.set_application_protos(quiche::h3::APPLICATION_PROTOCOL)?;
//! # Ok::<(), quiche::Error>(())
//! ```
//!
//! The QUIC handshake is driven by [sending] and [receiving] QUIC packets.
//!
//! Once the handshake has completed, the first step in establishing an HTTP/3
//! connection is creating its configuration object:
//!
//! ```
//! let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! HTTP/3 client and server connections are both created using the
//! [`with_transport()`] function, the role is inferred from the type of QUIC
//! connection:
//!
//! ```no_run
//! # let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
//! # let scid = [0xba; 16];
//! # let mut conn = quiche::connect(None, &scid, &mut config).unwrap();
//! # let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! let h3_conn = quiche::h3::Connection::with_transport(&mut conn, &h3_config)?;
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! ## Sending a request
//!
//! An HTTP/3 client can send a request by using the connection's
//! [`send_request()`] method to queue request headers; [sending] QUIC packets
//! causes the requests to get sent to the peer:
//!
//! ```no_run
//! # let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
//! # let scid = [0xba; 16];
//! # let mut conn = quiche::connect(None, &scid, &mut config).unwrap();
//! # let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! # let mut h3_conn = quiche::h3::Connection::with_transport(&mut conn, &h3_config)?;
//! let req = vec![
//! quiche::h3::Header::new(":method", "GET"),
//! quiche::h3::Header::new(":scheme", "https"),
//! quiche::h3::Header::new(":authority", "quic.tech"),
//! quiche::h3::Header::new(":path", "/"),
//! quiche::h3::Header::new(":user-agent", "quiche"),
//! ];
//!
//! h3_conn.send_request(&mut conn, &req, true)?;
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! An HTTP/3 client can send a request with additional body data by using
//! the connection's [`send_body()`] method:
//!
//! ```no_run
//! # let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
//! # let scid = [0xba; 16];
//! # let mut conn = quiche::connect(None, &scid, &mut config).unwrap();
//! # let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! # let mut h3_conn = quiche::h3::Connection::with_transport(&mut conn, &h3_config)?;
//! let req = vec![
//! quiche::h3::Header::new(":method", "GET"),
//! quiche::h3::Header::new(":scheme", "https"),
//! quiche::h3::Header::new(":authority", "quic.tech"),
//! quiche::h3::Header::new(":path", "/"),
//! quiche::h3::Header::new(":user-agent", "quiche"),
//! ];
//!
//! let stream_id = h3_conn.send_request(&mut conn, &req, false)?;
//! h3_conn.send_body(&mut conn, stream_id, b"Hello World!", true)?;
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! ## Handling requests and responses
//!
//! After [receiving] QUIC packets, HTTP/3 data is processed using the
//! connection's [`poll()`] method. On success, this returns an [`Event`] object
//! and an ID corresponding to the stream where the `Event` originated.
//!
//! An HTTP/3 server uses [`poll()`] to read requests and responds to them using
//! [`send_response()`] and [`send_body()`]:
//!
//! ```no_run
//! # let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
//! # let scid = [0xba; 16];
//! # let mut conn = quiche::accept(&scid, None, &mut config).unwrap();
//! # let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! # let mut h3_conn = quiche::h3::Connection::with_transport(&mut conn, &h3_config)?;
//! loop {
//! match h3_conn.poll(&mut conn) {
//! Ok((stream_id, quiche::h3::Event::Headers(headers))) => {
//! let mut headers = headers.into_iter();
//!
//! // Look for the request's method.
//! let method = headers.find(|h| h.name() == ":method").unwrap();
//!
//! // Look for the request's path.
//! let path = headers.find(|h| h.name() == ":path").unwrap();
//!
//! if method.value() == "GET" && path.value() == "/" {
//! let resp = vec![
//! quiche::h3::Header::new(":status", &200.to_string()),
//! quiche::h3::Header::new("server", "quiche"),
//! ];
//!
//! h3_conn.send_response(&mut conn, stream_id, &resp, false)?;
//! h3_conn.send_body(&mut conn, stream_id, b"Hello World!", true)?;
//! }
//! },
//!
//! Ok((stream_id, quiche::h3::Event::Data)) => {
//! // Request body data, handle it.
//! # return Ok(());
//! },
//!
//! Ok((stream_id, quiche::h3::Event::Finished)) => {
//! // Peer terminated stream, handle it.
//! }
//!
//! Err(quiche::h3::Error::Done) => {
//! // Done reading.
//! break;
//! },
//!
//! Err(e) => {
//! // An error occurred, handle it.
//! break;
//! },
//! }
//! }
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! An HTTP/3 client uses [`poll()`] to read responses:
//!
//! ```no_run
//! # let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
//! # let scid = [0xba; 16];
//! # let mut conn = quiche::connect(None, &scid, &mut config).unwrap();
//! # let h3_config = quiche::h3::Config::new(0, 1024, 0, 0)?;
//! # let mut h3_conn = quiche::h3::Connection::with_transport(&mut conn, &h3_config)?;
//! loop {
//! match h3_conn.poll(&mut conn) {
//! Ok((stream_id, quiche::h3::Event::Headers(headers))) => {
//! let status = headers.iter().find(|h| h.name() == ":status").unwrap();
//! println!("Received {} response on stream {}",
//! status.value(), stream_id);
//! },
//!
//! Ok((stream_id, quiche::h3::Event::Data)) => {
//! let mut body = vec![0; 4096];
//!
//! if let Ok(read) =
//! h3_conn.recv_body(&mut conn, stream_id, &mut body)
//! {
//! println!("Received {} bytes of payload on stream {}",
//! read, stream_id);
//! }
//! },
//!
//! Ok((stream_id, quiche::h3::Event::Finished)) => {
//! // Peer terminated stream, handle it.
//! }
//!
//! Err(quiche::h3::Error::Done) => {
//! // Done reading.
//! break;
//! },
//!
//! Err(e) => {
//! // An error occurred, handle it.
//! break;
//! },
//! }
//! }
//! # Ok::<(), quiche::h3::Error>(())
//! ```
//!
//! ## Detecting end of request or response
//!
//! A single HTTP/3 request or response may consist of several HEADERS and DATA
//! frames; it is finished when the QUIC stream is closed. Calling [`poll()`]
//! repeatedly will generate an [`Event`] for each of these. The application may
//! use these event to do additional HTTP semantic validation.
//!
//! ## HTTP/3 protocol errors
//!
//! Quiche is responsible for managing the HTTP/3 connection, ensuring it is in
//! a correct state and validating all messages received by a peer. This mainly
//! takes place in the [`poll()`] method. If an HTTP/3 error occurs, quiche will
//! close the connection and send an appropriate CONNECTION_CLOSE frame to the
//! peer. An [`Error`] is returned to the application so that it can perform any
//! required tidy up such as closing sockets.
//!
//! [`application_proto()`]: ../struct.Connection.html#method.application_proto
//! [`stream_finished()`]: ../struct.Connection.html#method.stream_finished
//! [Connection setup]: ../index.html#connection-setup
//! [sending]: ../index.html#generating-outgoing-packets
//! [receiving]: ../index.html#handling-incoming-packets
//! [`with_transport()`]: struct.Connection.html#method.with_transport
//! [`poll()`]: struct.Connection.html#method.poll
//! [`Event`]: enum.Event.html
//! [`Error`]: enum.Error.html
//! [`send_request()`]: struct.Connection.html#method.send_response
//! [`send_response()`]: struct.Connection.html#method.send_response
//! [`send_body()`]: struct.Connection.html#method.send_body
use std::collections::HashMap;
use std::collections::VecDeque;
use crate::octets;
/// The current HTTP/3 ALPN token.
pub const APPLICATION_PROTOCOL: &[u8] = b"\x05h3-22";
/// A specialized [`Result`] type for quiche HTTP/3 operations.
///
/// This type is used throughout quiche's HTTP/3 public API for any operation
/// that can produce an error.
///
/// [`Result`]: https://doc.rust-lang.org/std/result/enum.Result.html
pub type Result<T> = std::result::Result<T, Error>;
/// An HTTP/3 error.
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(C)]
pub enum Error {
/// There is no error or no work to do
Done = -1,
/// The provided buffer is too short.
BufferTooShort = -2,
/// Peer violated protocol requirements in a way which doesn’t match a
/// more specific error code, or endpoint declines to use the more
/// specific error code.
GeneralProtocolError = -3,
/// Internal error in the HTTP/3 stack.
InternalError = -5,
/// The client no longer needs the requested data.
RequestCancelled = -7,
/// The request stream terminated before completing the request.
IncompleteRequest = -8,
/// Forward connection failure for CONNECT target.
ConnectError = -9,
/// Endpoint detected that the peer is exhibiting behavior that causes.
/// excessive load.
ExcessiveLoad = -10,
/// Operation cannot be served over HTTP/3. Retry over HTTP/1.1.
VersionFallback = -11,
/// Frame received on stream where it is not permitted.
WrongStream = -12,
/// Stream ID, Push ID or Placeholder Id greater that current maximum was
/// used incorrectly, such as exceeding a limit, reducing a limit,
/// or being reused.
IdError = -13,
/// The endpoint detected that its peer created a stream that it will not
/// accept.
StreamCreationError = -15,
/// A required critical stream was closed.
ClosedCriticalStream = -17,
/// Inform client that remainder of request is not needed. Used in
/// STOP_SENDING only.
EarlyResponse = -19,
/// No SETTINGS frame at beginning of control stream.
MissingSettings = -20,
/// A frame was received which is not permitted in the current state.
UnexpectedFrame = -21,
/// Server rejected request without performing any application processing.
RequestRejected = -22,
/// An endpoint detected an error in the payload of a SETTINGS frame:
/// a duplicate setting was detected, a client-only setting was sent by a
/// server, or a server-only setting by a client.
SettingsError = -23,
/// TODO: malformed frame where last on-wire byte is the frame type.
MalformedFrame = -24,
/// QPACK Header block decompression failure.
QpackDecompressionFailed = -25,
/// QPACK encoder stream error.
QpackEncoderStreamError = -26,
/// QPACK decoder stream error.
QpackDecoderStreamError = -27,
/// Error originated from the transport layer.
TransportError = -28,
}
impl Error {
fn to_wire(self) -> u64 {
match self {
Error::Done => 0x0,
Error::GeneralProtocolError => 0x1,
// reserved in draft 22 => 0x2,
Error::InternalError => 0x3,
// reserved in draft 22 => 0x4,
Error::RequestCancelled => 0x5,
Error::IncompleteRequest => 0x6,
Error::ConnectError => 0x07,
Error::ExcessiveLoad => 0x08,
Error::VersionFallback => 0x09,
Error::WrongStream => 0xA,
Error::IdError => 0xB,
// reserved in draft 22 => 0xC,
Error::StreamCreationError => 0xD,
// reserved in draft 22 => 0xE,
Error::ClosedCriticalStream => 0xF,
// reserved in draft 22 => 0x10,
Error::EarlyResponse => 0x11,
Error::MissingSettings => 0x12,
Error::UnexpectedFrame => 0x13,
Error::RequestRejected => 0x14,
Error::SettingsError => 0xFF,
Error::MalformedFrame => 0x10,
Error::QpackDecompressionFailed => 0x200,
Error::QpackEncoderStreamError => 0x201,
Error::QpackDecoderStreamError => 0x202,
Error::BufferTooShort => 0x999,
Error::TransportError => 0xFF,
}
}
fn to_c(self) -> libc::ssize_t {
self as _
}
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
impl std::error::Error for Error {
fn description(&self) -> &str {
// TODO: fill this
""
}
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
None
}
}
impl std::convert::From<super::Error> for Error {
fn from(err: super::Error) -> Self {
match err {
super::Error::Done => Error::Done,
_ => Error::TransportError,
}
}
}
impl std::convert::From<octets::BufferTooShortError> for Error {
fn from(_err: octets::BufferTooShortError) -> Self {
Error::BufferTooShort
}
}
/// An HTTP/3 configuration.
pub struct Config {
num_placeholders: u64,
max_header_list_size: u64,
qpack_max_table_capacity: u64,
qpack_blocked_streams: u64,
}
impl Config {
/// Creates a new configuration object with the specified parameters.
pub fn new(
num_placeholders: u64, max_header_list_size: u64,
qpack_max_table_capacity: u64, qpack_blocked_streams: u64,
) -> Result<Config> {
Ok(Config {
num_placeholders,
max_header_list_size,
qpack_max_table_capacity,
qpack_blocked_streams,
})
}
}
/// A name-value pair representing a raw HTTP header.
#[derive(Clone, Debug, PartialEq)]
pub struct Header(String, String);
impl Header {
/// Creates a new header.
///
/// Both `name` and `value` will be cloned, and `name` will also be
/// converted into lower-case.
pub fn new(name: &str, value: &str) -> Header {
Header(name.to_lowercase(), String::from(value))
}
/// Returns the header's name.
pub fn name(&self) -> &str {
&self.0
}
/// Returns the header's value.
pub fn value(&self) -> &str {
&self.1
}
}
/// An HTTP/3 connection event.
#[derive(Clone, Debug, PartialEq)]
pub enum Event {
/// Request/response headers were received.
Headers(Vec<Header>),
/// Data was received.
///
/// This indicates that the application can use the [`recv_body()`] method
/// to retrieve the data from the stream.
///
/// This event will keep being reported until all the available data is
/// retrieved by the application.
///
/// [`recv_body()`]: struct.Connection.html#method.recv_body
Data,
/// Stream was closed,
Finished,
}
struct ConnectionSettings {
pub num_placeholders: Option<u64>,
pub max_header_list_size: Option<u64>,
pub qpack_max_table_capacity: Option<u64>,
pub qpack_blocked_streams: Option<u64>,
}
struct QpackStreams {
pub encoder_stream_id: Option<u64>,
pub decoder_stream_id: Option<u64>,
}
/// An HTTP/3 connection.
pub struct Connection {
is_server: bool,
highest_request_stream_id: u64,
highest_uni_stream_id: u64,
streams: HashMap<u64, stream::Stream>,
local_settings: ConnectionSettings,
peer_settings: ConnectionSettings,
control_stream_id: Option<u64>,
peer_control_stream_id: Option<u64>,
qpack_encoder: qpack::Encoder,
qpack_decoder: qpack::Decoder,
local_qpack_streams: QpackStreams,
peer_qpack_streams: QpackStreams,
max_push_id: u64,
finished_streams: VecDeque<u64>,
frames_greased: bool,
}
impl Connection {
fn new(config: &Config, is_server: bool) -> Result<Connection> {
let initial_uni_stream_id = if is_server { 0x3 } else { 0x2 };
Ok(Connection {
is_server,
highest_request_stream_id: 0,
highest_uni_stream_id: initial_uni_stream_id,
streams: HashMap::new(),
local_settings: ConnectionSettings {
num_placeholders: Some(config.num_placeholders),
max_header_list_size: Some(config.max_header_list_size),
qpack_max_table_capacity: Some(config.qpack_max_table_capacity),
qpack_blocked_streams: Some(config.qpack_blocked_streams),
},
peer_settings: ConnectionSettings {
num_placeholders: None,
max_header_list_size: None,
qpack_max_table_capacity: None,
qpack_blocked_streams: None,
},
control_stream_id: None,
peer_control_stream_id: None,
qpack_encoder: qpack::Encoder::new(),
qpack_decoder: qpack::Decoder::new(),
local_qpack_streams: QpackStreams {
encoder_stream_id: None,
decoder_stream_id: None,
},
peer_qpack_streams: QpackStreams {
encoder_stream_id: None,
decoder_stream_id: None,
},
max_push_id: 0,
finished_streams: VecDeque::new(),
frames_greased: false,
})
}
/// Creates a new HTTP/3 connection using the provided QUIC connection.
///
/// This will also initiate the HTTP/3 handshake with the peer by opening
/// all control streams (including QPACK) and sending the local settings.
pub fn with_transport(
conn: &mut super::Connection, config: &Config,
) -> Result<Connection> {
let mut http3_conn = Connection::new(config, conn.is_server)?;
http3_conn.send_settings(conn)?;
// Try opening QPACK streams, but ignore errors if it fails since we
// don't need them right now.
http3_conn.open_qpack_encoder_stream(conn).ok();
http3_conn.open_qpack_decoder_stream(conn).ok();
if conn.grease {
// Try opening a GREASE stream, but ignore errors since it's not
// critical.
http3_conn.open_grease_stream(conn).ok();
}
Ok(http3_conn)
}
/// Sends an HTTP/3 request.
///
/// The request is encoded from the provided list of headers, and sent on
/// a newly allocated stream.
///
/// On success the newly allocated stream ID is returned.
pub fn send_request(
&mut self, conn: &mut super::Connection, headers: &[Header], fin: bool,
) -> Result<u64> {
let stream_id = self.get_available_request_stream()?;
self.streams
.insert(stream_id, stream::Stream::new(stream_id, true));
self.send_headers(conn, stream_id, headers, fin)?;
Ok(stream_id)
}
/// Sends an HTTP/3 response on the specified stream.
pub fn send_response(
&mut self, conn: &mut super::Connection, stream_id: u64,
headers: &[Header], fin: bool,
) -> Result<()> {
self.send_headers(conn, stream_id, headers, fin)?;
Ok(())
}
fn encode_header_block(&mut self, headers: &[Header]) -> Result<Vec<u8>> {
let headers_len = headers
.iter()
.fold(0, |acc, h| acc + h.value().len() + h.name().len() + 32);
let mut header_block = vec![0; headers_len];
let len = self
.qpack_encoder
.encode(&headers, &mut header_block)
.map_err(|_| Error::InternalError)?;
header_block.truncate(len);
Ok(header_block)
}
fn send_headers(
&mut self, conn: &mut super::Connection, stream_id: u64,
headers: &[Header], fin: bool,
) -> Result<()> {
let mut d = [42; 10];
let mut b = octets::Octets::with_slice(&mut d);
let header_block = self.encode_header_block(headers)?;
if !self.frames_greased && conn.grease {
self.send_grease_frames(conn, stream_id)?;
self.frames_greased = true;
}
trace!(
"{} tx frm HEADERS stream={} len={} fin={}",
conn.trace_id(),
stream_id,
header_block.len(),
fin
);
conn.stream_send(
stream_id,
b.put_varint(frame::HEADERS_FRAME_TYPE_ID)?,
false,
)?;
conn.stream_send(
stream_id,
b.put_varint(header_block.len() as u64)?,
false,
)?;
conn.stream_send(stream_id, &header_block, fin)?;
Ok(())
}
/// Sends an HTTP/3 body chunk on the given stream.
///
/// On success the number of bytes written is returned.
pub fn send_body(
&mut self, conn: &mut super::Connection, stream_id: u64, body: &[u8],
fin: bool,
) -> Result<usize> {
let mut d = [42; 10];
let mut b = octets::Octets::with_slice(&mut d);
// Validate that it is sane to send data on the stream.
if !self.streams.contains_key(&stream_id) || stream_id % 4 != 0 {
return Err(Error::WrongStream);
}
let overhead = octets::varint_len(frame::DATA_FRAME_TYPE_ID) +
octets::varint_len(body.len() as u64);
let stream_cap = conn.stream_capacity(stream_id)?;
// Make sure there is enough capacity to send the frame header and at
// least one byte of frame payload (this to avoid sending 0-length DATA
// frames).
if stream_cap <= overhead {
return Err(Error::Done);
}
// Cap the frame payload length to the stream's capacity.
let body_len = std::cmp::min(body.len(), stream_cap - overhead);
// If we can't send the entire body, set the fin flag to false so the
// application can try again later.
let fin = if body_len != body.len() { false } else { fin };
trace!(
"{} tx frm DATA stream={} len={} fin={}",
conn.trace_id(),
stream_id,
body_len,
fin
);
conn.stream_send(
stream_id,
b.put_varint(frame::DATA_FRAME_TYPE_ID)?,
false,
)?;
conn.stream_send(stream_id, b.put_varint(body_len as u64)?, false)?;
// Return how many bytes were written, excluding the frame header.
let written = conn.stream_send(stream_id, &body[..body_len], fin)?;
Ok(written)
}
/// Reads request or response body data into the provided buffer.
///
/// Applications should call this method whenever the [`poll()`] method
/// returns a [`Data`] event.
///
/// On success the amount of bytes read is returned, or [`Done`] if there
/// is no data to read.
///
/// [`poll()`]: struct.Connection.html#method.poll
/// [`Data`]: enum.Event.html#variant.Data
/// [`Done`]: enum.Error.html#variant.Done
pub fn recv_body(
&mut self, conn: &mut super::Connection, stream_id: u64, out: &mut [u8],
) -> Result<usize> {
let stream = self.streams.get_mut(&stream_id).ok_or(Error::Done)?;
if stream.state() != stream::State::Data {
return Err(Error::Done);
}
let read = stream.try_consume_data(conn, out)?;
// While body is being received, the stream is marked as finished only
// when all data is read by the application.
if conn.stream_finished(stream_id) {
self.finished_streams.push_back(stream_id);
}
Ok(read)
}
/// Processes HTTP/3 data received from the peer.
///
/// On success it returns an [`Event`] as well as the event's source stream
/// ID. The stream ID can be used when calling [`send_response()`] and
/// [`send_body()`] when responding to incoming requests. On error the
/// connection will be closed by calling [`close()`] with the appropriate
/// error code.
///
/// [`Event`]: enum.Event.html
/// [`send_response()`]: struct.Connection.html#method.send_response
/// [`send_body()`]: struct.Connection.html#method.send_body
/// [`close()`]: ../struct.Connection.html#method.close
pub fn poll(&mut self, conn: &mut super::Connection) -> Result<(u64, Event)> {
// Process control streams first.
if let Some(stream_id) = self.peer_control_stream_id {
self.process_control_stream(conn, stream_id)?;
}
if let Some(stream_id) = self.peer_qpack_streams.encoder_stream_id {
self.process_control_stream(conn, stream_id)?;
}
if let Some(stream_id) = self.peer_qpack_streams.decoder_stream_id {
self.process_control_stream(conn, stream_id)?;
}
// Process finished streams list.
if let Some(finished) = self.finished_streams.pop_front() {
return Ok((finished, Event::Finished));
}
// Process HTTP/3 data from readable streams.
for s in conn.readable() {
trace!("{} stream id {} is readable", conn.trace_id(), s);
let ev = match self.process_readable_stream(conn, s) {
Ok(v) => Some(v),
Err(Error::Done) => None,
Err(e) => return Err(e),
};
if conn.stream_finished(s) {
self.finished_streams.push_back(s);
}
if let Some(ev) = ev {
return Ok(ev);
}
}
Err(Error::Done)
}
pub fn poll2<F>(
&mut self, conn: &mut super::Connection, mut f: F,
) -> Result<()>
where
F: FnMut(
&mut Connection,
&mut super::Connection,
u64,
Event,
) -> Result<()>,
{
// Process control streams first.
if let Some(stream_id) = self.peer_control_stream_id {
self.process_control_stream(conn, stream_id)?;
}
if let Some(stream_id) = self.peer_qpack_streams.encoder_stream_id {
self.process_control_stream(conn, stream_id)?;
}
if let Some(stream_id) = self.peer_qpack_streams.decoder_stream_id {
self.process_control_stream(conn, stream_id)?;
}
// Process finished streams list.
if let Some(finished) = self.finished_streams.pop_front() {
f(self, conn, finished, Event::Finished)?;
}
// Process HTTP/3 data from readable streams.
for s in conn.readable() {
trace!("{} stream id {} is readable", conn.trace_id(), s);
let ev = match self.process_readable_stream(conn, s) {
Ok(v) => Some(v),
Err(Error::Done) => None,
Err(e) => return Err(e),
};
if conn.stream_finished(s) {
self.finished_streams.push_back(s);
}
if let Some((stream_id, ev)) = ev {
f(self, conn, stream_id, ev)?;
}
}
Err(Error::Done)
}
/// Allocates a new request stream ID for the local endpoint to use.
fn get_available_request_stream(&mut self) -> Result<u64> {
if self.highest_request_stream_id < std::u64::MAX {
let ret = self.highest_request_stream_id;
self.highest_request_stream_id += 4;
return Ok(ret);
}
Err(Error::IdError)
}
/// Allocates a new unidirectional stream ID for the local endpoint to use.
fn get_available_uni_stream(&mut self) -> Result<u64> {
if self.highest_uni_stream_id < std::u64::MAX {
let ret = self.highest_uni_stream_id;
self.highest_uni_stream_id += 4;
return Ok(ret);
}
Err(Error::IdError)
}
fn open_uni_stream(
&mut self, conn: &mut super::Connection, ty: u64,
) -> Result<u64> {
let stream_id = self.get_available_uni_stream()?;
let mut d = [0; 8];
let mut b = octets::Octets::with_slice(&mut d);
conn.stream_send(stream_id, b.put_varint(ty)?, false)?;
Ok(stream_id)
}
fn open_qpack_encoder_stream(
&mut self, conn: &mut super::Connection,
) -> Result<()> {
self.local_qpack_streams.encoder_stream_id = Some(
self.open_uni_stream(conn, stream::QPACK_ENCODER_STREAM_TYPE_ID)?,
);
Ok(())
}
fn open_qpack_decoder_stream(
&mut self, conn: &mut super::Connection,
) -> Result<()> {
self.local_qpack_streams.decoder_stream_id = Some(
self.open_uni_stream(conn, stream::QPACK_DECODER_STREAM_TYPE_ID)?,
);
Ok(())
}
/// Send GREASE frames on the provided stream ID.
fn send_grease_frames(
&mut self, conn: &mut super::Connection, stream_id: u64,
) -> Result<()> {
let mut d = [42; 128];
let mut b = octets::Octets::with_slice(&mut d);
trace!("{} tx frm GREASE stream={}", conn.trace_id(), stream_id);
// Empty GREASE frame.
conn.stream_send(stream_id, b.put_varint(grease_value())?, false)?;
conn.stream_send(stream_id, b.put_varint(0)?, false)?;
// GREASE frame with payload.
conn.stream_send(stream_id, b.put_varint(grease_value())?, false)?;
conn.stream_send(stream_id, b.put_varint(18)?, false)?;
conn.stream_send(stream_id, b"GREASE is the word", false)?;
Ok(())
}
/// Opens a new unidirectional stream with a GREASE type and sends some
/// unframed payload.
fn open_grease_stream(&mut self, conn: &mut super::Connection) -> Result<()> {
match self.open_uni_stream(conn, grease_value()) {
Ok(stream_id) => {
trace!("{} open GREASE stream {}", conn.trace_id(), stream_id);
conn.stream_send(stream_id, b"GREASE is the word", false)?;
},
Err(Error::IdError) => {
trace!("{} GREASE stream blocked", conn.trace_id(),);
return Ok(());
},
Err(e) => return Err(e),
};
Ok(())
}
/// Sends SETTINGS frame based on HTTP/3 configuration.
fn send_settings(&mut self, conn: &mut super::Connection) -> Result<()> {
self.control_stream_id = Some(
self.open_uni_stream(conn, stream::HTTP3_CONTROL_STREAM_TYPE_ID)?,
);
// Client cannot send placeholders, so validate here
let num_placeholders = if self.is_server {
self.local_settings.num_placeholders
} else {
None
};
let grease = if conn.grease {
Some((grease_value(), grease_value()))
} else {
None
};
let frame = frame::Frame::Settings {
num_placeholders,
max_header_list_size: self.local_settings.max_header_list_size,
qpack_max_table_capacity: self
.local_settings
.qpack_max_table_capacity,
qpack_blocked_streams: self.local_settings.qpack_blocked_streams,
grease,
};
let mut d = [42; 128];
let mut b = octets::Octets::with_slice(&mut d);
frame.to_bytes(&mut b)?;
let off = b.off();
if let Some(id) = self.control_stream_id {
conn.stream_send(id, &d[..off], false)?;
}
Ok(())
}
fn process_control_stream(
&mut self, conn: &mut super::Connection, stream_id: u64,
) -> Result<()> {
match self.process_readable_stream(conn, stream_id) {
Ok(_) => (),
Err(Error::Done) => (),
Err(e) => return Err(e),
};
if conn.stream_finished(stream_id) {
conn.close(
true,
Error::ClosedCriticalStream.to_wire(),
b"Critical stream closed.",
)?;
return Err(Error::ClosedCriticalStream);
}
Ok(())
}
fn process_readable_stream(
&mut self, conn: &mut super::Connection, stream_id: u64,
) -> Result<(u64, Event)> {
self.streams
.entry(stream_id)
.or_insert_with(|| stream::Stream::new(stream_id, false));
// We need to get a fresh reference to the stream for each
// iteration, to avoid borrowing `self` for the entire duration
// of the loop, because we'll need to borrow it again in the
// `State::FramePayload` case below.
while let Some(stream) = self.streams.get_mut(&stream_id) {
match stream.state() {
stream::State::StreamType => {
stream.try_fill_buffer(conn)?;
let varint = match stream.try_consume_varint() {
Ok(v) => v,
Err(_) => continue,
};
let ty = stream::Type::deserialize(varint)?;
if let Err(e) = stream.set_ty(ty) {
conn.close(true, e.to_wire(), b"")?;
return Err(e);
}
match &ty {
stream::Type::Control => {
// Only one control stream allowed.
if self.peer_control_stream_id.is_some() {
conn.close(
true,
Error::StreamCreationError.to_wire(),
b"Received multiple control streams",
)?;
return Err(Error::StreamCreationError);
}
trace!(
"{} open peer's control stream {}",
conn.trace_id(),
stream_id
);
self.peer_control_stream_id = Some(stream_id);
},
stream::Type::Push => {
// Only clients can receive push stream.
if self.is_server {
conn.close(
true,
Error::StreamCreationError.to_wire(),
b"Server received push stream.",
)?;
return Err(Error::StreamCreationError);
}
},
stream::Type::QpackEncoder => {
// Only one qpack encoder stream allowed.
if self.peer_qpack_streams.encoder_stream_id.is_some()
{
conn.close(
true,
Error::StreamCreationError.to_wire(),
b"Received multiple QPACK encoder streams",
)?;
return Err(Error::StreamCreationError);
}
self.peer_qpack_streams.encoder_stream_id =
Some(stream_id);
},
stream::Type::QpackDecoder => {
// Only one qpack decoder allowed.
if self.peer_qpack_streams.decoder_stream_id.is_some()
{
conn.close(
true,
Error::StreamCreationError.to_wire(),
b"Received multiple QPACK decoder streams",
)?;
return Err(Error::StreamCreationError);
}
self.peer_qpack_streams.decoder_stream_id =
Some(stream_id);
},
stream::Type::Unknown => {
// Unknown stream types are ignored.
// TODO: we MAY send STOP_SENDING
},
stream::Type::Request => unreachable!(),
}
},
stream::State::PushId => {
stream.try_fill_buffer(conn)?;
let varint = match stream.try_consume_varint() {
Ok(v) => v,
Err(_) => continue,
};
if let Err(e) = stream.set_push_id(varint) {
conn.close(true, e.to_wire(), b"")?;
return Err(e);
}
},
stream::State::FrameType => {
stream.try_fill_buffer(conn)?;
let varint = match stream.try_consume_varint() {
Ok(v) => v,
Err(_) => continue,
};
match stream.set_frame_type(varint) {
Err(Error::UnexpectedFrame) => {
let msg = format!("Unexpected frame type {}", varint);
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
msg.as_bytes(),
)?;
return Err(Error::UnexpectedFrame);
},
Err(e) => {
conn.close(
true,
e.to_wire(),
b"Error handling frame.",
)?;
return Err(e);
},
_ => (),
}
},
stream::State::FramePayloadLen => {
stream.try_fill_buffer(conn)?;
let varint = match stream.try_consume_varint() {
Ok(v) => v,
Err(_) => continue,
};
if let Err(e) = stream.set_frame_payload_len(varint) {
conn.close(true, e.to_wire(), b"")?;
return Err(e);
}
},
stream::State::FramePayload => {
stream.try_fill_buffer(conn)?;
let frame = match stream.try_consume_frame() {
Ok(frame) => frame,
Err(Error::Done) => return Err(Error::Done),
Err(e) => {
conn.close(
true,
e.to_wire(),
b"Error handling frame.",
)?;
return Err(e);
},
};
match self.process_frame(conn, stream_id, frame) {
Ok(ev) => return Ok(ev),
Err(Error::Done) => (),
Err(e) => return Err(e),
};
},
stream::State::Data => {
return Ok((stream_id, Event::Data));
},
stream::State::QpackInstruction => {
let mut d = [0; 4096];
// Read data from the stream and discard immediately.
loop {
conn.stream_recv(stream_id, &mut d)?;
}
},
stream::State::Drain => {
// Discard incoming data on the stream.
conn.stream_shutdown(stream_id, crate::Shutdown::Read, 0)?;
break;
},
}
}
Err(Error::Done)
}
fn process_frame(
&mut self, conn: &mut super::Connection, stream_id: u64,
frame: frame::Frame,
) -> Result<(u64, Event)> {
trace!(
"{} rx frm {:?} stream={}",
conn.trace_id(),
frame,
stream_id
);
match frame {
frame::Frame::Settings {
num_placeholders,
max_header_list_size,
qpack_max_table_capacity,
qpack_blocked_streams,
..
} => {
if self.is_server && num_placeholders.is_some() {
conn.close(
true,
Error::SettingsError.to_wire(),
b"Num placeholder setting received by server.",
)?;
return Err(Error::SettingsError);
}
self.peer_settings = ConnectionSettings {
num_placeholders,
max_header_list_size,
qpack_max_table_capacity,
qpack_blocked_streams,
};
},
frame::Frame::Headers { mut header_block } => {
if Some(stream_id) == self.peer_control_stream_id {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"HEADERS received on control stream",
)?;
return Err(Error::UnexpectedFrame);
}
let headers = self
.qpack_decoder
.decode(&mut header_block[..])
.map_err(|_| Error::QpackDecompressionFailed)?;
return Ok((stream_id, Event::Headers(headers)));
},
frame::Frame::Data { .. } => {
if Some(stream_id) == self.peer_control_stream_id {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"DATA received on control stream",
)?;
return Err(Error::UnexpectedFrame);
}
// Do nothing. The Data event is returned separately.
},
frame::Frame::GoAway {
stream_id: goaway_stream_id,
} => {
if self.is_server {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"GOWAY received on server",
)?;
return Err(Error::UnexpectedFrame);
}
if Some(stream_id) != self.peer_control_stream_id {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"GOAWAY received on non-control stream",
)?;
return Err(Error::UnexpectedFrame);
}
if goaway_stream_id % 4 != 0 {
conn.close(
true,
Error::WrongStream.to_wire(),
b"GOAWAY received with ID of non-request stream",
)?;
return Err(Error::WrongStream);
}
// TODO: implement GOAWAY
},
frame::Frame::MaxPushId { push_id } => {
if Some(stream_id) != self.peer_control_stream_id {
conn.close(
true,
Error::WrongStream.to_wire(),
b"MAX_PUSH_ID received on non-control stream",
)?;
return Err(Error::WrongStream);
}
if !self.is_server {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"MAX_PUSH_ID received by client",
)?;
return Err(Error::UnexpectedFrame);
}
// The spec says this lower limit elicits an
// HTTP_MALFORMED_FRAME error. It's a non-sensical
// error because at this point we already parsed the
// frame just fine. Therefore, just send a
// HTTP_GENERAL_PROTOCOL_ERROR.
if push_id < self.max_push_id {
conn.close(
true,
Error::GeneralProtocolError.to_wire(),
b"MAX_PUSH_ID reduced limit",
)?;
return Err(Error::GeneralProtocolError);
}
self.max_push_id = push_id;
},
frame::Frame::PushPromise { .. } => {
if self.is_server {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"PUSH_PROMISE received by server",
)?;
return Err(Error::UnexpectedFrame);
}
if stream_id % 4 != 0 {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"PUSH_PROMISE received on non-request stream",
)?;
return Err(Error::UnexpectedFrame);
}
// TODO: implement more checks and PUSH_PROMISE event
},
frame::Frame::DuplicatePush { .. } => {
if self.is_server {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"DUPLICATE_PUSH received by server",
)?;
return Err(Error::UnexpectedFrame);
}
if stream_id % 4 != 0 {
conn.close(
true,
Error::UnexpectedFrame.to_wire(),
b"DUPLICATE_PUSH received on non-request stream",
)?;
return Err(Error::UnexpectedFrame);
}
// TODO: implement DUPLICATE_PUSH
},
frame::Frame::CancelPush { .. } => {
if Some(stream_id) != self.peer_control_stream_id {
conn.close(
true,
Error::WrongStream.to_wire(),
b"CANCEL_PUSH received on non-control stream",
)?;
return Err(Error::WrongStream);
}
// TODO: implement CANCEL_PUSH frame
},
frame::Frame::Unknown => (),
}
Err(Error::Done)
}
}
/// Generates an HTTP/3 GREASE variable length integer.
fn grease_value() -> u64 {
let n = std::cmp::min(super::rand::rand_u64(), 148_764_065_110_560_899);
31 * n + 33
}
#[doc(hidden)]
pub mod testing {
use super::*;
use crate::testing;
/// Session is an HTTP/3 test helper structure. It holds a client, server
/// and pipe that allows them to communicate.
///
/// `default()` creates a session with some sensible default
/// configuration. `with_configs()` allows for providing a specific
/// configuration.
///
/// `handshake()` performs all the steps needed to establish an HTTP/3
/// connection.
///
/// Some utility functions are provided that make it less verbose to send
/// request, responses and individual headers. The full quiche API remains
/// available for any test that need to do unconventional things (such as
/// bad behaviour that triggers errors).
pub struct Session {
pub pipe: testing::Pipe,
pub client: Connection,
pub server: Connection,
buf: [u8; 65535],
}
impl Session {
pub fn default() -> Result<Session> {
let mut config = crate::Config::new(crate::PROTOCOL_VERSION)?;
config.load_cert_chain_from_pem_file("examples/cert.crt")?;
config.load_priv_key_from_pem_file("examples/cert.key")?;
config.set_application_protos(b"\x02h3")?;
config.set_initial_max_data(1500);
config.set_initial_max_stream_data_bidi_local(150);
config.set_initial_max_stream_data_bidi_remote(150);
config.set_initial_max_stream_data_uni(150);
config.set_initial_max_streams_bidi(5);
config.set_initial_max_streams_uni(5);
config.verify_peer(false);
let mut h3_config = Config::new(0, 1024, 0, 0)?;
Session::with_configs(&mut config, &mut h3_config)
}
pub fn with_configs(
config: &mut crate::Config, h3_config: &mut Config,
) -> Result<Session> {
Ok(Session {
pipe: testing::Pipe::with_config(config)?,
client: Connection::new(&h3_config, false)?,
server: Connection::new(&h3_config, true)?,
buf: [0; 65535],
})
}
/// Do the HTTP/3 handshake so both ends are in sane initial state.
pub fn handshake(&mut self) -> Result<()> {
self.pipe.handshake(&mut self.buf)?;
// Client streams.
self.client.send_settings(&mut self.pipe.client)?;
self.pipe.advance(&mut self.buf).ok();
self.client
.open_qpack_encoder_stream(&mut self.pipe.client)?;
self.pipe.advance(&mut self.buf).ok();
self.client
.open_qpack_decoder_stream(&mut self.pipe.client)?;
self.pipe.advance(&mut self.buf).ok();
if self.pipe.client.grease {
self.client.open_grease_stream(&mut self.pipe.client)?;
}
self.pipe.advance(&mut self.buf).ok();
// Server streams.
self.server.send_settings(&mut self.pipe.server)?;
self.pipe.advance(&mut self.buf).ok();
self.server
.open_qpack_encoder_stream(&mut self.pipe.server)?;
self.pipe.advance(&mut self.buf).ok();
self.server
.open_qpack_decoder_stream(&mut self.pipe.server)?;
self.pipe.advance(&mut self.buf).ok();
if self.pipe.server.grease {
self.server.open_grease_stream(&mut self.pipe.server)?;
}
self.advance().ok();
while self.client.poll(&mut self.pipe.client).is_ok() {
// Do nothing.
}
while self.server.poll(&mut self.pipe.server).is_ok() {
// Do nothing.
}
Ok(())
}
/// Advances the session pipe over the buffer.
pub fn advance(&mut self) -> crate::Result<()> {
self.pipe.advance(&mut self.buf)
}
/// Polls the client for events.
pub fn poll_client(&mut self) -> Result<(u64, Event)> {
self.client.poll(&mut self.pipe.client)
}
/// Polls the server for events.
pub fn poll_server(&mut self) -> Result<(u64, Event)> {
self.server.poll(&mut self.pipe.server)
}
/// Sends a request from client with default headers.
///
/// On success it returns the newly allocated stream and the headers.
pub fn send_request(&mut self, fin: bool) -> Result<(u64, Vec<Header>)> {
let req = vec![
Header::new(":method", "GET"),
Header::new(":scheme", "https"),
Header::new(":authority", "quic.tech"),
Header::new(":path", "/test"),
Header::new("user-agent", "quiche-test"),
];
let stream = self
.client
.send_request(&mut self.pipe.client, &req, fin)
.unwrap();
self.advance().ok();
Ok((stream, req))
}
/// Sends a response from server with default headers.
///
/// On success it returns the headers.
pub fn send_response(
&mut self, stream: u64, fin: bool,
) -> Result<Vec<Header>> {
let resp = vec![
Header::new(":status", "200"),
Header::new("server", "quiche-test"),
];
self.server.send_response(
&mut self.pipe.server,
stream,
&resp,
fin,
)?;
self.advance().ok();
Ok(resp)
}
/// Sends some default payload from client.
///
/// On success it returns the payload.
pub fn send_body_client(
&mut self, stream: u64, fin: bool,
) -> Result<Vec<u8>> {
let bytes = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
self.client
.send_body(&mut self.pipe.client, stream, &bytes, fin)?;
self.advance().ok();
Ok(bytes)
}
/// Fetches DATA payload from the server.
///
/// On success it returns the number of bytes received.
pub fn recv_body_client(
&mut self, stream: u64, buf: &mut [u8],
) -> Result<usize> {
self.client.recv_body(&mut self.pipe.client, stream, buf)
}
/// Sends some default payload from server.
///
/// On success it returns the payload.
pub fn send_body_server(
&mut self, stream: u64, fin: bool,
) -> Result<Vec<u8>> {
let bytes = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
self.server
.send_body(&mut self.pipe.server, stream, &bytes, fin)?;
self.advance().ok();
Ok(bytes)
}
/// Fetches DATA payload from the client.
///
/// On success it returns the number of bytes received.
pub fn recv_body_server(
&mut self, stream: u64, buf: &mut [u8],
) -> Result<usize> {
self.server.recv_body(&mut self.pipe.server, stream, buf)
}
/// Sends a single HTTP/3 frame from the client.
pub fn send_frame_client(
&mut self, frame: frame::Frame, stream_id: u64, fin: bool,
) -> Result<()> {
let mut d = [42; 65535];
let mut b = octets::Octets::with_slice(&mut d);
frame.to_bytes(&mut b)?;
let off = b.off();
self.pipe.client.stream_send(stream_id, &d[..off], fin)?;
self.advance().ok();
Ok(())
}
/// Sends a single HTTP/3 frame from the server.
pub fn send_frame_server(
&mut self, frame: frame::Frame, stream_id: u64, fin: bool,
) -> Result<()> {
let mut d = [42; 65535];
let mut b = octets::Octets::with_slice(&mut d);
frame.to_bytes(&mut b)?;
let off = b.off();
self.pipe.server.stream_send(stream_id, &d[..off], fin)?;
self.advance().ok();
Ok(())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use super::testing::*;
#[test]
/// Make sure that random GREASE values is within the specified limit.
fn grease_value_in_varint_limit() {
assert!(grease_value() < 2u64.pow(62) - 1);
}
#[test]
/// Send a request with no body, get a response with no body.
fn request_no_body_response_no_body() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(true).unwrap();
assert_eq!(stream, 0);
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
let resp = s.send_response(stream, true).unwrap();
assert_eq!(s.poll_client(), Ok((stream, Event::Headers(resp))));
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Send a request with no body, get a response with one DATA frame.
fn request_no_body_response_one_chunk() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(true).unwrap();
assert_eq!(stream, 0);
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
let resp = s.send_response(stream, false).unwrap();
let body = s.send_body_server(stream, true).unwrap();
let mut recv_buf = vec![0; body.len()];
assert_eq!(s.poll_client(), Ok((stream, Event::Headers(resp))));
assert_eq!(s.poll_client(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_client(stream, &mut recv_buf), Ok(body.len()));
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Send a request with no body, get a response with multiple DATA frames.
fn request_no_body_response_many_chunks() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(true).unwrap();
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
let total_data_frames = 4;
let resp = s.send_response(stream, false).unwrap();
for _ in 0..total_data_frames - 1 {
s.send_body_server(stream, false).unwrap();
}
let body = s.send_body_server(stream, true).unwrap();
let mut recv_buf = vec![0; body.len()];
assert_eq!(s.poll_client(), Ok((stream, Event::Headers(resp))));
for _ in 0..total_data_frames {
assert_eq!(s.poll_client(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_client(stream, &mut recv_buf), Ok(body.len()));
}
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Send a request with one DATA frame, get a response with no body.
fn request_one_chunk_response_no_body() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
let body = s.send_body_client(stream, true).unwrap();
let mut recv_buf = vec![0; body.len()];
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_server(stream, &mut recv_buf), Ok(body.len()));
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
let resp = s.send_response(stream, true).unwrap();
assert_eq!(s.poll_client(), Ok((stream, Event::Headers(resp))));
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
}
#[test]
/// Send a request with multiple DATA frames, get a response with no body.
fn request_many_chunks_response_no_body() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
let total_data_frames = 4;
for _ in 0..total_data_frames - 1 {
s.send_body_client(stream, false).unwrap();
}
let body = s.send_body_client(stream, true).unwrap();
let mut recv_buf = vec![0; body.len()];
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
for _ in 0..total_data_frames {
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_server(stream, &mut recv_buf), Ok(body.len()));
}
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
let resp = s.send_response(stream, true).unwrap();
assert_eq!(s.poll_client(), Ok((stream, Event::Headers(resp))));
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
}
#[test]
/// Send a request with multiple DATA frames, get a response with one DATA
/// frame.
fn many_requests_many_chunks_response_one_chunk() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut reqs = Vec::new();
let (stream1, req1) = s.send_request(false).unwrap();
assert_eq!(stream1, 0);
reqs.push(req1);
let (stream2, req2) = s.send_request(false).unwrap();
assert_eq!(stream2, 4);
reqs.push(req2);
let (stream3, req3) = s.send_request(false).unwrap();
assert_eq!(stream3, 8);
reqs.push(req3);
let body = s.send_body_client(stream1, false).unwrap();
s.send_body_client(stream2, false).unwrap();
s.send_body_client(stream3, false).unwrap();
let mut recv_buf = vec![0; body.len()];
// Reverse order of writes.
s.send_body_client(stream3, true).unwrap();
s.send_body_client(stream2, true).unwrap();
s.send_body_client(stream1, true).unwrap();
for _ in 0..reqs.len() {
let (stream, ev) = s.poll_server().unwrap();
assert_eq!(ev, Event::Headers(reqs[(stream / 4) as usize].clone()));
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_server(stream, &mut recv_buf), Ok(body.len()));
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(s.recv_body_server(stream, &mut recv_buf), Ok(body.len()));
assert_eq!(s.poll_server(), Ok((stream, Event::Finished)));
}
assert_eq!(s.poll_server(), Err(Error::Done));
let mut resps = Vec::new();
let resp1 = s.send_response(stream1, true).unwrap();
resps.push(resp1);
let resp2 = s.send_response(stream2, true).unwrap();
resps.push(resp2);
let resp3 = s.send_response(stream3, true).unwrap();
resps.push(resp3);
for _ in 0..resps.len() {
let (stream, ev) = s.poll_client().unwrap();
assert_eq!(ev, Event::Headers(resps[(stream / 4) as usize].clone()));
assert_eq!(s.poll_client(), Ok((stream, Event::Finished)));
}
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Try to send DATA frames on wrong streams, ensure the API returns an
/// error before anything hits the transport layer.
fn send_body_invalid_server_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
assert_eq!(s.send_body_server(0, true), Err(Error::WrongStream));
assert_eq!(
s.send_body_server(s.server.control_stream_id.unwrap(), true),
Err(Error::WrongStream)
);
assert_eq!(
s.send_body_server(
s.server.local_qpack_streams.encoder_stream_id.unwrap(),
true
),
Err(Error::WrongStream)
);
assert_eq!(
s.send_body_server(
s.server.local_qpack_streams.decoder_stream_id.unwrap(),
true
),
Err(Error::WrongStream)
);
assert_eq!(
s.send_body_server(s.server.peer_control_stream_id.unwrap(), true),
Err(Error::WrongStream)
);
assert_eq!(
s.send_body_server(
s.server.peer_qpack_streams.encoder_stream_id.unwrap(),
true
),
Err(Error::WrongStream)
);
assert_eq!(
s.send_body_server(
s.server.peer_qpack_streams.decoder_stream_id.unwrap(),
true
),
Err(Error::WrongStream)
);
}
#[test]
/// Send a MAX_PUSH_ID frame from the client on a valid stream.
fn max_push_id_from_client_good() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_client(
frame::Frame::MaxPushId { push_id: 1 },
s.client.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_server(), Err(Error::Done));
}
#[test]
/// Send a MAX_PUSH_ID frame from the client on an invalid stream.
fn max_push_id_from_client_bad_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
s.send_frame_client(
frame::Frame::MaxPushId { push_id: 2 },
stream,
false,
)
.unwrap();
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Err(Error::WrongStream));
}
#[test]
/// Send a sequence of MAX_PUSH_ID frames from the client that attempt to
/// reduce the limit.
fn max_push_id_from_client_limit_reduction() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_client(
frame::Frame::MaxPushId { push_id: 2 },
s.client.control_stream_id.unwrap(),
false,
)
.unwrap();
s.send_frame_client(
frame::Frame::MaxPushId { push_id: 1 },
s.client.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_server(), Err(Error::GeneralProtocolError));
}
#[test]
/// Send a MAX_PUSH_ID frame from the server, which is forbidden.
fn max_push_id_from_server() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_server(
frame::Frame::MaxPushId { push_id: 1 },
s.server.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_client(), Err(Error::UnexpectedFrame));
}
#[test]
/// Send a PUSH_PROMISE frame from the client, which is forbidden.
fn push_promise_from_client() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
let header_block = s.client.encode_header_block(&req).unwrap();
s.send_frame_client(
frame::Frame::PushPromise {
push_id: 1,
header_block,
},
stream,
false,
)
.unwrap();
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Err(Error::UnexpectedFrame));
}
#[test]
/// Send a CANCEL_PUSH frame from the client.
fn cancel_push_from_client() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_client(
frame::Frame::CancelPush { push_id: 1 },
s.client.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_server(), Err(Error::Done));
}
#[test]
/// Send a CANCEL_PUSH frame from the client on an invalid stream.
fn cancel_push_from_client_bad_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
s.send_frame_client(
frame::Frame::CancelPush { push_id: 2 },
stream,
false,
)
.unwrap();
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Err(Error::WrongStream));
}
#[test]
/// Send a CANCEL_PUSH frame from the client.
fn cancel_push_from_server() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_server(
frame::Frame::CancelPush { push_id: 1 },
s.server.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Send a DUPLICATE_PUSH frame from the client, which is forbidden.
fn duplicate_push_from_client() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
s.send_frame_client(
frame::Frame::DuplicatePush { push_id: 1 },
stream,
false,
)
.unwrap();
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
assert_eq!(s.poll_server(), Err(Error::UnexpectedFrame));
}
#[test]
/// Send a GOAWAY frame from the client, which is forbidden.
fn goaway_from_client() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_client(
frame::Frame::GoAway { stream_id: 100 },
s.client.control_stream_id.unwrap(),
false,
)
.unwrap();
s.advance().ok();
assert_eq!(s.poll_server(), Err(Error::UnexpectedFrame));
}
#[test]
/// Send a GOAWAY frame from the server.
fn goaway_from_server_good() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_server(
frame::Frame::GoAway { stream_id: 100 },
s.server.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_client(), Err(Error::Done));
}
#[test]
/// Send a GOAWAY frame from the server, that references a request that does
/// not exist.
fn goaway_from_server_bad_id() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
s.send_frame_server(
frame::Frame::GoAway { stream_id: 1 },
s.server.control_stream_id.unwrap(),
false,
)
.unwrap();
assert_eq!(s.poll_client(), Err(Error::WrongStream));
}
#[test]
/// Send a PRIORITY frame from the client, ensure server accepts it.
fn priority_control_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut d = [42; 128];
let mut b = octets::Octets::with_slice(&mut d);
// Create an approximate PRIORITY frame in the buffer.
b.put_varint(frame::PRIORITY_FRAME_TYPE_ID).unwrap();
b.put_varint(1 + octets::varint_parse_len(1) as u64 + 1)
.unwrap(); // 2 u8s = Bitfield + varint + Weight
b.put_u8(176).unwrap(); // bitfield
b.put_varint(1).unwrap();
b.put_u8(16).unwrap(); // weight
let off = b.off();
s.pipe
.client
.stream_send(s.client.control_stream_id.unwrap(), &d[..off], false)
.unwrap();
s.advance().ok();
assert_eq!(s.poll_server(), Err(Error::Done));
}
#[test]
/// Ensure quiche allocates streams for client and server roles as expected.
fn uni_stream_local_counting() {
let config = Config::new(0, 1024, 0, 0).unwrap();
let mut h3_cln = Connection::new(&config, false).unwrap();
assert_eq!(h3_cln.get_available_uni_stream().unwrap(), 2);
assert_eq!(h3_cln.get_available_uni_stream().unwrap(), 6);
assert_eq!(h3_cln.get_available_uni_stream().unwrap(), 10);
assert_eq!(h3_cln.get_available_uni_stream().unwrap(), 14);
assert_eq!(h3_cln.get_available_uni_stream().unwrap(), 18);
let mut h3_srv = Connection::new(&config, true).unwrap();
assert_eq!(h3_srv.get_available_uni_stream().unwrap(), 3);
assert_eq!(h3_srv.get_available_uni_stream().unwrap(), 7);
assert_eq!(h3_srv.get_available_uni_stream().unwrap(), 11);
assert_eq!(h3_srv.get_available_uni_stream().unwrap(), 15);
assert_eq!(h3_srv.get_available_uni_stream().unwrap(), 19);
}
#[test]
/// Client opens multiple control streams, which is forbidden.
fn open_multiple_control_streams() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let stream_id = s.client.get_available_uni_stream().unwrap();
let mut d = [42; 8];
let mut b = octets::Octets::with_slice(&mut d);
s.pipe
.client
.stream_send(
stream_id,
b.put_varint(stream::HTTP3_CONTROL_STREAM_TYPE_ID).unwrap(),
false,
)
.unwrap();
s.advance().ok();
assert_eq!(s.poll_server(), Err(Error::StreamCreationError));
}
#[test]
/// Client closes the control stream, which is forbidden.
fn close_control_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut control_stream_closed = false;
s.send_frame_client(
frame::Frame::MaxPushId { push_id: 1 },
s.client.control_stream_id.unwrap(),
true,
)
.unwrap();
loop {
match s.server.poll(&mut s.pipe.server) {
Ok(_) => (),
Err(Error::Done) => {
break;
},
Err(Error::ClosedCriticalStream) => {
control_stream_closed = true;
break;
},
Err(_) => (),
}
}
assert!(control_stream_closed);
}
#[test]
/// Client closes QPACK stream, which is forbidden.
fn close_qpack_stream() {
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut qpack_stream_closed = false;
let stream_id = s.client.local_qpack_streams.encoder_stream_id.unwrap();
let d = [0; 1];
s.pipe.client.stream_send(stream_id, &d, false).unwrap();
s.pipe.client.stream_send(stream_id, &d, true).unwrap();
s.advance().ok();
loop {
match s.server.poll(&mut s.pipe.server) {
Ok(_) => (),
Err(Error::Done) => {
break;
},
Err(Error::ClosedCriticalStream) => {
qpack_stream_closed = true;
break;
},
Err(_) => (),
}
}
assert!(qpack_stream_closed);
}
#[test]
/// Client sends QPACK data.
fn qpack_data() {
// TODO: QPACK instructions are ignored until dynamic table support is
// added so we just test that the data is safely ignored.
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let e_stream_id = s.client.local_qpack_streams.encoder_stream_id.unwrap();
let d_stream_id = s.client.local_qpack_streams.decoder_stream_id.unwrap();
let d = [0; 20];
s.pipe.client.stream_send(e_stream_id, &d, false).unwrap();
s.pipe.client.stream_send(d_stream_id, &d, false).unwrap();
s.advance().ok();
loop {
match s.server.poll(&mut s.pipe.server) {
Ok(_) => (),
Err(Error::Done) => {
break;
},
Err(_) => {
panic!();
},
}
}
}
#[test]
/// Tests limits for the stream state buffer maximum size.
fn max_state_buf_size() {
// DATA frames don't consume the state buffer, so can be of any size.
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut d = [42; 128];
let mut b = octets::Octets::with_slice(&mut d);
let frame_type = b.put_varint(frame::DATA_FRAME_TYPE_ID).unwrap();
s.pipe.client.stream_send(0, frame_type, false).unwrap();
let frame_len = b.put_varint(1 << 24).unwrap();
s.pipe.client.stream_send(0, frame_len, false).unwrap();
s.pipe.client.stream_send(0, &d, false).unwrap();
s.advance().ok();
assert_eq!(s.server.poll(&mut s.pipe.server), Ok((0, Event::Data)));
// GREASE frames consume the state buffer, so need to be limited.
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let mut d = [42; 128];
let mut b = octets::Octets::with_slice(&mut d);
let frame_type = b.put_varint(148_764_065_110_560_899).unwrap();
s.pipe.client.stream_send(0, frame_type, false).unwrap();
let frame_len = b.put_varint(1 << 24).unwrap();
s.pipe.client.stream_send(0, frame_len, false).unwrap();
s.pipe.client.stream_send(0, &d, false).unwrap();
s.advance().ok();
assert_eq!(s.server.poll(&mut s.pipe.server), Err(Error::InternalError));
}
#[test]
/// Tests that DATA frames are properly truncated depending on the request
/// stream's outgoing flow control capacity.
fn stream_backpressure() {
let bytes = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let mut s = Session::default().unwrap();
s.handshake().unwrap();
let (stream, req) = s.send_request(false).unwrap();
let total_data_frames = 6;
for _ in 0..total_data_frames {
assert_eq!(
s.client
.send_body(&mut s.pipe.client, stream, &bytes, false),
Ok(bytes.len())
);
s.advance().ok();
}
assert_eq!(
s.client.send_body(&mut s.pipe.client, stream, &bytes, true),
Ok(bytes.len() - 2)
);
s.advance().ok();
let mut recv_buf = vec![0; bytes.len()];
assert_eq!(s.poll_server(), Ok((stream, Event::Headers(req))));
for _ in 0..total_data_frames {
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(
s.recv_body_server(stream, &mut recv_buf),
Ok(bytes.len())
);
}
assert_eq!(s.poll_server(), Ok((stream, Event::Data)));
assert_eq!(
s.recv_body_server(stream, &mut recv_buf),
Ok(bytes.len() - 2)
);
// Fin flag from last send_body() call was not sent as the buffer was
// only partially written.
assert_eq!(s.poll_server(), Err(Error::Done));
}
}
mod ffi;
mod frame;
#[doc(hidden)]
pub mod qpack;
mod stream;