From 4e6d8350945533c535e361f0b4948c44f32dd490 Mon Sep 17 00:00:00 2001
From: 4JX <79868816+4JX@users.noreply.github.com>
Date: Tue, 16 Aug 2022 16:34:15 +0200
Subject: [PATCH] Add a setter for header_table_size

---
 src/client.rs            | 33 +++++++++++++++++++++++++++++++++
 src/codec/framed_read.rs |  6 ++++++
 src/codec/mod.rs         |  5 +++++
 src/frame/settings.rs    |  4 +---
 src/proto/settings.rs    |  4 ++++
 5 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/src/client.rs b/src/client.rs
index a6c6498..bf33cbf 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1022,6 +1022,39 @@ impl Builder {
         self
     }
 
+    /// Sets the header table size.
+    ///
+    /// This setting informs the peer of the maximum size of the header compression
+    /// table used to encode header blocks, in octets. The encoder may select any value
+    /// equal to or less than the header table size specified by the sender.
+    ///
+    /// The default value is 4,096.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use tokio::io::{AsyncRead, AsyncWrite};
+    /// # use h2::client::*;
+    /// # use bytes::Bytes;
+    /// #
+    /// # async fn doc<T: AsyncRead + AsyncWrite + Unpin>(my_io: T)
+    /// # -> Result<((SendRequest<Bytes>, Connection<T, Bytes>)), h2::Error>
+    /// # {
+    /// // `client_fut` is a future representing the completion of the HTTP/2
+    /// // handshake.
+    /// let client_fut = Builder::new()
+    ///     .header_table_size(1_000_000)
+    ///     .handshake(my_io);
+    /// # client_fut.await
+    /// # }
+    /// #
+    /// # pub fn main() {}
+    /// ```
+    pub fn header_table_size(&mut self, size: u32) -> &mut Self {
+        self.settings.set_header_table_size(Some(size));
+        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 {
diff --git a/src/codec/framed_read.rs b/src/codec/framed_read.rs
index 7c3bbb3..0416c8e 100644
--- a/src/codec/framed_read.rs
+++ b/src/codec/framed_read.rs
@@ -88,6 +88,12 @@ impl<T> FramedRead<T> {
     pub fn set_max_header_list_size(&mut self, val: usize) {
         self.max_header_list_size = val;
     }
+
+    /// Update the header table size setting.
+    #[inline]
+    pub fn set_header_table_size(&mut self, val: usize) {
+        self.hpack.queue_size_update(val);
+    }
 }
 
 /// Decodes a frame.
diff --git a/src/codec/mod.rs b/src/codec/mod.rs
index 359adf6..6cbdc1e 100644
--- a/src/codec/mod.rs
+++ b/src/codec/mod.rs
@@ -95,6 +95,11 @@ impl<T, B> Codec<T, B> {
         self.framed_write().set_header_table_size(val)
     }
 
+    /// Set the decoder header table size size.
+    pub fn set_recv_header_table_size(&mut self, val: usize) {
+        self.inner.set_header_table_size(val)
+    }
+
     /// Set the max header list size that can be received.
     pub fn set_max_recv_header_list_size(&mut self, val: usize) {
         self.inner.set_max_header_list_size(val);
diff --git a/src/frame/settings.rs b/src/frame/settings.rs
index 080d0f4..8168c65 100644
--- a/src/frame/settings.rs
+++ b/src/frame/settings.rs
@@ -120,12 +120,10 @@ impl Settings {
     pub fn header_table_size(&self) -> Option<u32> {
         self.header_table_size
     }
-
-    /*
+    
     pub fn set_header_table_size(&mut self, size: Option<u32>) {
         self.header_table_size = size;
     }
-    */
 
     pub fn load(head: Head, payload: &[u8]) -> Result<Settings, Error> {
         use self::Setting::*;
diff --git a/src/proto/settings.rs b/src/proto/settings.rs
index 6cc6172..28065cc 100644
--- a/src/proto/settings.rs
+++ b/src/proto/settings.rs
@@ -60,6 +60,10 @@ impl Settings {
                         codec.set_max_recv_header_list_size(max as usize);
                     }
 
+                    if let Some(val) = local.header_table_size() {
+                        codec.set_recv_header_table_size(val as usize);
+                    }
+
                     streams.apply_local_settings(local)?;
                     self.local = Local::Synced;
                     Ok(())