hanyu-dev
diff --git a/‎CHANGELOG.md
+2-18 b/‎CHANGELOG.md
+2-18
diff --git a/‎README.md
+11-9 b/‎README.md
+11-9
diff --git a/‎src/client.rs
+22-9 b/‎src/client.rs
+22-9
diff --git a/‎src/codec/framed_write.rs
+7-1 b/‎src/codec/framed_write.rs
+7-1
diff --git a/‎src/frame/headers.rs
+53-26 b/‎src/frame/headers.rs
+53-26
diff --git a/‎src/frame/mod.rs
+2-1 b/‎src/frame/mod.rs
+2-1
@@ -14,25 +14,9 @@
 
 * Limit number of CONTINUATION frames for misbehaving connections.
 
-# 0.4.3 (March 15, 2024)
+# 0.3.25 (March 15, 2024)
 
-* Fix flow control limits to not apply until receiving SETTINGS ack.
-* Fix not returning an error if IO ended without `close_notify`.
-* Improve performance of decoding many headers.
-
-# 0.4.2 (January 17th, 2024)
-
-* Limit error resets for misbehaving connections.
-* Fix selecting MAX_CONCURRENT_STREAMS value if no value is advertised initially.
-
-# 0.4.1 (January 8, 2024)
-
-* Fix assigning connection capacity which could starve streams in some instances.
-
-# 0.4.0 (November 15, 2023)
-
-* Update to `http` 1.0.
-* Remove deprecated `Server::poll_close()`.
+* Improve performance decoding many headers.
 
 # 0.3.24 (January 17, 2024)
 
 
@@ -1,16 +1,14 @@
 # H2
 
-This project is forked from [h2](https://github.com/hyperium/h2)
-
 A Tokio aware, HTTP/2 client & server implementation for Rust.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![Crates.io](https://img.shields.io/crates/v/h2.svg)](https://crates.io/crates/h2)
-[![Documentation](https://docs.rs/h2/badge.svg)][dox]
+[![Crates.io](https://img.shields.io/crates/v/rh2.svg)](https://crates.io/crates/rh2)
+[![Documentation](https://docs.rs/rh2/badge.svg)][dox]
 
 More information about this crate can be found in the [crate documentation][dox].
 
-[dox]: https://docs.rs/h2
+[dox]: https://docs.rs/rh2
 
 ## Features
 
@@ -34,19 +32,19 @@ This crate is now used by [hyper](https://github.com/hyperium/hyper), which will
 
 ## Usage
 
-To use `h2`, first add this to your `Cargo.toml`:
+To use `rh2`, first add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-h2 = "0.4"
+rh2 = "0.4"
 ```
 
 Next, add this to your crate:
 
 ```rust
-extern crate h2;
+extern crate rh2;
 
-use h2::server::Connection;
+use rh2::server::Connection;
 
 fn main() {
     // ...
@@ -71,3 +69,7 @@ actively maintained.
 [solicit]: https://github.com/mlalic/solicit
 [rust-http2]: https://github.com/stepancheg/rust-http2
 [h2spec]: https://github.com/summerwind/h2spec
+
+## Accolades
+
+The project is based on a fork of [h2](https://github.com/hyperium/h2).
@@ -138,7 +138,8 @@
 use crate::codec::{Codec, SendError, UserError};
 use crate::ext::Protocol;
 use crate::frame::{
-    Headers, Pseudo, PseudoOrder, Reason, Settings, SettingsOrder, StreamDependency, StreamId,
+    Headers, Pseudo, PseudoOrder, PseudoOrders, Reason, Settings, SettingsOrder, StreamDependency,
+    StreamId
 };
 use crate::proto::{self, Error};
 use crate::{FlowControl, PingPong, RecvStream, SendStream};
@@ -347,7 +348,7 @@ pub struct Builder {
     local_max_error_reset_streams: Option<usize>,
 
     /// The headers frame pseudo order
-    headers_pseudo_order: Option<[PseudoOrder; 4]>,
+    headers_pseudo_order: Option<PseudoOrders>,
 
     /// The headers frame priority
     headers_priority: Option<StreamDependency>,
@@ -677,20 +678,20 @@ impl Builder {
     }
 
     /// Set http2 header pseudo order
-    pub fn headers_psuedo(&mut self, headers_psuedo: Option<[PseudoOrder; 4]>) -> &mut Self {
-        self.headers_pseudo_order = headers_psuedo;
+    pub fn headers_psuedo(&mut self, order: [PseudoOrder; 4]) -> &mut Self {
+        self.headers_pseudo_order = Some(order.into());
         self
     }
 
     /// Set http2 header priority
-    pub fn headers_priority(&mut self, headers_priority: Option<StreamDependency>) -> &mut Self {
-        self.headers_priority = headers_priority;
+    pub fn headers_priority(&mut self, headers_priority: StreamDependency) -> &mut Self {
+        self.headers_priority = Some(headers_priority);
         self
     }
 
     /// Settings frame order
-    pub fn settings_order(&mut self, order: Option<[SettingsOrder; 2]>) -> &mut Self {
-        self.settings.set_settings_order(order);
+    pub fn settings_order(&mut self, order: [SettingsOrder; 8]) -> &mut Self {
+        self.settings.set_settings_order(Some(order));
         self
     }
 
@@ -1173,6 +1174,18 @@ impl Builder {
         self
     }
 
+    /// unknown_setting8
+    pub fn unknown_setting8(&mut self, enabled: bool) -> &mut Self {
+        self.settings.set_unknown_setting_8(enabled);
+        self
+    }
+
+    /// unknown_setting8
+    pub fn unknown_setting9(&mut self, enabled: bool) -> &mut Self {
+        self.settings.set_unknown_setting_9(enabled);
+        self
+    }
+
     /// Sets the first stream ID to something other than 1.
     #[cfg(feature = "unstable")]
     pub fn initial_stream_id(&mut self, stream_id: u32) -> &mut Self {
@@ -1614,7 +1627,7 @@ impl Peer {
         request: Request<()>,
         protocol: Option<Protocol>,
         end_of_stream: bool,
-        pseudo_order: Option<[PseudoOrder; 4]>,
+        pseudo_order: Option<PseudoOrders>,
         headers_priority: Option<StreamDependency>,
     ) -> Result<Headers, SendError> {
         use http::request::Parts;
 
@@ -133,7 +133,7 @@ where
 
         loop {
             while !self.encoder.is_empty() {
-                match self.encoder.next {
+                let n = match self.encoder.next {
                     Some(Next::Data(ref mut frame)) => {
                         tracing::trace!(queued_data_frame = true);
                         let mut buf = (&mut self.encoder.buf).chain(frame.payload_mut());
@@ -148,6 +148,12 @@ where
                         ))?
                     }
                 };
+                if n == 0 {
+                    return Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::WriteZero,
+                        "failed to write frame to socket",
+                    )));
+                }
             }
 
             match self.encoder.unset_frame() {
 
@@ -74,7 +74,7 @@ pub struct Pseudo {
     pub status: Option<StatusCode>,
 
     // order of pseudo headers
-    pub order: Option<[PseudoOrder; 4]>,
+    pub order: PseudoOrders,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -85,6 +85,26 @@ pub enum PseudoOrder {
     Path,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct PseudoOrders([PseudoOrder; 4]);
+
+impl From<[PseudoOrder; 4]> for PseudoOrders {
+    fn from(src: [PseudoOrder; 4]) -> Self {
+        PseudoOrders(src)
+    }
+}
+
+impl Default for PseudoOrders {
+    fn default() -> Self {
+        PseudoOrders([
+            PseudoOrder::Method,
+            PseudoOrder::Scheme,
+            PseudoOrder::Authority,
+            PseudoOrder::Path,
+        ])
+    }
+}
+
 #[derive(Debug)]
 pub struct Iter {
     /// Pseudo headers
@@ -131,6 +151,13 @@ impl Headers {
         fields: HeaderMap,
         stream_dep: Option<StreamDependency>,
     ) -> Self {
+        // If the stream dependency is set, the PRIORITY flag must be set
+        let flags = if stream_dep.is_some() {
+            HeadersFlag(END_HEADERS | PRIORITY)
+        } else {
+            HeadersFlag::default()
+        };
+
         Headers {
             stream_id,
             stream_dep,
@@ -140,7 +167,7 @@ impl Headers {
                 is_over_size: false,
                 pseudo,
             },
-            flags: HeadersFlag::default(),
+            flags,
         }
     }
 
@@ -580,7 +607,7 @@ impl Pseudo {
         method: Method,
         uri: Uri,
         protocol: Option<Protocol>,
-        pseudo_order: Option<[PseudoOrder; 4]>,
+        order: Option<PseudoOrders>,
     ) -> Self {
         let parts = uri::Parts::from(uri);
 
@@ -610,7 +637,7 @@ impl Pseudo {
             path,
             protocol,
             status: None,
-            order: pseudo_order,
+            order: order.unwrap_or_default(),
         };
 
         // If the URI includes a scheme component, add it to the pseudo headers
@@ -635,7 +662,7 @@ impl Pseudo {
             path: None,
             protocol: None,
             status: Some(status),
-            order: None,
+            order: Default::default(),
         }
     }
 
@@ -730,28 +757,26 @@ impl Iterator for Iter {
         use crate::hpack::Header::*;
 
         if let Some(ref mut pseudo) = self.pseudo {
-            if let Some(orders) = pseudo.order.as_ref() {
-                for pseudo_type in orders {
-                    match pseudo_type {
-                        PseudoOrder::Method => {
-                            if let Some(method) = pseudo.method.take() {
-                                return Some(Method(method));
-                            }
+            for pseudo_type in pseudo.order.0.iter() {
+                match pseudo_type {
+                    PseudoOrder::Method => {
+                        if let Some(method) = pseudo.method.take() {
+                            return Some(Method(method));
                         }
-                        PseudoOrder::Scheme => {
-                            if let Some(scheme) = pseudo.scheme.take() {
-                                return Some(Scheme(scheme));
-                            }
+                    }
+                    PseudoOrder::Scheme => {
+                        if let Some(scheme) = pseudo.scheme.take() {
+                            return Some(Scheme(scheme));
                         }
-                        PseudoOrder::Authority => {
-                            if let Some(authority) = pseudo.authority.take() {
-                                return Some(Authority(authority));
-                            }
+                    }
+                    PseudoOrder::Authority => {
+                        if let Some(authority) = pseudo.authority.take() {
+                            return Some(Authority(authority));
                         }
-                        PseudoOrder::Path => {
-                            if let Some(path) = pseudo.path.take() {
-                                return Some(Path(path));
-                            }
+                    }
+                    PseudoOrder::Path => {
+                        if let Some(path) = pseudo.path.take() {
+                            return Some(Path(path));
                         }
                     }
                 }
@@ -827,9 +852,9 @@ impl HeadersFlag {
 }
 
 impl Default for HeadersFlag {
-    /// Returns a `HeadersFlag` value with `END_HEADERS` and `PRIORITY` set.
+    /// Returns a `HeadersFlag` value with `END_HEADERS` set.
     fn default() -> Self {
-        HeadersFlag(END_HEADERS | PRIORITY)
+        HeadersFlag(END_HEADERS)
     }
 }
 
@@ -1048,6 +1073,8 @@ fn decoded_header_size(name: usize, value: usize) -> usize {
 
 #[cfg(test)]
 mod test {
+    use std::iter::FromIterator;
+
     use super::*;
     use crate::frame;
     use crate::hpack::{huffman, Encoder};
 
@@ -53,7 +53,8 @@ pub use self::go_away::GoAway;
 pub use self::head::{Head, Kind};
 pub(crate) use self::headers::PseudoOrder;
 pub use self::headers::{
-    parse_u64, Continuation, Headers, Pseudo, PushPromise, PushPromiseHeaderError,
+    parse_u64, Continuation, Headers, Pseudo, PseudoOrder, PseudoOrders, PushPromise,
+    PushPromiseHeaderError,
 };
 pub use self::ping::Ping;
 pub use self::priority::{Priority, StreamDependency};