8268960: com/sun/net/httpserver/Headers.java: Ensure mutators normalize keys and disallow null for keys and values

Reviewed-by: chegar, dfuchs, michaelm

Author: Julia Boes

src/jdk.httpserver/share/classes/com/sun/net/httpserver/Headers.java

@@ -30,7 +30,9 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
+import java.util.function.BiFunction;
 
 /**
  * HTTP request and response headers are represented by this class which
@@ -63,14 +65,8 @@
  *     value given overwriting any existing values in the value list.
  * </ul>
  *
- * <p> All methods in this class accept {@code null} values for keys and values.
- * However, {@code null} keys will never will be present in HTTP request
- * headers, and will not be output/sent in response headers. Null values can be
- * represented as either a {@code null} entry for the key (i.e. the list is
- * {@code null}) or where the key has a list, but one (or more) of the list's
- * values is {@code null}. Null values are output as a header line containing
- * the key but no associated value.
- *
+ * <p> All methods in this class reject {@code null} values for keys and values.
+ * {@code null} keys will never be present in HTTP request or response headers.
  * @since 1.6
  */
 public class Headers implements Map<String,List<String>> {
@@ -88,9 +84,7 @@ public class Headers implements Map<String,List<String>> {
      * key is presumed to be {@code ASCII}.
      */
     private String normalize(String key) {
-        if (key == null) {
-            return null;
-        }
+        Objects.requireNonNull(key);
         int len = key.length();
         if (len == 0) {
             return key;
@@ -110,54 +104,58 @@ private String normalize(String key) {
         return new String(b);
     }
 
+    @Override
     public int size() {return map.size();}
 
+    @Override
     public boolean isEmpty() {return map.isEmpty();}
 
+    @Override
     public boolean containsKey(Object key) {
-        if (key == null) {
-            return false;
-        }
-        if (!(key instanceof String)) {
-            return false;
-        }
-        return map.containsKey(normalize((String)key));
+        Objects.requireNonNull(key);
+        return key instanceof String k && map.containsKey(normalize(k));
     }
 
+    @Override
     public boolean containsValue(Object value) {
+        Objects.requireNonNull(value);
         return map.containsValue(value);
     }
 
+    @Override
     public List<String> get(Object key) {
         return map.get(normalize((String)key));
     }
 
     /**
-     * Returns the first value from the {@link List} of {@code String}
-     * values for the given key (if at least one exists).
+     * Returns the first value from the {@link List} of {@code String} values
+     * for the given {@code key}, or {@code null} if no mapping for the
+     * {@code key} exists.
      *
      * @param key the key to search for
-     * @return the first {@code String} value associated with the key
+     * @return    the first {@code String} value associated with the key,
+     *            or {@code null} if no mapping for the key exists
      */
     public String getFirst(String key) {
         List<String> l = map.get(normalize(key));
-        if (l == null) {
+        if (l == null || l.size() == 0) {  // no mapping exists
             return null;
         }
         return l.get(0);
     }
 
+    @Override
     public List<String> put(String key, List<String> value) {
         for (String v : value)
             checkValue(v);
         return map.put(normalize(key), value);
     }
 
     /**
-     * Adds the given value to the list of headers for the given key. If
-     * the mapping does not already exist, then it is created.
+     * Adds the given {@code value} to the list of headers for the given
+     * {@code key}. If the mapping does not already exist, then it is created.
      *
-     * @param key the header name
+     * @param key   the header name
      * @param value the value to add to the header
      */
     public void add(String key, String value) {
@@ -196,10 +194,10 @@ private static void checkValue(String value) {
     }
 
     /**
-     * Sets the given value as the sole header value for the given
-     * key. If the mapping does not already exist, then it is created.
+     * Sets the given {@code value} as the sole header value for the given
+     * {@code key}. If the mapping does not already exist, then it is created.
      *
-     * @param key the header name
+     * @param key   the header name
      * @param value the header value to set
      */
     public void set(String key, String value) {
@@ -208,25 +206,52 @@ public void set(String key, String value) {
         put(key, l);
     }
 
+    @Override
     public List<String> remove(Object key) {
         return map.remove(normalize((String)key));
     }
 
+    @Override
     public void putAll(Map<? extends String,? extends List<String>> t)  {
-        map.putAll(t);
+        t.forEach(this::put);
     }
 
+    @Override
     public void clear() {map.clear();}
 
+    @Override
     public Set<String> keySet() {return map.keySet();}
 
+    @Override
     public Collection<List<String>> values() {return map.values();}
 
+    @Override
     public Set<Map.Entry<String, List<String>>> entrySet() {
         return map.entrySet();
     }
 
-    public boolean equals(Object o) {return map.equals(o);}
+    @Override
+    public void replaceAll(BiFunction<? super String, ? super List<String>, ? extends List<String>> function) {
+        var f = function.andThen(values -> {
+            Objects.requireNonNull(values);
+            values.forEach(Headers::checkValue);
+            return values;
+        });
+        Map.super.replaceAll(f);
+    }
+
+    @Override
+    public boolean equals(Object o) { return map.equals(o); }
 
+    @Override
     public int hashCode() {return map.hashCode();}
+
+    @Override
+    public String toString() {
+        final var sb = new StringBuilder(Headers.class.getSimpleName());
+        sb.append(" { ");
+        sb.append(map.toString());
+        sb.append(" }");
+        return sb.toString();
+    }
 }