From: Markus Koschany <apo@debian.org>
Date: Sun, 1 Jan 2023 19:16:23 +0100
Subject: CVE-2022-41915

Bug-Debian: https://bugs.debian.org/1027180
Origin: https://github.com/netty/netty/commit/fe18adff1c2b333acb135ab779a3b9ba3295a1c4
---
 .../handler/codec/http/DefaultHttpHeadersTest.java |  25 +-
 .../io/netty/handler/codec/DefaultHeaders.java     | 368 +++++++++++++++++----
 2 files changed, 323 insertions(+), 70 deletions(-)

diff --git a/codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpHeadersTest.java b/codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpHeadersTest.java
index d0f6c41..44984a7 100644
--- a/codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpHeadersTest.java
+++ b/codec-http/src/test/java/io/netty/handler/codec/http/DefaultHttpHeadersTest.java
@@ -20,7 +20,7 @@ import io.netty.util.AsciiString;
 import io.netty.util.internal.StringUtil;
 import org.junit.Test;
 
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
@@ -33,6 +33,7 @@ import static org.junit.Assert.*;
 
 public class DefaultHttpHeadersTest {
     private static final CharSequence HEADER_NAME = "testHeader";
+    private static final CharSequence ILLEGAL_VALUE = "testHeader\r\nContent-Length:45\r\n\r\n";
 
     @Test(expected = IllegalArgumentException.class)
     public void nullHeaderNameNotAllowed() {
@@ -206,6 +207,28 @@ public class DefaultHttpHeadersTest {
         assertDefaultValues(headers, HeaderValue.THREE);
     }
 
+    @Test
+    public void setCharSequenceValidatesValue() {
+        final DefaultHttpHeaders headers = newDefaultDefaultHttpHeaders();
+        assertThrows(IllegalArgumentException.class, new Executable() {
+            @Override
+            public void execute() throws Throwable {
+                headers.set(HEADER_NAME, ILLEGAL_VALUE);
+            }
+        });
+    }
+
+    @Test
+    public void setIterableValidatesValue() {
+        final DefaultHttpHeaders headers = newDefaultDefaultHttpHeaders();
+        assertThrows(IllegalArgumentException.class, new Executable() {
+            @Override
+            public void execute() throws Throwable {
+                headers.set(HEADER_NAME, Collections.singleton(ILLEGAL_VALUE));
+            }
+        });
+    }
+
     @Test
     public void toStringOnEmptyHeaders() {
         assertEquals("DefaultHttpHeaders[]", newDefaultDefaultHttpHeaders().toString());
diff --git a/codec/src/main/java/io/netty/handler/codec/DefaultHeaders.java b/codec/src/main/java/io/netty/handler/codec/DefaultHeaders.java
index 4109037..6abe71b 100644
--- a/codec/src/main/java/io/netty/handler/codec/DefaultHeaders.java
+++ b/codec/src/main/java/io/netty/handler/codec/DefaultHeaders.java
@@ -5,7 +5,7 @@
  * "License"); you may not use this file except in compliance with the License. You may obtain a
  * copy of the License at:
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ -52,6 +52,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     private final byte hashMask;
     private final ValueConverter<V> valueConverter;
     private final NameValidator<K> nameValidator;
+    private final ValueValidator<V> valueValidator;
     private final HashingStrategy<K> hashingStrategy;
     int size;
 
@@ -72,6 +73,22 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         };
     }
 
+    public interface ValueValidator<V> {
+        /**
+         * Validate the given value. If the validation fails, then an implementation specific runtime exception may be
+         * thrown.
+         *
+         * @param value The value to validate.
+         */
+        void validate(V value);
+
+        ValueValidator<?> NO_VALIDATION = new ValueValidator<Object>() {
+            @Override
+            public void validate(Object value) {
+            }
+        };
+    }
+
     @SuppressWarnings("unchecked")
     public DefaultHeaders(ValueConverter<V> valueConverter) {
         this(JAVA_HASHER, valueConverter);
@@ -102,13 +119,30 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
      */
     @SuppressWarnings("unchecked")
     public DefaultHeaders(HashingStrategy<K> nameHashingStrategy,
-            ValueConverter<V> valueConverter, NameValidator<K> nameValidator, int arraySizeHint) {
+                          ValueConverter<V> valueConverter, NameValidator<K> nameValidator, int arraySizeHint) {
+        this(nameHashingStrategy, valueConverter, nameValidator, arraySizeHint,
+                (ValueValidator<V>) ValueValidator.NO_VALIDATION);
+    }
+
+    /**
+     * Create a new instance.
+     * @param nameHashingStrategy Used to hash and equality compare names.
+     * @param valueConverter Used to convert values to/from native types.
+     * @param nameValidator Used to validate name elements.
+     * @param arraySizeHint A hint as to how large the hash data structure should be.
+     * The next positive power of two will be used. An upper bound may be enforced.
+     * @param valueValidator The validation strategy for entry values.
+     */
+    @SuppressWarnings("unchecked")
+    public DefaultHeaders(HashingStrategy<K> nameHashingStrategy, ValueConverter<V> valueConverter,
+                          NameValidator<K> nameValidator, int arraySizeHint, ValueValidator<V> valueValidator) {
         this.valueConverter = checkNotNull(valueConverter, "valueConverter");
         this.nameValidator = checkNotNull(nameValidator, "nameValidator");
-        this.hashingStrategy = checkNotNull(nameHashingStrategy, "nameHashingStrategy");
+        hashingStrategy = checkNotNull(nameHashingStrategy, "nameHashingStrategy");
+        this.valueValidator = checkNotNull(valueValidator, "valueValidator");
         // Enforce a bound of [2, 128] because hashMask is a byte. The max possible value of hashMask is one less
         // than the length of this array, and we want the mask to be > 0.
-        entries = new DefaultHeaders.HeaderEntry[findNextPositivePowerOfTwo(max(2, min(arraySizeHint, 128)))];
+        entries = new HeaderEntry[findNextPositivePowerOfTwo(max(2, min(arraySizeHint, 128)))];
         hashMask = (byte) (entries.length - 1);
         head = new HeaderEntry<K, V>();
     }
@@ -197,52 +231,52 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public boolean containsObject(K name, Object value) {
-        return contains(name, valueConverter.convertObject(checkNotNull(value, "value")));
+        return contains(name, fromObject(name, value));
     }
 
     @Override
     public boolean containsBoolean(K name, boolean value) {
-        return contains(name, valueConverter.convertBoolean(value));
+        return contains(name, fromBoolean(name, value));
     }
 
     @Override
     public boolean containsByte(K name, byte value) {
-        return contains(name, valueConverter.convertByte(value));
+        return contains(name, fromByte(name, value));
     }
 
     @Override
     public boolean containsChar(K name, char value) {
-        return contains(name, valueConverter.convertChar(value));
+        return contains(name, fromChar(name, value));
     }
 
     @Override
     public boolean containsShort(K name, short value) {
-        return contains(name, valueConverter.convertShort(value));
+        return contains(name, fromShort(name, value));
     }
 
     @Override
     public boolean containsInt(K name, int value) {
-        return contains(name, valueConverter.convertInt(value));
+        return contains(name, fromInt(name, value));
     }
 
     @Override
     public boolean containsLong(K name, long value) {
-        return contains(name, valueConverter.convertLong(value));
+        return contains(name, fromLong(name, value));
     }
 
     @Override
     public boolean containsFloat(K name, float value) {
-        return contains(name, valueConverter.convertFloat(value));
+        return contains(name, fromFloat(name, value));
     }
 
     @Override
     public boolean containsDouble(K name, double value) {
-        return contains(name, valueConverter.convertDouble(value));
+        return contains(name, fromDouble(name, value));
     }
 
     @Override
     public boolean containsTimeMillis(K name, long value) {
-        return contains(name, valueConverter.convertTimeMillis(value));
+        return contains(name, fromTimeMillis(name, value));
     }
 
     @SuppressWarnings("unchecked")
@@ -292,7 +326,8 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T add(K name, V value) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, true, name);
+        validateValue(valueValidator, name, value);
         checkNotNull(value, "value");
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
@@ -302,10 +337,11 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T add(K name, Iterable<? extends V> values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, true, name);
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
         for (V v: values) {
+            validateValue(valueValidator, name, v);
             add0(h, i, name, v);
         }
         return thisT();
@@ -313,10 +349,11 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T add(K name, V... values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, true, name);
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
         for (V v: values) {
+            validateValue(valueValidator, name, v);
             add0(h, i, name, v);
         }
         return thisT();
@@ -324,7 +361,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T addObject(K name, Object value) {
-        return add(name, valueConverter.convertObject(checkNotNull(value, "value")));
+        return add(name, fromObject(name, value));
     }
 
     @Override
@@ -345,47 +382,47 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T addInt(K name, int value) {
-        return add(name, valueConverter.convertInt(value));
+        return add(name, fromInt(name, value));
     }
 
     @Override
     public T addLong(K name, long value) {
-        return add(name, valueConverter.convertLong(value));
+        return add(name, fromLong(name, value));
     }
 
     @Override
     public T addDouble(K name, double value) {
-        return add(name, valueConverter.convertDouble(value));
+        return add(name, fromDouble(name, value));
     }
 
     @Override
     public T addTimeMillis(K name, long value) {
-        return add(name, valueConverter.convertTimeMillis(value));
+        return add(name, fromTimeMillis(name, value));
     }
 
     @Override
     public T addChar(K name, char value) {
-        return add(name, valueConverter.convertChar(value));
+        return add(name, fromChar(name, value));
     }
 
     @Override
     public T addBoolean(K name, boolean value) {
-        return add(name, valueConverter.convertBoolean(value));
+        return add(name, fromBoolean(name, value));
     }
 
     @Override
     public T addFloat(K name, float value) {
-        return add(name, valueConverter.convertFloat(value));
+        return add(name, fromFloat(name, value));
     }
 
     @Override
     public T addByte(K name, byte value) {
-        return add(name, valueConverter.convertByte(value));
+        return add(name, fromByte(name, value));
     }
 
     @Override
     public T addShort(K name, short value) {
-        return add(name, valueConverter.convertShort(value));
+        return add(name, fromShort(name, value));
     }
 
     @Override
@@ -427,7 +464,8 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T set(K name, V value) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, false, name);
+        validateValue(valueValidator, name, value);
         checkNotNull(value, "value");
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
@@ -438,7 +476,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T set(K name, Iterable<? extends V> values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, false, name);
         checkNotNull(values, "values");
 
         int h = hashingStrategy.hashCode(name);
@@ -449,6 +487,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
             if (v == null) {
                 break;
             }
+            validateValue(valueValidator, name, v);
             add0(h, i, name, v);
         }
 
@@ -457,7 +496,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T set(K name, V... values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, false, name);
         checkNotNull(values, "values");
 
         int h = hashingStrategy.hashCode(name);
@@ -468,6 +507,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
             if (v == null) {
                 break;
             }
+            validateValue(valueValidator, name, v);
             add0(h, i, name, v);
         }
 
@@ -476,14 +516,13 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T setObject(K name, Object value) {
-        checkNotNull(value, "value");
-        V convertedValue = checkNotNull(valueConverter.convertObject(value), "convertedValue");
+        V convertedValue = checkNotNull(fromObject(name, value), "convertedValue");
         return set(name, convertedValue);
     }
 
     @Override
     public T setObject(K name, Iterable<?> values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, false, name);
 
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
@@ -493,7 +532,9 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
             if (v == null) {
                 break;
             }
-            add0(h, i, name, valueConverter.convertObject(v));
+            V converted = fromObject(name, v);
+            validateValue(valueValidator, name, converted);
+            add0(h, i, name, converted);
         }
 
         return thisT();
@@ -501,7 +542,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T setObject(K name, Object... values) {
-        nameValidator.validateName(name);
+        validateName(nameValidator, false, name);
 
         int h = hashingStrategy.hashCode(name);
         int i = index(h);
@@ -511,7 +552,9 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
             if (v == null) {
                 break;
             }
-            add0(h, i, name, valueConverter.convertObject(v));
+            V converted = fromObject(name, v);
+            validateValue(valueValidator, name, converted);
+            add0(h, i, name, converted);
         }
 
         return thisT();
@@ -519,47 +562,47 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
 
     @Override
     public T setInt(K name, int value) {
-        return set(name, valueConverter.convertInt(value));
+        return set(name, fromInt(name, value));
     }
 
     @Override
     public T setLong(K name, long value) {
-        return set(name, valueConverter.convertLong(value));
+        return set(name, fromLong(name, value));
     }
 
     @Override
     public T setDouble(K name, double value) {
-        return set(name, valueConverter.convertDouble(value));
+        return set(name, fromDouble(name, value));
     }
 
     @Override
     public T setTimeMillis(K name, long value) {
-        return set(name, valueConverter.convertTimeMillis(value));
+        return set(name, fromTimeMillis(name, value));
     }
 
     @Override
     public T setFloat(K name, float value) {
-        return set(name, valueConverter.convertFloat(value));
+        return set(name, fromFloat(name, value));
     }
 
     @Override
     public T setChar(K name, char value) {
-        return set(name, valueConverter.convertChar(value));
+        return set(name, fromChar(name, value));
     }
 
     @Override
     public T setBoolean(K name, boolean value) {
-        return set(name, valueConverter.convertBoolean(value));
+        return set(name, fromBoolean(name, value));
     }
 
     @Override
     public T setByte(K name, byte value) {
-        return set(name, valueConverter.convertByte(value));
+        return set(name, fromByte(name, value));
     }
 
     @Override
     public T setShort(K name, short value) {
-        return set(name, valueConverter.convertShort(value));
+        return set(name, fromShort(name, value));
     }
 
     @Override
@@ -604,7 +647,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Boolean getBoolean(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToBoolean(v) : null;
+            return v != null ? toBoolean(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -620,7 +663,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Byte getByte(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToByte(v) : null;
+            return v != null ? toByte(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -636,7 +679,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Character getChar(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToChar(v) : null;
+            return v != null ? toChar(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -652,7 +695,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Short getShort(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToShort(v) : null;
+            return v != null ? toShort(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -668,7 +711,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Integer getInt(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToInt(v) : null;
+            return v != null ? toInt(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -684,7 +727,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Long getLong(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToLong(v) : null;
+            return v != null ? toLong(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -700,7 +743,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Float getFloat(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToFloat(v) : null;
+            return v != null ? toFloat(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -716,7 +759,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Double getDouble(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToDouble(v) : null;
+            return v != null ? toDouble(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -732,7 +775,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Long getTimeMillis(K name) {
         V v = get(name);
         try {
-            return v != null ? valueConverter.convertToTimeMillis(v) : null;
+            return v != null ? toTimeMillis(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -748,7 +791,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Boolean getBooleanAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToBoolean(v) : null;
+            return v != null ? toBoolean(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -764,7 +807,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Byte getByteAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToByte(v) : null;
+            return v != null ? toByte(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -780,7 +823,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Character getCharAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToChar(v) : null;
+            return v != null ? toChar(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -796,7 +839,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Short getShortAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToShort(v) : null;
+            return v != null ? toShort(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -812,7 +855,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Integer getIntAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToInt(v) : null;
+            return v != null ? toInt(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -828,7 +871,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Long getLongAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToLong(v) : null;
+            return v != null ? toLong(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -844,7 +887,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Float getFloatAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToFloat(v) : null;
+            return v != null ? toFloat(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -860,7 +903,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Double getDoubleAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToDouble(v) : null;
+            return v != null ? toDouble(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -876,7 +919,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
     public Long getTimeMillisAndRemove(K name) {
         V v = getAndRemove(name);
         try {
-            return v != null ? valueConverter.convertToTimeMillis(v) : null;
+            return v != null ? toTimeMillis(name, v) : null;
         } catch (RuntimeException ignore) {
             return null;
         }
@@ -957,6 +1000,22 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         return HeadersUtils.toString(getClass(), iterator(), size());
     }
 
+    /**
+     * Call out to the given {@link NameValidator} to validate the given name.
+     *
+     * @param validator the validator to use
+     * @param forAdd {@code true } if this validation is for adding to the headers, or {@code false} if this is for
+     * setting (overwriting) the given header.
+     * @param name the name to validate.
+     */
+    protected void validateName(NameValidator<K> validator, boolean forAdd, K name) {
+        validator.validateName(name);
+    }
+
+    protected void validateValue(ValueValidator<V> validator, K name, V value) {
+        validator.validate(value);
+    }
+
     protected HeaderEntry<K, V> newHeaderEntry(int h, K name, V value, HeaderEntry<K, V> next) {
         return new HeaderEntry<K, V>(h, name, value, next, head);
     }
@@ -965,6 +1024,14 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         return valueConverter;
     }
 
+    protected NameValidator<K> nameValidator() {
+        return nameValidator;
+    }
+
+    protected ValueValidator<V> valueValidator() {
+        return valueValidator;
+    }
+
     private int index(int hash) {
         return hash & hashMask;
     }
@@ -1012,12 +1079,22 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         return value;
     }
 
-    private HeaderEntry<K, V> remove0(HeaderEntry<K, V> entry, HeaderEntry<K, V> previous) {
+    HeaderEntry<K, V> remove0(HeaderEntry<K, V> entry, HeaderEntry<K, V> previous) {
         int i = index(entry.hash);
-        HeaderEntry<K, V> e = entries[i];
-        if (e == entry) {
+        HeaderEntry<K, V> firstEntry = entries[i];
+        if (firstEntry == entry) {
             entries[i] = entry.next;
             previous = entries[i];
+        } else if (previous == null) {
+            // If we don't have any existing starting point, then start from the beginning.
+            previous = firstEntry;
+            HeaderEntry<K, V> next = firstEntry.next;
+            while (next != null && next != entry) {
+                previous = next;
+                next = next.next;
+            }
+            assert next != null: "Entry not found in its hash bucket: " + entry;
+            previous.next = entry.next;
         } else {
             previous.next = entry.next;
         }
@@ -1031,6 +1108,159 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         return (T) this;
     }
 
+    private V fromObject(K name, Object value) {
+        try {
+            return valueConverter.convertObject(checkNotNull(value, "value"));
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert object value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromBoolean(K name, boolean value) {
+        try {
+            return valueConverter.convertBoolean(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert boolean value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromByte(K name, byte value) {
+        try {
+            return valueConverter.convertByte(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert byte value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromChar(K name, char value) {
+        try {
+            return valueConverter.convertChar(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert char value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromShort(K name, short value) {
+        try {
+            return valueConverter.convertShort(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert short value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromInt(K name, int value) {
+        try {
+            return valueConverter.convertInt(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert int value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromLong(K name, long value) {
+        try {
+            return valueConverter.convertLong(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert long value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromFloat(K name, float value) {
+        try {
+            return valueConverter.convertFloat(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert float value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromDouble(K name, double value) {
+        try {
+            return valueConverter.convertDouble(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert double value for header '" + name + '\'', e);
+        }
+    }
+
+    private V fromTimeMillis(K name, long value) {
+        try {
+            return valueConverter.convertTimeMillis(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert millsecond value for header '" + name + '\'', e);
+        }
+    }
+
+    private boolean toBoolean(K name, V value) {
+        try {
+            return valueConverter.convertToBoolean(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to boolean for header '" + name + '\'');
+        }
+    }
+
+    private byte toByte(K name, V value) {
+        try {
+            return valueConverter.convertToByte(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to byte for header '" + name + '\'');
+        }
+    }
+
+    private char toChar(K name, V value) {
+        try {
+            return valueConverter.convertToChar(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to char for header '" + name + '\'');
+        }
+    }
+
+    private short toShort(K name, V value) {
+        try {
+            return valueConverter.convertToShort(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to short for header '" + name + '\'');
+        }
+    }
+
+    private int toInt(K name, V value) {
+        try {
+            return valueConverter.convertToInt(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to int for header '" + name + '\'');
+        }
+    }
+
+    private long toLong(K name, V value) {
+        try {
+            return valueConverter.convertToLong(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to long for header '" + name + '\'');
+        }
+    }
+
+    private float toFloat(K name, V value) {
+        try {
+            return valueConverter.convertToFloat(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to float for header '" + name + '\'');
+        }
+    }
+
+    private double toDouble(K name, V value) {
+        try {
+            return valueConverter.convertToDouble(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to convert header value to double for header '" + name + '\'');
+        }
+    }
+
+    private long toTimeMillis(K name, V value) {
+        try {
+            return valueConverter.convertToTimeMillis(value);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException(
+                    "Failed to convert header value to millsecond for header '" + name + '\'');
+        }
+    }
+
     /**
      * Returns a deep copy of this instance.
      */
@@ -1041,7 +1271,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         return copy;
     }
 
-    private final class HeaderIterator implements Iterator<Map.Entry<K, V>> {
+    private final class HeaderIterator implements Iterator<Entry<K, V>> {
         private HeaderEntry<K, V> current = head;
 
         @Override
@@ -1118,7 +1348,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
         }
     }
 
-    protected static class HeaderEntry<K, V> implements Map.Entry<K, V> {
+    protected static class HeaderEntry<K, V> implements Entry<K, V> {
         protected final int hash;
         protected final K key;
         protected V value;
@@ -1199,7 +1429,7 @@ public class DefaultHeaders<K, V, T extends Headers<K, V, T>> implements Headers
             if (!(o instanceof Map.Entry)) {
                 return false;
             }
-            Map.Entry<?, ?> other = (Map.Entry<?, ?>) o;
+            Entry<?, ?> other = (Entry<?, ?>) o;
             return (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey()))  &&
                    (getValue() == null ? other.getValue() == null : getValue().equals(other.getValue()));
         }