|
|
@@ -0,0 +1,1802 @@
|
|
|
+%% Copyright (c) 2023, Loïc Hoguin <essen@ninenines.eu>
|
|
|
+%%
|
|
|
+%% Permission to use, copy, modify, and/or distribute this software for any
|
|
|
+%% purpose with or without fee is hereby granted, provided that the above
|
|
|
+%% copyright notice and this permission notice appear in all copies.
|
|
|
+%%
|
|
|
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
+
|
|
|
+-module(rfc9114_SUITE).
|
|
|
+-compile(export_all).
|
|
|
+-compile(nowarn_export_all).
|
|
|
+
|
|
|
+-import(ct_helper, [config/2]).
|
|
|
+-import(ct_helper, [doc/1]).
|
|
|
+
|
|
|
+-include_lib("quicer/include/quicer.hrl").
|
|
|
+
|
|
|
+all() -> [{group, quic}].
|
|
|
+
|
|
|
+groups() ->
|
|
|
+ %% @todo Enable parallel tests but for this issues in the
|
|
|
+ %% QUIC accept loop need to be figured out (can't connect
|
|
|
+ %% concurrently somehow, no backlog?).
|
|
|
+ [{quic, [], ct_helper:all(?MODULE)}].
|
|
|
+
|
|
|
+init_per_group(Name = quic, Config) ->
|
|
|
+ cowboy_test:init_http3(Name, #{
|
|
|
+ env => #{dispatch => cowboy_router:compile(init_routes(Config))}
|
|
|
+ }, Config).
|
|
|
+
|
|
|
+end_per_group(_Name, _) ->
|
|
|
+ ok. %% @todo = cowboy:stop_listener(Name).
|
|
|
+
|
|
|
+init_routes(_) -> [
|
|
|
+ {"localhost", [
|
|
|
+ {"/", hello_h, []}%,
|
|
|
+% {"/echo/:key", echo_h, []},
|
|
|
+% {"/delay_hello", delay_hello_h, 1200},
|
|
|
+% {"/long_polling", long_polling_h, []},
|
|
|
+% {"/loop_handler_abort", loop_handler_abort_h, []},
|
|
|
+% {"/resp/:key[/:arg]", resp_h, []}
|
|
|
+ ]}
|
|
|
+].
|
|
|
+
|
|
|
+%% Starting HTTP/3 for "https" URIs.
|
|
|
+
|
|
|
+alpn(Config) ->
|
|
|
+ doc("Successful ALPN negotiation. (RFC9114 3.1)"),
|
|
|
+ {ok, Conn} = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h3"], verify => none}, 5000),
|
|
|
+ {ok, <<"h3">>} = quicer:getopt(Conn, param_tls_negotiated_alpn, quic_tls),
|
|
|
+ %% To make sure the connection is fully established we wait
|
|
|
+ %% to receive the SETTINGS frame on the control stream.
|
|
|
+ {ok, _ControlRef, _Settings} = do_wait_settings(Conn),
|
|
|
+ ok.
|
|
|
+
|
|
|
+alpn_error(Config) ->
|
|
|
+ doc("Failed ALPN negotiation using the 'h2' token. (RFC9114 3.1)"),
|
|
|
+ {error, transport_down, #{status := alpn_neg_failure}}
|
|
|
+ = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h2"], verify => none}, 5000),
|
|
|
+ ok.
|
|
|
+
|
|
|
+%% @todo 3.2. Connection Establishment
|
|
|
+%% After the QUIC connection is established, a SETTINGS frame MUST be sent by each endpoint as the initial frame of their respective HTTP control stream.
|
|
|
+
|
|
|
+%% @todo 3.3. Connection Reuse
|
|
|
+%% Servers are encouraged to maintain open HTTP/3 connections for as long as
|
|
|
+%possible but are permitted to terminate idle connections if necessary. When
|
|
|
+%either endpoint chooses to close the HTTP/3 connection, the terminating
|
|
|
+%endpoint SHOULD first send a GOAWAY frame (Section 5.2) so that both endpoints
|
|
|
+%can reliably determine whether previously sent frames have been processed and
|
|
|
+%gracefully complete or terminate any necessary remaining tasks.
|
|
|
+
|
|
|
+%% Frame format.
|
|
|
+
|
|
|
+req_stream(Config) ->
|
|
|
+ doc("Complete lifecycle of a request stream. (RFC9114 4.1)"),
|
|
|
+ {ok, Conn} = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h3"], verify => none}, 5000),
|
|
|
+ %% To make sure the connection is fully established we wait
|
|
|
+ %% to receive the SETTINGS frame on the control stream.
|
|
|
+ {ok, ControlRef, _Settings} = do_wait_settings(Conn),
|
|
|
+ %% Send a request on a request stream.
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedRequest, _EncData, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedRequest)),
|
|
|
+ EncodedRequest
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ %% Receive the response.
|
|
|
+ {ok, Data} = do_receive_data(StreamRef),
|
|
|
+ {HLenEnc, HLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 1, %% HEADERS frame.
|
|
|
+ HLenEnc:2, HLen:HLenBits,
|
|
|
+ EncodedResponse:HLen/bytes,
|
|
|
+ Rest/bits
|
|
|
+ >> = Data,
|
|
|
+ {ok, DecodedResponse, _DecData, _DecSt}
|
|
|
+ = cow_qpack:decode_field_section(EncodedResponse, 0, cow_qpack:init()),
|
|
|
+ #{
|
|
|
+ <<":status">> := <<"200">>,
|
|
|
+ <<"content-length">> := BodyLen
|
|
|
+ } = maps:from_list(DecodedResponse),
|
|
|
+ {DLenEnc, DLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 0, %% DATA frame.
|
|
|
+ DLenEnc:2, DLen:DLenBits,
|
|
|
+ Body:DLen/bytes
|
|
|
+ >> = Rest,
|
|
|
+ <<"Hello world!">> = Body,
|
|
|
+ BodyLen = integer_to_binary(byte_size(Body)),
|
|
|
+ ok = do_wait_peer_send_shutdown(StreamRef),
|
|
|
+ ok = do_wait_stream_closed(StreamRef).
|
|
|
+
|
|
|
+%% @todo Same test as above but with content-length unset?
|
|
|
+
|
|
|
+req_stream_two_requests(Config) ->
|
|
|
+ doc("Receipt of multiple requests on a single stream must "
|
|
|
+ "be rejected with an H3_MESSAGE_ERROR stream error. "
|
|
|
+ "(RFC9114 4.1, RFC9114 4.1.2)"),
|
|
|
+ {ok, Conn} = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h3"], verify => none}, 5000),
|
|
|
+ %% To make sure the connection is fully established we wait
|
|
|
+ %% to receive the SETTINGS frame on the control stream.
|
|
|
+ {ok, ControlRef, _Settings} = do_wait_settings(Conn),
|
|
|
+ %% Send two requests on a request stream.
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedRequest1, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedRequest2, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedRequest1)),
|
|
|
+ EncodedRequest1,
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedRequest2)),
|
|
|
+ EncodedRequest2
|
|
|
+ ]),
|
|
|
+ %% The stream should have been aborted.
|
|
|
+ #{reason := h3_message_error} = do_wait_stream_aborted(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+req_stream_two_requests_sequential(Config) ->
|
|
|
+ doc("Receipt of multiple requests on a single stream must "
|
|
|
+ "be rejected with an H3_MESSAGE_ERROR stream error. "
|
|
|
+ "(RFC9114 4.1, RFC9114 4.1.2)"),
|
|
|
+ {ok, Conn} = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h3"], verify => none}, 5000),
|
|
|
+ %% To make sure the connection is fully established we wait
|
|
|
+ %% to receive the SETTINGS frame on the control stream.
|
|
|
+ {ok, ControlRef, _Settings} = do_wait_settings(Conn),
|
|
|
+ %% Send a first request.
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedRequest1, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedRequest1)),
|
|
|
+ EncodedRequest1
|
|
|
+ ]),
|
|
|
+ %% Receive the response.
|
|
|
+ {ok, Data} = do_receive_data(StreamRef),
|
|
|
+ {HLenEnc, HLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 1, %% HEADERS frame.
|
|
|
+ HLenEnc:2, HLen:HLenBits,
|
|
|
+ EncodedResponse:HLen/bytes,
|
|
|
+ Rest/bits
|
|
|
+ >> = Data,
|
|
|
+ {ok, DecodedResponse, _DecData, _DecSt}
|
|
|
+ = cow_qpack:decode_field_section(EncodedResponse, 0, cow_qpack:init()),
|
|
|
+ #{
|
|
|
+ <<":status">> := <<"200">>,
|
|
|
+ <<"content-length">> := BodyLen
|
|
|
+ } = maps:from_list(DecodedResponse),
|
|
|
+ {DLenEnc, DLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 0, %% DATA frame.
|
|
|
+ DLenEnc:2, DLen:DLenBits,
|
|
|
+ Body:DLen/bytes
|
|
|
+ >> = Rest,
|
|
|
+ <<"Hello world!">> = Body,
|
|
|
+ BodyLen = integer_to_binary(byte_size(Body)),
|
|
|
+ ok = do_wait_peer_send_shutdown(StreamRef),
|
|
|
+ %% Send a second request.
|
|
|
+ {ok, EncodedRequest2, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedRequest2)),
|
|
|
+ EncodedRequest2
|
|
|
+ ]),
|
|
|
+ %% The stream should have been aborted.
|
|
|
+ #{reason := h3_message_error} = do_wait_stream_aborted(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_trailers(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by trailer HEADERS must be accepted. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_trailers(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by trailer HEADERS "
|
|
|
+ "must be accepted. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+data_then_headers(Config) ->
|
|
|
+ doc("Receipt of DATA before HEADERS must be rejected "
|
|
|
+ "with an H3_FRAME_UNEXPECTED connection error. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ %% The connection should have been closed.
|
|
|
+ #{reason := h3_frame_unexpected} = do_wait_connection_closed(Conn),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_trailers_then_data(Config) ->
|
|
|
+ doc("Receipt of DATA after trailer HEADERS must be rejected "
|
|
|
+ "with an H3_FRAME_UNEXPECTED connection error. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ %% The connection should have been closed.
|
|
|
+ #{reason := h3_frame_unexpected} = do_wait_connection_closed(Conn),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_trailers_then_data(Config) ->
|
|
|
+ doc("Receipt of DATA after trailer HEADERS must be rejected "
|
|
|
+ "with an H3_FRAME_UNEXPECTED connection error. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ %% The connection should have been closed.
|
|
|
+ #{reason := h3_frame_unexpected} = do_wait_connection_closed(Conn),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_trailers_then_trailers(Config) ->
|
|
|
+ doc("Receipt of DATA after trailer HEADERS must be rejected "
|
|
|
+ "with an H3_FRAME_UNEXPECTED connection error. (RFC9114 4.1)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers1, _EncData2, EncSt1} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, EncodedTrailers2, _EncData3, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt1),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers1)),
|
|
|
+ EncodedTrailers1,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers2)),
|
|
|
+ EncodedTrailers2
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ %% The connection should have been closed.
|
|
|
+ #{reason := h3_frame_unexpected} = do_wait_connection_closed(Conn),
|
|
|
+ ok.
|
|
|
+
|
|
|
+unknown_then_headers(Config) ->
|
|
|
+ doc("Receipt of unknown frame followed by HEADERS "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ unknown_then_headers(Config, do_unknown_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+unknown_then_headers(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes,
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_unknown(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by unknown frame "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_unknown(Config, do_unknown_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_unknown(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_unknown(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by unknown frame "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_data_then_unknown(Config, do_unknown_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_unknown(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_trailers_then_unknown(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by trailer HEADERS followed by unknown frame "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_data_then_unknown(Config, do_unknown_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_trailers_then_unknown(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_unknown_then_trailers(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "unknown frame followed by trailer HEADERS "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_data_then_unknown_then_trailers(Config,
|
|
|
+ do_unknown_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_unknown_then_trailers(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_unknown_then_data(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "unknown frame followed by DATA "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_data_then_unknown_then_data(Config,
|
|
|
+ do_unknown_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_unknown_then_data(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(6),
|
|
|
+ <<"Hello ">>,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(7),
|
|
|
+ <<"server!">>
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+headers_then_data_then_trailers_then_unknown(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "trailer HEADERS followed by unknown frame "
|
|
|
+ "must be accepted. (RFC9114 4.1, RFC9114 9)"),
|
|
|
+ headers_then_data_then_trailers_then_unknown(Config,
|
|
|
+ do_unknown_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_trailers_then_unknown(Config, Type, Bytes) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"13">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(13),
|
|
|
+ <<"Hello server!">>,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers,
|
|
|
+ cow_http3:encode_int(Type), %% Unknown frame.
|
|
|
+ cow_http3:encode_int(iolist_size(Bytes)),
|
|
|
+ Bytes
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+do_unknown_frame_type() ->
|
|
|
+ Type = rand:uniform(4611686018427387904) - 1,
|
|
|
+ %% Retry if we get a value that's specified.
|
|
|
+ case lists:member(Type, [
|
|
|
+ 16#0, 16#1, 16#3, 16#4, 16#5, 16#7, 16#d, %% HTTP/3 core frame types.
|
|
|
+ 16#2, 16#6, 16#8, 16#9 %% HTTP/3 reserved frame types that must be rejected.
|
|
|
+ ]) of
|
|
|
+ true -> do_unknown_frame_type();
|
|
|
+ false -> Type
|
|
|
+ end.
|
|
|
+
|
|
|
+reserved_then_headers(Config) ->
|
|
|
+ doc("Receipt of reserved frame followed by HEADERS "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ unknown_then_headers(Config, do_reserved_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_reserved(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by reserved frame "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_unknown(Config, do_reserved_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_reserved(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by reserved frame "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_data_then_unknown(Config, do_reserved_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_trailers_then_reserved(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by trailer HEADERS followed by reserved frame "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_trailers_then_unknown(Config, do_reserved_frame_type(),
|
|
|
+ rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_reserved_then_trailers(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "reserved frame followed by trailer HEADERS "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_data_then_unknown_then_trailers(Config,
|
|
|
+ do_reserved_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_reserved_then_data(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "reserved frame followed by DATA "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_data_then_unknown_then_data(Config,
|
|
|
+ do_reserved_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+headers_then_data_then_trailers_then_reserved(Config) ->
|
|
|
+ doc("Receipt of HEADERS followed by DATA followed by "
|
|
|
+ "trailer HEADERS followed by reserved frame "
|
|
|
+ "must be accepted when the reserved frame type is "
|
|
|
+ "of the format 0x1f * N + 0x21. (RFC9114 4.1, RFC9114 7.2.8)"),
|
|
|
+ headers_then_data_then_trailers_then_unknown(Config,
|
|
|
+ do_reserved_frame_type(), rand:bytes(rand:uniform(4096))).
|
|
|
+
|
|
|
+do_reserved_frame_type() ->
|
|
|
+ 16#1f * (rand:uniform(148764065110560900) - 1) + 16#21.
|
|
|
+
|
|
|
+reject_transfer_encoding_header_with_body(Config) ->
|
|
|
+ doc("Requests containing a transfer-encoding header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.1, RFC9114 4.1.2, RFC9114 4.2)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, _EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"transfer-encoding">>, <<"chunked">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(24),
|
|
|
+ <<"13\r\nHello server!\r\n0\r\n\r\n">>
|
|
|
+ ]),
|
|
|
+ %% The stream should have been aborted.
|
|
|
+ #{reason := h3_message_error} = do_wait_stream_aborted(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+%% 4. Expressing HTTP Semantics in HTTP/3
|
|
|
+%% 4.1. HTTP Message Framing
|
|
|
+
|
|
|
+%% An HTTP request/response exchange fully consumes a client-initiated
|
|
|
+%bidirectional QUIC stream. After sending a request, a client MUST close the
|
|
|
+%stream for sending. Unless using the CONNECT method (see Section 4.4), clients
|
|
|
+%MUST NOT make stream closure dependent on receiving a response to their
|
|
|
+%request. After sending a final response, the server MUST close the stream for
|
|
|
+%sending. At this point, the QUIC stream is fully closed.
|
|
|
+%% @todo What to do with clients that DON'T close the stream
|
|
|
+%% for sending after the request is sent?
|
|
|
+
|
|
|
+%% If a client-initiated stream terminates without enough of the HTTP message
|
|
|
+%to provide a complete response, the server SHOULD abort its response stream
|
|
|
+%with the error code H3_REQUEST_INCOMPLETE.
|
|
|
+%% @todo difficult!!
|
|
|
+
|
|
|
+%% When the server does not need to receive the remainder of the request, it
|
|
|
+%MAY abort reading the request stream, send a complete response, and cleanly
|
|
|
+%close the sending part of the stream. The error code H3_NO_ERROR SHOULD be
|
|
|
+%used when requesting that the client stop sending on the request stream.
|
|
|
+%% @todo read_body related; h2 has this behavior but there is no corresponding test
|
|
|
+
|
|
|
+%% 4.1.1. Request Cancellation and Rejection
|
|
|
+
|
|
|
+%% When possible, it is RECOMMENDED that servers send an HTTP response with an
|
|
|
+%appropriate status code rather than cancelling a request it has already begun
|
|
|
+%processing.
|
|
|
+
|
|
|
+%% Implementations SHOULD cancel requests by abruptly terminating any
|
|
|
+%directions of a stream that are still open. To do so, an implementation resets
|
|
|
+%the sending parts of streams and aborts reading on the receiving parts of
|
|
|
+%streams; see Section 2.4 of [QUIC-TRANSPORT].
|
|
|
+
|
|
|
+%% When the server cancels a request without performing any application
|
|
|
+%processing, the request is considered "rejected". The server SHOULD abort its
|
|
|
+%response stream with the error code H3_REQUEST_REJECTED. In this context,
|
|
|
+%"processed" means that some data from the stream was passed to some higher
|
|
|
+%layer of software that might have taken some action as a result. The client
|
|
|
+%can treat requests rejected by the server as though they had never been sent
|
|
|
+%at all, thereby allowing them to be retried later.
|
|
|
+
|
|
|
+%% Servers MUST NOT use the H3_REQUEST_REJECTED error code for requests that
|
|
|
+%were partially or fully processed. When a server abandons a response after
|
|
|
+%partial processing, it SHOULD abort its response stream with the error code
|
|
|
+%H3_REQUEST_CANCELLED.
|
|
|
+%% @todo
|
|
|
+
|
|
|
+%% Client SHOULD use the error code H3_REQUEST_CANCELLED to cancel requests.
|
|
|
+%Upon receipt of this error code, a server MAY abruptly terminate the response
|
|
|
+%using the error code H3_REQUEST_REJECTED if no processing was performed.
|
|
|
+%Clients MUST NOT use the H3_REQUEST_REJECTED error code, except when a server
|
|
|
+%has requested closure of the request stream with this error code.
|
|
|
+%% @todo
|
|
|
+
|
|
|
+%4.1.2. Malformed Requests and Responses
|
|
|
+%A malformed request or response is one that is an otherwise valid sequence of
|
|
|
+%frames but is invalid due to:
|
|
|
+%
|
|
|
+%the presence of prohibited fields or pseudo-header fields,
|
|
|
+%% @todo reject_response_pseudo_headers
|
|
|
+%% @todo reject_unknown_pseudo_headers
|
|
|
+%% @todo reject_pseudo_headers_in_trailers
|
|
|
+
|
|
|
+%the absence of mandatory pseudo-header fields,
|
|
|
+%invalid values for pseudo-header fields,
|
|
|
+%pseudo-header fields after fields,
|
|
|
+%% @todo reject_pseudo_headers_after_regular_headers
|
|
|
+
|
|
|
+%an invalid sequence of HTTP messages,
|
|
|
+%the inclusion of invalid characters in field names or values.
|
|
|
+%
|
|
|
+%A request or response that is defined as having content when it contains a
|
|
|
+%Content-Length header field (Section 8.6 of [HTTP]) is malformed if the value
|
|
|
+%of the Content-Length header field does not equal the sum of the DATA frame
|
|
|
+%lengths received. A response that is defined as never having content, even
|
|
|
+%when a Content-Length is present, can have a non-zero Content-Length header
|
|
|
+%field even though no content is included in DATA frames.
|
|
|
+%
|
|
|
+%For malformed requests, a server MAY send an HTTP response indicating the
|
|
|
+%error prior to closing or resetting the stream.
|
|
|
+%% @todo All the malformed tests
|
|
|
+
|
|
|
+headers_reject_uppercase_header_name(Config) ->
|
|
|
+ doc("Requests containing uppercase header names must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"I-AM-GIGANTIC">>, <<"How's the weather up there?">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+%% 4.2. HTTP Fields
|
|
|
+%% An endpoint MUST NOT generate an HTTP/3 field section containing
|
|
|
+%connection-specific fields; any message containing connection-specific fields
|
|
|
+%MUST be treated as malformed.
|
|
|
+
|
|
|
+reject_connection_header(Config) ->
|
|
|
+ doc("Requests containing a connection header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"connection">>, <<"close">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_keep_alive_header(Config) ->
|
|
|
+ doc("Requests containing a keep-alive header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"keep-alive">>, <<"timeout=5, max=1000">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_proxy_authenticate_header(Config) ->
|
|
|
+ doc("Requests containing a proxy-authenticate header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"proxy-authenticate">>, <<"Basic">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_proxy_authorization_header(Config) ->
|
|
|
+ doc("Requests containing a proxy-authorization header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"proxy-authorization">>, <<"Basic YWxhZGRpbjpvcGVuc2VzYW1l">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_transfer_encoding_header(Config) ->
|
|
|
+ doc("Requests containing a transfer-encoding header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"transfer-encoding">>, <<"chunked">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_upgrade_header(Config) ->
|
|
|
+ doc("Requests containing an upgrade header must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"upgrade">>, <<"websocket">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+accept_te_header_value_trailers(Config) ->
|
|
|
+ doc("Requests containing a TE header with a value of \"trailers\" "
|
|
|
+ "must be accepted. (RFC9114 4.2)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"content-length">>, <<"0">>},
|
|
|
+ {<<"te">>, <<"trailers">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"content-type">>, <<"text/plain">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers
|
|
|
+ ]),
|
|
|
+ ok = do_async_stream_shutdown(StreamRef),
|
|
|
+ #{
|
|
|
+ headers := #{<<":status">> := <<"200">>},
|
|
|
+ body := <<"Hello world!">>
|
|
|
+ } = do_receive_response(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+reject_te_header_other_values(Config) ->
|
|
|
+ doc("Requests containing a TE header with a value other than \"trailers\" must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.2, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<"te">>, <<"trailers, deflate;q=0.5">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+%% @todo response_dont_send_header_in_connection
|
|
|
+%% @todo response_dont_send_connection_header
|
|
|
+%% @todo response_dont_send_keep_alive_header
|
|
|
+%% @todo response_dont_send_proxy_connection_header
|
|
|
+%% @todo response_dont_send_transfer_encoding_header
|
|
|
+%% @todo response_dont_send_upgrade_header
|
|
|
+
|
|
|
+%% 4.2.1. Field Compression
|
|
|
+%% To allow for better compression efficiency, the Cookie header field
|
|
|
+%([COOKIES]) MAY be split into separate field lines, each with one or more
|
|
|
+%cookie-pairs, before compression. If a decompressed field section contains
|
|
|
+%multiple cookie field lines, these MUST be concatenated into a single byte
|
|
|
+%string using the two-byte delimiter of "; " (ASCII 0x3b, 0x20) before being
|
|
|
+%passed into a context other than HTTP/2 or HTTP/3, such as an HTTP/1.1
|
|
|
+%connection, or a generic HTTP server application.
|
|
|
+
|
|
|
+%% 4.2.2. Header Size Constraints
|
|
|
+%% An HTTP/3 implementation MAY impose a limit on the maximum size of the
|
|
|
+%message header it will accept on an individual HTTP message. A server that
|
|
|
+%receives a larger header section than it is willing to handle can send an HTTP
|
|
|
+%431 (Request Header Fields Too Large) status code ([RFC6585]). The size of a
|
|
|
+%field list is calculated based on the uncompressed size of fields, including
|
|
|
+%the length of the name and value in bytes plus an overhead of 32 bytes for
|
|
|
+%each field.
|
|
|
+%% If an implementation wishes to advise its peer of this limit, it can be
|
|
|
+%conveyed as a number of bytes in the SETTINGS_MAX_FIELD_SECTION_SIZE
|
|
|
+%parameter.
|
|
|
+
|
|
|
+reject_unknown_pseudo_headers(Config) ->
|
|
|
+ doc("Requests containing unknown pseudo-headers must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<":upgrade">>, <<"websocket">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_response_pseudo_headers(Config) ->
|
|
|
+ doc("Requests containing response pseudo-headers must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_header(Config,
|
|
|
+ {<<":status">>, <<"200">>}
|
|
|
+ ).
|
|
|
+
|
|
|
+reject_pseudo_headers_in_trailers(Config) ->
|
|
|
+ doc("Requests containing pseudo-headers in trailers must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3, RFC9114 4.1.2)"),
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, EncSt0} = cow_qpack:encode_field_section([
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<"trailer">>, <<"x-checksum">>}
|
|
|
+ ], 0, cow_qpack:init()),
|
|
|
+ {ok, EncodedTrailers, _EncData2, _EncSt} = cow_qpack:encode_field_section([
|
|
|
+ {<<"x-checksum">>, <<"md5:4cc909a007407f3706399b6496babec3">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ], 0, EncSt0),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders,
|
|
|
+ <<0>>, %% DATA frame.
|
|
|
+ cow_http3:encode_int(10000),
|
|
|
+ <<0:10000/unit:8>>,
|
|
|
+ <<1>>, %% HEADERS frame for trailers.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedTrailers)),
|
|
|
+ EncodedTrailers
|
|
|
+ ]),
|
|
|
+ %% The stream should have been aborted.
|
|
|
+ #{reason := h3_message_error} = do_wait_stream_aborted(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+reject_pseudo_headers_after_regular_headers(Config) ->
|
|
|
+ doc("Requests containing pseudo-headers after regular headers must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<"content-length">>, <<"0">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_userinfo(Config) ->
|
|
|
+ doc("An authority containing a userinfo component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"user@localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+%% To ensure that the HTTP/1.1 request line can be reproduced accurately, this
|
|
|
+%% pseudo-header field (:authority) MUST be omitted when translating from an
|
|
|
+%% HTTP/1.1 request that has a request target in a method-specific form;
|
|
|
+%% see Section 7.1 of [HTTP].
|
|
|
+
|
|
|
+reject_empty_path(Config) ->
|
|
|
+ doc("A request containing an empty path component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<>>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_missing_pseudo_header_method(Config) ->
|
|
|
+ doc("A request without a method component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_many_pseudo_header_method(Config) ->
|
|
|
+ doc("A request containing more than one method component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_missing_pseudo_header_scheme(Config) ->
|
|
|
+ doc("A request without a scheme component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_many_pseudo_header_scheme(Config) ->
|
|
|
+ doc("A request containing more than one scheme component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_missing_pseudo_header_authority(Config) ->
|
|
|
+ doc("A request without an authority or host component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+%% @todo
|
|
|
+%accept_host_header_on_missing_pseudo_header_authority(Config) ->
|
|
|
+% doc("A request without an authority but with a host header must be accepted. "
|
|
|
+% "(RFC7540 8.1.2.3, RFC7540 8.1.3)"),
|
|
|
+% {ok, Socket} = do_handshake(Config),
|
|
|
+% %% Send a HEADERS frame with host header and without an :authority pseudo-header.
|
|
|
+% {HeadersBlock, _} = cow_hpack:encode([
|
|
|
+% {<<":method">>, <<"GET">>},
|
|
|
+% {<<":scheme">>, <<"http">>},
|
|
|
+% {<<":path">>, <<"/">>},
|
|
|
+% {<<"host">>, <<"localhost">>}
|
|
|
+% ]),
|
|
|
+% ok = gen_tcp:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
|
|
|
+% %% Receive a 200 response.
|
|
|
+% {ok, << Len:24, 1:8, _:8, _:32 >>} = gen_tcp:recv(Socket, 9, 6000),
|
|
|
+% {ok, RespHeadersBlock} = gen_tcp:recv(Socket, Len, 6000),
|
|
|
+% {RespHeaders, _} = cow_hpack:decode(RespHeadersBlock),
|
|
|
+% {_, <<"200">>} = lists:keyfind(<<":status">>, 1, RespHeaders),
|
|
|
+% ok.
|
|
|
+
|
|
|
+%% @todo
|
|
|
+%% If the :scheme pseudo-header field identifies a scheme that has a mandatory
|
|
|
+%% authority component (including "http" and "https"), the request MUST contain
|
|
|
+%% either an :authority pseudo-header field or a Host header field.
|
|
|
+%% - If both fields are present, they MUST NOT be empty.
|
|
|
+%% - If both fields are present, they MUST contain the same value.
|
|
|
+
|
|
|
+reject_many_pseudo_header_authority(Config) ->
|
|
|
+ doc("A request containing more than one authority component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_missing_pseudo_header_path(Config) ->
|
|
|
+ doc("A request without a path component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+reject_many_pseudo_header_path(Config) ->
|
|
|
+ doc("A request containing more than one path component must be rejected "
|
|
|
+ "with an H3_MESSAGE_ERROR stream error. (RFC9114 4.3.1, RFC9114 4.1.2)"),
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"http">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ {<<":path">>, <<"/">>}
|
|
|
+ ]).
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+do_reject_malformed_header(Config, Header) ->
|
|
|
+ do_reject_malformed_headers(Config, [
|
|
|
+ {<<":method">>, <<"GET">>},
|
|
|
+ {<<":scheme">>, <<"https">>},
|
|
|
+ {<<":authority">>, <<"localhost">>},
|
|
|
+ {<<":path">>, <<"/">>},
|
|
|
+ Header
|
|
|
+ ]).
|
|
|
+
|
|
|
+do_reject_malformed_headers(Config, Headers) ->
|
|
|
+ #{conn := Conn} = do_connect(Config),
|
|
|
+ {ok, StreamRef} = quicer:start_stream(Conn, #{}),
|
|
|
+ {ok, EncodedHeaders, _EncData1, _EncSt0}
|
|
|
+ = cow_qpack:encode_field_section(Headers, 0, cow_qpack:init()),
|
|
|
+ {ok, _} = quicer:send(StreamRef, [
|
|
|
+ <<1>>, %% HEADERS frame.
|
|
|
+ cow_http3:encode_int(iolist_size(EncodedHeaders)),
|
|
|
+ EncodedHeaders
|
|
|
+ ]),
|
|
|
+ %% The stream should have been aborted.
|
|
|
+ #{reason := h3_message_error} = do_wait_stream_aborted(StreamRef),
|
|
|
+ ok.
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+%% Helper functions.
|
|
|
+
|
|
|
+do_connect(Config) ->
|
|
|
+ {ok, Conn} = quicer:connect("localhost", config(port, Config),
|
|
|
+ #{alpn => ["h3"], verify => none}, 5000),
|
|
|
+ %% To make sure the connection is fully established we wait
|
|
|
+ %% to receive the SETTINGS frame on the control stream.
|
|
|
+ {ok, ControlRef, _Settings} = do_wait_settings(Conn),
|
|
|
+ #{
|
|
|
+ conn => Conn,
|
|
|
+ control => ControlRef
|
|
|
+ }.
|
|
|
+
|
|
|
+do_wait_settings(Conn) ->
|
|
|
+ {ok, Conn} = quicer:async_accept_stream(Conn, []),
|
|
|
+ receive
|
|
|
+ {quic, new_stream, StreamRef, #{flags := Flags}} ->
|
|
|
+ true = quicer:is_unidirectional(Flags),
|
|
|
+ receive {quic, <<
|
|
|
+ 0, %% Control stream.
|
|
|
+ 4, 0 %% Empty SETTINGS frame.
|
|
|
+ >>, StreamRef, _} ->
|
|
|
+ {ok, StreamRef, #{}}
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_receive_data(StreamRef) ->
|
|
|
+ receive
|
|
|
+ {quic, Data, StreamRef, _Flags} when is_binary(Data) ->
|
|
|
+ {ok, Data}
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_guess_int_encoding(Data) ->
|
|
|
+ SizeWithLen = byte_size(Data) - 1,
|
|
|
+ if
|
|
|
+ SizeWithLen < 64 + 1 ->
|
|
|
+ {0, 6};
|
|
|
+ SizeWithLen < 16384 + 2 ->
|
|
|
+ {1, 14};
|
|
|
+ SizeWithLen < 1073741824 + 4 ->
|
|
|
+ {2, 30};
|
|
|
+ SizeWithLen < 4611686018427387904 + 8 ->
|
|
|
+ {3, 62}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_async_stream_shutdown(StreamRef) ->
|
|
|
+ quicer:async_shutdown_stream(StreamRef, ?QUIC_STREAM_SHUTDOWN_FLAG_GRACEFUL, 0),
|
|
|
+ receive
|
|
|
+ {quic, send_shutdown_complete, StreamRef, true} ->
|
|
|
+ ok
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_wait_peer_send_shutdown(StreamRef) ->
|
|
|
+ receive
|
|
|
+ {quic, peer_send_shutdown, StreamRef, undefined} ->
|
|
|
+ ok
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_wait_stream_aborted(StreamRef) ->
|
|
|
+ receive
|
|
|
+ {quic, peer_send_aborted, StreamRef, Code} ->
|
|
|
+ Reason = cow_http3:code_to_error(Code),
|
|
|
+ #{reason => Reason};
|
|
|
+ {quic, peer_receive_aborted, StreamRef, Code} ->
|
|
|
+ Reason = cow_http3:code_to_error(Code),
|
|
|
+ #{reason => Reason}
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_wait_stream_closed(StreamRef) ->
|
|
|
+ receive
|
|
|
+ {quic, stream_closed, StreamRef, #{error := Error, is_conn_shutdown := false}} ->
|
|
|
+ 0 = Error,
|
|
|
+ ok
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+do_receive_response(StreamRef) ->
|
|
|
+ {ok, Data} = do_receive_data(StreamRef),
|
|
|
+ {HLenEnc, HLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 1, %% HEADERS frame.
|
|
|
+ HLenEnc:2, HLen:HLenBits,
|
|
|
+ EncodedResponse:HLen/bytes,
|
|
|
+ Rest/bits
|
|
|
+ >> = Data,
|
|
|
+ {ok, DecodedResponse, _DecData, _DecSt}
|
|
|
+ = cow_qpack:decode_field_section(EncodedResponse, 0, cow_qpack:init()),
|
|
|
+ Headers = maps:from_list(DecodedResponse),
|
|
|
+ #{<<"content-length">> := BodyLen} = Headers,
|
|
|
+ {DLenEnc, DLenBits} = do_guess_int_encoding(Data),
|
|
|
+ <<
|
|
|
+ 0, %% DATA frame.
|
|
|
+ DLenEnc:2, DLen:DLenBits,
|
|
|
+ Body:DLen/bytes
|
|
|
+ >> = Rest,
|
|
|
+ BodyLen = integer_to_binary(byte_size(Body)),
|
|
|
+ ok = do_wait_peer_send_shutdown(StreamRef),
|
|
|
+ ok = do_wait_stream_closed(StreamRef),
|
|
|
+ #{
|
|
|
+ headers => Headers,
|
|
|
+ body => Body
|
|
|
+ }.
|
|
|
+
|
|
|
+do_wait_connection_closed(Conn) ->
|
|
|
+ receive
|
|
|
+ {quic, shutdown, Conn, {unknown_quic_status, Code}} ->
|
|
|
+ Reason = cow_http3:code_to_error(Code),
|
|
|
+ #{reason => Reason}
|
|
|
+ after 5000 ->
|
|
|
+ {error, timeout}
|
|
|
+ end.
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+%% 4.3.2. Response Pseudo-Header Fields
|
|
|
+%% For responses, a single ":status" pseudo-header field is defined that
|
|
|
+%carries the HTTP status code; see Section 15 of [HTTP]. This pseudo-header
|
|
|
+%field MUST be included in all responses; otherwise, the response is malformed
|
|
|
+%(see Section 4.1.2).
|
|
|
+%% HTTP/3 does not define a way to carry the version or reason phrase that is
|
|
|
+%included in an HTTP/1.1 status line. HTTP/3 responses implicitly have a
|
|
|
+%protocol version of "3.0".
|
|
|
+
|
|
|
+%% 4.4. The CONNECT Method
|
|
|
+%% A CONNECT request MUST be constructed as follows:
|
|
|
+%%The :method pseudo-header field is set to "CONNECT"
|
|
|
+%%The :scheme and :path pseudo-header fields are omitted
|
|
|
+%%The :authority pseudo-header field contains the host and port to connect to
|
|
|
+%(equivalent to the authority-form of the request-target of CONNECT requests;
|
|
|
+%see Section 7.1 of [HTTP]).
|
|
|
+%% The request stream remains open at the end of the request to carry the data
|
|
|
+%to be transferred. A CONNECT request that does not conform to these
|
|
|
+%restrictions is malformed.
|
|
|
+%%
|
|
|
+%% Once the CONNECT method has completed, only DATA frames are permitted to be
|
|
|
+%sent on the stream. Extension frames MAY be used if specifically permitted by
|
|
|
+%the definition of the extension. Receipt of any other known frame type MUST be
|
|
|
+%treated as a connection error of type H3_FRAME_UNEXPECTED.%% @todo + review
|
|
|
+%how it should work beyond the handling of the CONNECT request
|
|
|
+
|
|
|
+%% 4.5. HTTP Upgrade
|
|
|
+%% HTTP/3 does not support the HTTP Upgrade mechanism (Section 7.8 of [HTTP])
|
|
|
+%or the 101 (Switching Protocols) informational status code (Section 15.2.2 of
|
|
|
+%[HTTP]).
|
|
|
+
|
|
|
+%% 4.6. Server Push
|
|
|
+%% The push ID space begins at zero and ends at a maximum value set by the
|
|
|
+%MAX_PUSH_ID frame. In particular, a server is not able to push until after the
|
|
|
+%client sends a MAX_PUSH_ID frame. A client sends MAX_PUSH_ID frames to control
|
|
|
+%the number of pushes that a server can promise. A server SHOULD use push IDs
|
|
|
+%sequentially, beginning from zero. A client MUST treat receipt of a push
|
|
|
+%stream as a connection error of type H3_ID_ERROR when no MAX_PUSH_ID frame has
|
|
|
+%been sent or when the stream references a push ID that is greater than the
|
|
|
+%maximum push ID.
|
|
|
+%% When the same push ID is promised on multiple request streams, the
|
|
|
+%decompressed request field sections MUST contain the same fields in the same
|
|
|
+%order, and both the name and the value in each field MUST be identical.
|
|
|
+%% Not all requests can be pushed. A server MAY push requests that have the following properties:
|
|
|
+%cacheable; see Section 9.2.3 of [HTTP]
|
|
|
+%safe; see Section 9.2.1 of [HTTP]
|
|
|
+%does not include request content or a trailer section
|
|
|
+%
|
|
|
+%% The server MUST include a value in the :authority pseudo-header field for
|
|
|
+%which the server is authoritative. If the client has not yet validated the
|
|
|
+%connection for the origin indicated by the pushed request, it MUST perform the
|
|
|
+%same verification process it would do before sending a request for that origin
|
|
|
+%on the connection; see Section 3.3. If this verification fails, the client
|
|
|
+%MUST NOT consider the server authoritative for that origin.
|
|
|
+%% Clients SHOULD send a CANCEL_PUSH frame upon receipt of a PUSH_PROMISE frame
|
|
|
+%carrying a request that is not cacheable, is not known to be safe, that
|
|
|
+%indicates the presence of request content, or for which it does not consider
|
|
|
+%the server authoritative. Any corresponding responses MUST NOT be used or
|
|
|
+%cached.
|
|
|
+%% Ordering of a PUSH_PROMISE frame in relation to certain parts of the
|
|
|
+%response is important. The server SHOULD send PUSH_PROMISE frames prior to
|
|
|
+%sending HEADERS or DATA frames that reference the promised responses. This
|
|
|
+%reduces the chance that a client requests a resource that will be pushed by
|
|
|
+%the server.
|
|
|
+%% Push stream data can also arrive after a client has cancelled a push. In
|
|
|
+%this case, the client can abort reading the stream with an error code of
|
|
|
+%H3_REQUEST_CANCELLED. This asks the server not to transfer additional data and
|
|
|
+%indicates that it will be discarded upon receipt.
|
|
|
+
|
|
|
+%% 5. Connection Closure
|
|
|
+%% 5.1. Idle Connections
|
|
|
+%% HTTP/3 implementations will need to open a new HTTP/3 connection for new
|
|
|
+%requests if the existing connection has been idle for longer than the idle
|
|
|
+%timeout negotiated during the QUIC handshake, and they SHOULD do so if
|
|
|
+%approaching the idle timeout; see Section 10.1 of [QUIC-TRANSPORT].
|
|
|
+%% Servers SHOULD NOT actively keep connections open.
|
|
|
+
|
|
|
+%% 5.2. Connection Shutdown
|
|
|
+%% Endpoints initiate the graceful shutdown of an HTTP/3 connection by sending
|
|
|
+%a GOAWAY frame. The GOAWAY frame contains an identifier that indicates to the
|
|
|
+%receiver the range of requests or pushes that were or might be processed in
|
|
|
+%this connection. The server sends a client-initiated bidirectional stream ID;
|
|
|
+%the client sends a push ID. Requests or pushes with the indicated identifier
|
|
|
+%or greater are rejected (Section 4.1.1) by the sender of the GOAWAY. This
|
|
|
+%identifier MAY be zero if no requests or pushes were processed.
|
|
|
+%% Upon sending a GOAWAY frame, the endpoint SHOULD explicitly cancel (see
|
|
|
+%Sections 4.1.1 and 7.2.3) any requests or pushes that have identifiers greater
|
|
|
+%than or equal to the one indicated, in order to clean up transport state for
|
|
|
+%the affected streams. The endpoint SHOULD continue to do so as more requests
|
|
|
+%or pushes arrive.
|
|
|
+%% Endpoints MUST NOT initiate new requests or promise new pushes on the
|
|
|
+%connection after receipt of a GOAWAY frame from the peer.
|
|
|
+%% Requests on stream IDs less than the stream ID in a GOAWAY frame from the
|
|
|
+%server might have been processed; their status cannot be known until a
|
|
|
+%response is received, the stream is reset individually, another GOAWAY is
|
|
|
+%received with a lower stream ID than that of the request in question, or the
|
|
|
+%connection terminates.
|
|
|
+%% Servers MAY reject individual requests on streams below the indicated ID if
|
|
|
+%these requests were not processed.
|
|
|
+%% If a server receives a GOAWAY frame after having promised pushes with a push
|
|
|
+%ID greater than or equal to the identifier contained in the GOAWAY frame,
|
|
|
+%those pushes will not be accepted.
|
|
|
+%% Servers SHOULD send a GOAWAY frame when the closing of a connection is known
|
|
|
+%in advance, even if the advance notice is small, so that the remote peer can
|
|
|
+%know whether or not a request has been partially processed.
|
|
|
+%% An endpoint MAY send multiple GOAWAY frames indicating different
|
|
|
+%identifiers, but the identifier in each frame MUST NOT be greater than the
|
|
|
+%identifier in any previous frame, since clients might already have retried
|
|
|
+%unprocessed requests on another HTTP connection. Receiving a GOAWAY containing
|
|
|
+%a larger identifier than previously received MUST be treated as a connection
|
|
|
+%error of type H3_ID_ERROR.
|
|
|
+%% An endpoint that is attempting to gracefully shut down a connection can send
|
|
|
+%a GOAWAY frame with a value set to the maximum possible value (262-4 for
|
|
|
+%servers, 262-1 for clients).
|
|
|
+%% Even when a GOAWAY indicates that a given request or push will not be
|
|
|
+%processed or accepted upon receipt, the underlying transport resources still
|
|
|
+%exist. The endpoint that initiated these requests can cancel them to clean up
|
|
|
+%transport state.
|
|
|
+%% Once all accepted requests and pushes have been processed, the endpoint can
|
|
|
+%permit the connection to become idle, or it MAY initiate an immediate closure
|
|
|
+%of the connection. An endpoint that completes a graceful shutdown SHOULD use
|
|
|
+%the H3_NO_ERROR error code when closing the connection.
|
|
|
+%% If a client has consumed all available bidirectional stream IDs with
|
|
|
+%requests, the server need not send a GOAWAY frame, since the client is unable
|
|
|
+%to make further requests. @todo OK that one's some weird stuff lol
|
|
|
+
|
|
|
+%% 5.3. Immediate Application Closure
|
|
|
+%% Before closing the connection, a GOAWAY frame MAY be sent to allow the
|
|
|
+%client to retry some requests. Including the GOAWAY frame in the same packet
|
|
|
+%as the QUIC CONNECTION_CLOSE frame improves the chances of the frame being
|
|
|
+%received by clients.
|
|
|
+
|
|
|
+%% 6. Stream Mapping and Usage
|
|
|
+%% 6.1. Bidirectional Streams
|
|
|
+%% an HTTP/3 server SHOULD configure non-zero minimum values for the number of
|
|
|
+%permitted streams and the initial stream flow-control window. So as to not
|
|
|
+%unnecessarily limit parallelism, at least 100 request streams SHOULD be
|
|
|
+%permitted at a time.
|
|
|
+
|
|
|
+%% 6.2. Unidirectional Streams
|
|
|
+%% Therefore, the transport parameters sent by both clients and servers MUST
|
|
|
+%allow the peer to create at least three unidirectional streams. These
|
|
|
+%transport parameters SHOULD also provide at least 1,024 bytes of flow-control
|
|
|
+%credit to each unidirectional stream.
|
|
|
+%% Note that an endpoint is not required to grant additional credits to create
|
|
|
+%more unidirectional streams if its peer consumes all the initial credits
|
|
|
+%before creating the critical unidirectional streams. Endpoints SHOULD create
|
|
|
+%the HTTP control stream as well as the unidirectional streams required by
|
|
|
+%mandatory extensions (such as the QPACK encoder and decoder streams) first,
|
|
|
+%and then create additional streams as allowed by their peer.
|
|
|
+%% Recipients of unknown stream types MUST either abort reading of the stream
|
|
|
+%or discard incoming data without further processing. If reading is aborted,
|
|
|
+%the recipient SHOULD use the H3_STREAM_CREATION_ERROR error code or a reserved
|
|
|
+%error code (Section 8.1). The recipient MUST NOT consider unknown stream types
|
|
|
+%to be a connection error of any kind.
|
|
|
+%% As certain stream types can affect connection state, a recipient SHOULD NOT
|
|
|
+%discard data from incoming unidirectional streams prior to reading the stream
|
|
|
+%type.
|
|
|
+%% Implementations MAY send stream types before knowing whether the peer
|
|
|
+%supports them. However, stream types that could modify the state or semantics
|
|
|
+%of existing protocol components, including QPACK or other extensions, MUST NOT
|
|
|
+%be sent until the peer is known to support them.
|
|
|
+%% A receiver MUST tolerate unidirectional streams being closed or reset prior
|
|
|
+%to the reception of the unidirectional stream header.
|
|
|
+
|
|
|
+%% 6.2.1. Control Streams
|
|
|
+%% A control stream is indicated by a stream type of 0x00. Data on this stream
|
|
|
+%consists of HTTP/3 frames, as defined in Section 7.2.
|
|
|
+%% Each side MUST initiate a single control stream at the beginning of the
|
|
|
+%connection and send its SETTINGS frame as the first frame on this stream. If
|
|
|
+%the first frame of the control stream is any other frame type, this MUST be
|
|
|
+%treated as a connection error of type H3_MISSING_SETTINGS. Only one control
|
|
|
+%stream per peer is permitted; receipt of a second stream claiming to be a
|
|
|
+%control stream MUST be treated as a connection error of type
|
|
|
+%H3_STREAM_CREATION_ERROR. The sender MUST NOT close the control stream, and
|
|
|
+%the receiver MUST NOT request that the sender close the control stream. If
|
|
|
+%either control stream is closed at any point, this MUST be treated as a
|
|
|
+%connection error of type H3_CLOSED_CRITICAL_STREAM. Connection errors are
|
|
|
+%described in Section 8.
|
|
|
+%% Because the contents of the control stream are used to manage the behavior
|
|
|
+%of other streams, endpoints SHOULD provide enough flow-control credit to keep
|
|
|
+%the peer's control stream from becoming blocked.
|
|
|
+
|
|
|
+%% 6.2.2. Push Streams
|
|
|
+%% A push stream is indicated by a stream type of 0x01, followed by the push ID
|
|
|
+%of the promise that it fulfills, encoded as a variable-length integer. The
|
|
|
+%remaining data on this stream consists of HTTP/3 frames, as defined in Section
|
|
|
+%7.2, and fulfills a promised server push by zero or more interim HTTP
|
|
|
+%responses followed by a single final HTTP response, as defined in Section 4.1.
|
|
|
+%Server push and push IDs are described in Section 4.6.
|
|
|
+%% Only servers can push; if a server receives a client-initiated push stream,
|
|
|
+%this MUST be treated as a connection error of type H3_STREAM_CREATION_ERROR.
|
|
|
+%% Each push ID MUST only be used once in a push stream header. If a client
|
|
|
+%detects that a push stream header includes a push ID that was used in another
|
|
|
+%push stream header, the client MUST treat this as a connection error of type
|
|
|
+%H3_ID_ERROR.
|
|
|
+
|
|
|
+%% 6.2.3. Reserved Stream Types
|
|
|
+%% Stream types of the format 0x1f * N + 0x21 for non-negative integer values
|
|
|
+%of N are reserved to exercise the requirement that unknown types be ignored.
|
|
|
+%These streams have no semantics, and they can be sent when application-layer
|
|
|
+%padding is desired. They MAY also be sent on connections where no data is
|
|
|
+%currently being transferred. Endpoints MUST NOT consider these streams to have
|
|
|
+%any meaning upon receipt.
|
|
|
+%% The payload and length of the stream are selected in any manner the sending
|
|
|
+%implementation chooses. When sending a reserved stream type, the
|
|
|
+%implementation MAY either terminate the stream cleanly or reset it. When
|
|
|
+%resetting the stream, either the H3_NO_ERROR error code or a reserved error
|
|
|
+%code (Section 8.1) SHOULD be used.
|
|
|
+
|
|
|
+%% 7. HTTP Framing Layer
|
|
|
+%% Note that, unlike QUIC frames, HTTP/3 frames can span multiple packets.
|
|
|
+
|
|
|
+%% 7.1. Frame Layout
|
|
|
+%% Each frame's payload MUST contain exactly the fields identified in its
|
|
|
+%description. A frame payload that contains additional bytes after the
|
|
|
+%identified fields or a frame payload that terminates before the end of the
|
|
|
+%identified fields MUST be treated as a connection error of type
|
|
|
+%H3_FRAME_ERROR. In particular, redundant length encodings MUST be verified to
|
|
|
+%be self-consistent; see Section 10.8.
|
|
|
+%% When a stream terminates cleanly, if the last frame on the stream was
|
|
|
+%truncated, this MUST be treated as a connection error of type H3_FRAME_ERROR.
|
|
|
+%Streams that terminate abruptly may be reset at any point in a frame.
|
|
|
+
|
|
|
+%% 7.2. Frame Definitions
|
|
|
+%% 7.2.1. DATA
|
|
|
+%% DATA frames MUST be associated with an HTTP request or response. If a DATA
|
|
|
+%frame is received on a control stream, the recipient MUST respond with a
|
|
|
+%connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+
|
|
|
+%% 7.2.2. HEADERS
|
|
|
+%% HEADERS frames can only be sent on request streams or push streams. If a
|
|
|
+%HEADERS frame is received on a control stream, the recipient MUST respond with
|
|
|
+%a connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+
|
|
|
+%% 7.2.3. CANCEL_PUSH
|
|
|
+%% When a client sends a CANCEL_PUSH frame, it is indicating that it does not
|
|
|
+%wish to receive the promised resource. The server SHOULD abort sending the
|
|
|
+%resource, but the mechanism to do so depends on the state of the corresponding
|
|
|
+%push stream. If the server has not yet created a push stream, it does not
|
|
|
+%create one. If the push stream is open, the server SHOULD abruptly terminate
|
|
|
+%that stream. If the push stream has already ended, the server MAY still
|
|
|
+%abruptly terminate the stream or MAY take no action.
|
|
|
+%% A server sends a CANCEL_PUSH frame to indicate that it will not be
|
|
|
+%fulfilling a promise that was previously sent. The client cannot expect the
|
|
|
+%corresponding promise to be fulfilled, unless it has already received and
|
|
|
+%processed the promised response. Regardless of whether a push stream has been
|
|
|
+%opened, a server SHOULD send a CANCEL_PUSH frame when it determines that
|
|
|
+%promise will not be fulfilled. If a stream has already been opened, the server
|
|
|
+%can abort sending on the stream with an error code of H3_REQUEST_CANCELLED.
|
|
|
+%% Sending a CANCEL_PUSH frame has no direct effect on the state of existing
|
|
|
+%push streams. A client SHOULD NOT send a CANCEL_PUSH frame when it has already
|
|
|
+%received a corresponding push stream. A push stream could arrive after a
|
|
|
+%client has sent a CANCEL_PUSH frame, because a server might not have processed
|
|
|
+%the CANCEL_PUSH. The client SHOULD abort reading the stream with an error code
|
|
|
+%of H3_REQUEST_CANCELLED.
|
|
|
+%% A CANCEL_PUSH frame is sent on the control stream. Receiving a CANCEL_PUSH
|
|
|
+%frame on a stream other than the control stream MUST be treated as a
|
|
|
+%connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+%% If a CANCEL_PUSH frame is received that references a push ID greater than
|
|
|
+%currently allowed on the connection, this MUST be treated as a connection
|
|
|
+%error of type H3_ID_ERROR.
|
|
|
+%% If the client receives a CANCEL_PUSH frame, that frame might identify a push
|
|
|
+%ID that has not yet been mentioned by a PUSH_PROMISE frame due to reordering.
|
|
|
+%If a server receives a CANCEL_PUSH frame for a push ID that has not yet been
|
|
|
+%mentioned by a PUSH_PROMISE frame, this MUST be treated as a connection error
|
|
|
+%of type H3_ID_ERROR.
|
|
|
+
|
|
|
+%% 7.2.4. SETTINGS
|
|
|
+%% A SETTINGS frame MUST be sent as the first frame of each control stream (see
|
|
|
+%Section 6.2.1) by each peer, and it MUST NOT be sent subsequently. If an
|
|
|
+%endpoint receives a second SETTINGS frame on the control stream, the endpoint
|
|
|
+%MUST respond with a connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+%% SETTINGS frames MUST NOT be sent on any stream other than the control
|
|
|
+%stream. If an endpoint receives a SETTINGS frame on a different stream, the
|
|
|
+%endpoint MUST respond with a connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+%% The same setting identifier MUST NOT occur more than once in the SETTINGS
|
|
|
+%frame. A receiver MAY treat the presence of duplicate setting identifiers as a
|
|
|
+%connection error of type H3_SETTINGS_ERROR.
|
|
|
+%% An implementation MUST ignore any parameter with an identifier it does not understand.
|
|
|
+
|
|
|
+%% 7.2.4.1. Defined SETTINGS Parameters
|
|
|
+%% Setting identifiers of the format 0x1f * N + 0x21 for non-negative integer
|
|
|
+%values of N are reserved to exercise the requirement that unknown identifiers
|
|
|
+%be ignored. Such settings have no defined meaning. Endpoints SHOULD include at
|
|
|
+%least one such setting in their SETTINGS frame. Endpoints MUST NOT consider
|
|
|
+%such settings to have any meaning upon receipt.
|
|
|
+%% -> try sending COW\0 BOY\0 if that fits the encoding and restrictions
|
|
|
+%otherwise something similar
|
|
|
+%% Setting identifiers that were defined in [HTTP/2] where there is no
|
|
|
+%corresponding HTTP/3 setting have also been reserved (Section 11.2.2). These
|
|
|
+%reserved settings MUST NOT be sent, and their receipt MUST be treated as a
|
|
|
+%connection error of type H3_SETTINGS_ERROR.
|
|
|
+
|
|
|
+%% 7.2.4.2. Initialization
|
|
|
+%% An HTTP implementation MUST NOT send frames or requests that would be
|
|
|
+%invalid based on its current understanding of the peer's settings.
|
|
|
+%% All settings begin at an initial value. Each endpoint SHOULD use these
|
|
|
+%initial values to send messages before the peer's SETTINGS frame has arrived,
|
|
|
+%as packets carrying the settings can be lost or delayed. When the SETTINGS
|
|
|
+%frame arrives, any settings are changed to their new values.
|
|
|
+%% Endpoints MUST NOT require any data to be received from the peer prior to
|
|
|
+%sending the SETTINGS frame; settings MUST be sent as soon as the transport is
|
|
|
+%ready to send data.
|
|
|
+%% A server MAY accept 0-RTT and subsequently provide different settings in its
|
|
|
+%SETTINGS frame. If 0-RTT data is accepted by the server, its SETTINGS frame
|
|
|
+%MUST NOT reduce any limits or alter any values that might be violated by the
|
|
|
+%client with its 0-RTT data. The server MUST include all settings that differ
|
|
|
+%from their default values. If a server accepts 0-RTT but then sends settings
|
|
|
+%that are not compatible with the previously specified settings, this MUST be
|
|
|
+%treated as a connection error of type H3_SETTINGS_ERROR. If a server accepts
|
|
|
+%0-RTT but then sends a SETTINGS frame that omits a setting value that the
|
|
|
+%client understands (apart from reserved setting identifiers) that was
|
|
|
+%previously specified to have a non-default value, this MUST be treated as a
|
|
|
+%connection error of type H3_SETTINGS_ERROR.
|
|
|
+
|
|
|
+%% 7.2.5. PUSH_PROMISE
|
|
|
+%% A server MUST NOT use a push ID that is larger than the client has provided
|
|
|
+%in a MAX_PUSH_ID frame (Section 7.2.7).
|
|
|
+%% A server MAY use the same push ID in multiple PUSH_PROMISE frames. If so,
|
|
|
+%the decompressed request header sets MUST contain the same fields in the same
|
|
|
+%order, and both the name and the value in each field MUST be exact matches.
|
|
|
+%% Allowing duplicate references to the same push ID is primarily to reduce
|
|
|
+%duplication caused by concurrent requests. A server SHOULD avoid reusing a
|
|
|
+%push ID over a long period. Clients are likely to consume server push
|
|
|
+%responses and not retain them for reuse over time. Clients that see a
|
|
|
+%PUSH_PROMISE frame that uses a push ID that they have already consumed and
|
|
|
+%discarded are forced to ignore the promise.
|
|
|
+%% A client MUST NOT send a PUSH_PROMISE frame. A server MUST treat the receipt
|
|
|
+%of a PUSH_PROMISE frame as a connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+
|
|
|
+%% 7.2.6. GOAWAY
|
|
|
+%% (not sure what applies to the server, should the server reject GOAWAY on
|
|
|
+%non-control stream too?)
|
|
|
+
|
|
|
+%% 7.2.7. MAX_PUSH_ID
|
|
|
+%% Receipt of a MAX_PUSH_ID frame on any other stream MUST be treated as a
|
|
|
+%connection error of type H3_FRAME_UNEXPECTED.
|
|
|
+%% The maximum push ID is unset when an HTTP/3 connection is created, meaning
|
|
|
+%that a server cannot push until it receives a MAX_PUSH_ID frame.
|
|
|
+%% A MAX_PUSH_ID frame cannot reduce the maximum push ID; receipt of a
|
|
|
+%MAX_PUSH_ID frame that contains a smaller value than previously received MUST
|
|
|
+%be treated as a connection error of type H3_ID_ERROR.
|
|
|
+
|
|
|
+%% 7.2.8. Reserved Frame Types
|
|
|
+%% These frames have no semantics, and they MAY be sent on any stream where
|
|
|
+%frames are allowed to be sent. This enables their use for application-layer
|
|
|
+%padding. Endpoints MUST NOT consider these frames to have any meaning upon
|
|
|
+%receipt.
|
|
|
+%% Frame types that were used in HTTP/2 where there is no corresponding HTTP/3
|
|
|
+%frame have also been reserved (Section 11.2.1). These frame types MUST NOT be
|
|
|
+%sent, and their receipt MUST be treated as a connection error of type
|
|
|
+%H3_FRAME_UNEXPECTED.
|
|
|
+
|
|
|
+%% 8. Error Handling
|
|
|
+%% An endpoint MAY choose to treat a stream error as a connection error under
|
|
|
+%certain circumstances, closing the entire connection in response to a
|
|
|
+%condition on a single stream.
|
|
|
+%% Because new error codes can be defined without negotiation (see Section 9),
|
|
|
+%use of an error code in an unexpected context or receipt of an unknown error
|
|
|
+%code MUST be treated as equivalent to H3_NO_ERROR.
|
|
|
+
|
|
|
+%% 8.1. HTTP/3 Error Codes
|
|
|
+%% H3_INTERNAL_ERROR (0x0102): An internal error has occurred in the HTTP stack.
|
|
|
+%% H3_FRAME_ERROR (0x0106): A frame that fails to satisfy layout requirements
|
|
|
+%or with an invalid size was received.
|
|
|
+%% H3_EXCESSIVE_LOAD (0x0107): The endpoint detected that its peer is
|
|
|
+%exhibiting a behavior that might be generating excessive load.
|
|
|
+%% (more)
|
|
|
+%% Error codes of the format 0x1f * N + 0x21 for non-negative integer values of
|
|
|
+%N are reserved to exercise the requirement that unknown error codes be treated
|
|
|
+%as equivalent to H3_NO_ERROR (Section 9). Implementations SHOULD select an
|
|
|
+%error code from this space with some probability when they would have sent
|
|
|
+%H3_NO_ERROR.
|
|
|
+
|
|
|
+%% 9. Extensions to HTTP/3
|
|
|
+%% Extensions are permitted to use new frame types (Section 7.2), new settings
|
|
|
+%(Section 7.2.4.1), new error codes (Section 8), or new unidirectional stream
|
|
|
+%types (Section 6.2). Registries are established for managing these extension
|
|
|
+%points: frame types (Section 11.2.1), settings (Section 11.2.2), error codes
|
|
|
+%(Section 11.2.3), and stream types (Section 11.2.4).
|
|
|
+%% Implementations MUST ignore unknown or unsupported values in all extensible
|
|
|
+%protocol elements. Implementations MUST discard data or abort reading on
|
|
|
+%unidirectional streams that have unknown or unsupported types. This means that
|
|
|
+%any of these extension points can be safely used by extensions without prior
|
|
|
+%arrangement or negotiation. However, where a known frame type is required to
|
|
|
+%be in a specific location, such as the SETTINGS frame as the first frame of
|
|
|
+%the control stream (see Section 6.2.1), an unknown frame type does not satisfy
|
|
|
+%that requirement and SHOULD be treated as an error.
|
|
|
+%% If a setting is used for extension negotiation, the default value MUST be
|
|
|
+%defined in such a fashion that the extension is disabled if the setting is
|
|
|
+%omitted.
|
|
|
+
|
|
|
+%% 10. Security Considerations
|
|
|
+%% 10.3. Intermediary-Encapsulation Attacks
|
|
|
+%% Requests or responses containing invalid field names MUST be treated as malformed.
|
|
|
+%% Any request or response that contains a character not permitted in a field
|
|
|
+%value MUST be treated as malformed.
|
|
|
+
|
|
|
+%% 10.5. Denial-of-Service Considerations
|
|
|
+%% Implementations SHOULD track the use of these features and set limits on
|
|
|
+%their use. An endpoint MAY treat activity that is suspicious as a connection
|
|
|
+%error of type H3_EXCESSIVE_LOAD, but false positives will result in disrupting
|
|
|
+%valid connections and requests.
|
|
|
+
|
|
|
+%% 10.5.1. Limits on Field Section Size
|
|
|
+%% An endpoint can use the SETTINGS_MAX_FIELD_SECTION_SIZE (Section 4.2.2)
|
|
|
+%setting to advise peers of limits that might apply on the size of field
|
|
|
+%sections.
|
|
|
+%% A server that receives a larger field section than it is willing to handle
|
|
|
+%can send an HTTP 431 (Request Header Fields Too Large) status code
|
|
|
+%([RFC6585]).
|
|
|
+
|
|
|
+%% 10.6. Use of Compression
|
|
|
+%% Implementations communicating on a secure channel MUST NOT compress content
|
|
|
+%that includes both confidential and attacker-controlled data unless separate
|
|
|
+%compression contexts are used for each source of data. Compression MUST NOT be
|
|
|
+%used if the source of data cannot be reliably determined.
|
|
|
+
|
|
|
+%% 10.8. Frame Parsing
|
|
|
+%% An implementation MUST ensure that the length of a frame exactly matches the
|
|
|
+%length of the fields it contains.
|
|
|
+
|
|
|
+%% 10.9. Early Data
|
|
|
+%% The anti-replay mitigations in [HTTP-REPLAY] MUST be applied when using HTTP/3 with 0-RTT.
|
|
|
+
|
|
|
+%% 10.10. Migration
|
|
|
+%% Certain HTTP implementations use the client address for logging or
|
|
|
+%access-control purposes. Since a QUIC client's address might change during a
|
|
|
+%connection (and future versions might support simultaneous use of multiple
|
|
|
+%addresses), such implementations will need to either actively retrieve the
|
|
|
+%client's current address or addresses when they are relevant or explicitly
|
|
|
+%accept that the original address might change. -> documentation for now
|
|
|
+
|
|
|
+%% 11.2.1. Frame Types
|
|
|
+%% Reserved types: 0x02 0x06 0x08 0x09
|
|
|
+
|
|
|
+%% 11.2.2. Settings Parameters
|
|
|
+%% Reserved settings: 0x00 0x02 0x03 0x04 0x05
|
|
|
+
|
|
|
+%% Appendix A. Considerations for Transitioning from HTTP/2
|
|
|
+%% A.1. Streams
|
|
|
+%% QUIC considers a stream closed when all data has been received and sent data
|
|
|
+%has been acknowledged by the peer. HTTP/2 considers a stream closed when the
|
|
|
+%frame containing the END_STREAM bit has been committed to the transport. As a
|
|
|
+%result, the stream for an equivalent exchange could remain "active" for a
|
|
|
+%longer period of time. HTTP/3 servers might choose to permit a larger number
|
|
|
+%of concurrent client-initiated bidirectional streams to achieve equivalent
|
|
|
+%concurrency to HTTP/2, depending on the expected usage patterns. ->
|
|
|
+%documentation?
|
|
|
+
|
|
|
+%% A.3. HTTP/2 SETTINGS Parameters
|
|
|
+%% SETTINGS_MAX_FRAME_SIZE (0x05): This setting has no equivalent in HTTP/3.
|
|
|
+%Specifying a setting with the identifier 0x05 (corresponding to the
|
|
|
+%SETTINGS_MAX_FRAME_SIZE parameter) in the HTTP/3 SETTINGS frame is an error.
|
|
|
+%-> do we still want a limit, if so how?
|
Loïc Hoguin