8263506: Make sun.net.httpserver.UnmodifiableHeaders unmodifiable

Reviewed-by: michaelm, dfuchs

src/jdk.httpserver/share/classes/sun/net/httpserver/ExchangeImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -85,7 +85,7 @@ class ExchangeImpl {
         String m, URI u, Request req, long len, HttpConnection connection
     ) throws IOException {
         this.req = req;
-        this.reqHdrs = req.headers();
+        this.reqHdrs = new UnmodifiableHeaders(req.headers());
         this.rspHdrs = new Headers();
         this.method = m;
         this.uri = u;
@@ -99,7 +99,7 @@ class ExchangeImpl {
     }
 
     public Headers getRequestHeaders () {
-        return new UnmodifiableHeaders (reqHdrs);
+        return reqHdrs;
     }
 
     public Headers getResponseHeaders () {

src/jdk.httpserver/share/classes/sun/net/httpserver/UnmodifiableHeaders.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,76 +26,79 @@
 package sun.net.httpserver;
 
 import java.util.*;
+import java.util.function.BiFunction;
 import com.sun.net.httpserver.*;
 
-class UnmodifiableHeaders extends Headers {
+public class UnmodifiableHeaders extends Headers {
 
-        Headers map;
+    private final Headers headers;  // modifiable, but no reference to it escapes
+    private final Map<String, List<String>> map;  // unmodifiable
 
-        UnmodifiableHeaders(Headers map) {
-            this.map = map;
-        }
-
-        public int size() {return map.size();}
-
-        public boolean isEmpty() {return map.isEmpty();}
-
-        public boolean containsKey(Object key) {
-            return map.containsKey (key);
-        }
-
-        public boolean containsValue(Object value) {
-            return map.containsValue(value);
-        }
-
-        public List<String> get(Object key) {
-            return map.get(key);
-        }
-
-        public String getFirst (String key) {
-            return map.getFirst(key);
-        }
-
-
-        public List<String> put(String key, List<String> value) {
-            return map.put (key, value);
-        }
-
-        public void add (String key, String value) {
-            throw new UnsupportedOperationException ("unsupported operation");
-        }
-
-        public void set (String key, String value) {
-            throw new UnsupportedOperationException ("unsupported operation");
-        }
-
-        public List<String> remove(Object key) {
-            throw new UnsupportedOperationException ("unsupported operation");
-        }
-
-        public void putAll(Map<? extends String,? extends List<String>> t)  {
-            throw new UnsupportedOperationException ("unsupported operation");
-        }
-
-        public void clear() {
-            throw new UnsupportedOperationException ("unsupported operation");
-        }
-
-        public Set<String> keySet() {
-            return Collections.unmodifiableSet (map.keySet());
-        }
-
-        public Collection<List<String>> values() {
-            return Collections.unmodifiableCollection(map.values());
-        }
-
-        /* TODO check that contents of set are not modifable : security */
-
-        public Set<Map.Entry<String, List<String>>> entrySet() {
-            return Collections.unmodifiableSet (map.entrySet());
-        }
-
-        public boolean equals(Object o) {return map.equals(o);}
-
-        public int hashCode() {return map.hashCode();}
+    public UnmodifiableHeaders(Headers headers) {
+        var h = headers;
+        var unmodHeaders = new Headers();
+        h.forEach((k, v) -> unmodHeaders.put(k, Collections.unmodifiableList(v)));
+        this.map = Collections.unmodifiableMap(unmodHeaders);
+        this.headers = unmodHeaders;
     }
+
+    public int size() {return headers.size();}
+
+    public boolean isEmpty() {return headers.isEmpty();}
+
+    public boolean containsKey(Object key) { return headers.containsKey(key); }
+
+    public boolean containsValue(Object value) { return headers.containsValue(value); }
+
+    public List<String> get(Object key) { return headers.get(key); }
+
+    public String getFirst(String key) { return headers.getFirst(key); }
+
+    public List<String> put(String key, List<String> value) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public void add(String key, String value) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public void set(String key, String value) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public List<String> remove(Object key) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public void putAll(Map<? extends String,? extends List<String>> t)  {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public void clear() {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public Set<String> keySet() { return map.keySet(); }
+
+    public Collection<List<String>> values() { return map.values(); }
+
+    /* TODO check that contents of set are not modifable : security */
+
+    public Set<Map.Entry<String, List<String>>> entrySet() { return map.entrySet(); }
+
+    public List<String> replace(String key, List<String> value) {
+        throw new UnsupportedOperationException("unsupported operation");
+    }
+
+    public boolean replace(String key, List<String> oldValue, List<String> newValue) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public void replaceAll(BiFunction<? super String, ? super List<String>, ? extends List<String>> function) {
+        throw new UnsupportedOperationException ("unsupported operation");
+    }
+
+    public boolean equals(Object o) {return headers.equals(o);}
+
+    public int hashCode() {return headers.hashCode();}
+}

test/jdk/com/sun/net/httpserver/UnmodifiableHeadersTest.java

@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8251496
+ * @summary Test that UnmodifiableHeaders is in fact immutable
+ * @modules jdk.httpserver/sun.net.httpserver:+open
+ * @run testng/othervm UnmodifiableHeadersTest
+ */
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.AbstractMap;
+import java.util.List;
+import java.util.Map;
+import com.sun.net.httpserver.Headers;
+import com.sun.net.httpserver.HttpContext;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpPrincipal;
+import org.testng.annotations.Test;
+import sun.net.httpserver.UnmodifiableHeaders;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertThrows;
+
+public class UnmodifiableHeadersTest {
+
+    @Test
+    public static void testEquality() {
+        var headers = new Headers();
+        var unmodifiableHeaders1 = new UnmodifiableHeaders(headers);
+        assertEquals(unmodifiableHeaders1, headers);
+        assertEquals(unmodifiableHeaders1.hashCode(), headers.hashCode());
+        assertEquals(unmodifiableHeaders1.get("Foo"), headers.get("Foo"));
+
+        headers.add("Foo", "Bar");
+        var unmodifiableHeaders2 = new UnmodifiableHeaders(headers);
+        assertEquals(unmodifiableHeaders2, headers);
+        assertEquals(unmodifiableHeaders2.hashCode(), headers.hashCode());
+        assertEquals(unmodifiableHeaders2.get("Foo"), headers.get("Foo"));
+    }
+
+    @Test
+    public static void testUnmodifiableHeaders() {
+        var headers = new Headers();
+        headers.add("Foo", "Bar");
+        HttpExchange exchange = new TestHttpExchange(headers);
+
+        assertUnsupportedOperation(exchange.getRequestHeaders());
+        assertUnmodifiableCollection(exchange.getRequestHeaders());
+    }
+
+    static final Class<UnsupportedOperationException> UOP = UnsupportedOperationException.class;
+
+    static void assertUnsupportedOperation(Headers headers) {
+        assertThrows(UOP, () -> headers.add("a", "b"));
+        assertThrows(UOP, () -> headers.compute("c", (k, v) -> List.of("c")));
+        assertThrows(UOP, () -> headers.computeIfAbsent("d", k -> List.of("d")));
+        assertThrows(UOP, () -> headers.computeIfPresent("Foo", (k, v) -> null));
+        assertThrows(UOP, () -> headers.merge("e", List.of("e"), (k, v) -> List.of("e")));
+        assertThrows(UOP, () -> headers.put("f", List.of("f")));
+        assertThrows(UOP, () -> headers.putAll(Map.of()));
+        assertThrows(UOP, () -> headers.putIfAbsent("g", List.of("g")));
+        assertThrows(UOP, () -> headers.remove("h"));
+        assertThrows(UOP, () -> headers.replace("i", List.of("i")));
+        assertThrows(UOP, () -> headers.replace("j", List.of("j"), List.of("j")));
+        assertThrows(UOP, () -> headers.replaceAll((k, v) -> List.of("k")));
+        assertThrows(UOP, () -> headers.set("l", "m"));
+        assertThrows(UOP, () -> headers.clear());
+    }
+
+    static void assertUnmodifiableCollection(Headers headers) {
+        var entry = new AbstractMap.SimpleEntry<>("n", List.of("n"));
+
+        assertThrows(UOP, () -> headers.values().remove(List.of("Bar")));
+        assertThrows(UOP, () -> headers.values().removeAll(List.of("Bar")));
+        assertThrows(UOP, () -> headers.keySet().remove("Foo"));
+        assertThrows(UOP, () -> headers.keySet().removeAll(List.of("Foo")));
+        assertThrows(UOP, () -> headers.entrySet().remove(entry));
+        assertThrows(UOP, () -> headers.entrySet().removeAll(List.of(entry)));
+    }
+
+    static void assertUnmodifiableList(Headers headers) {
+        assertThrows(UOP, () -> headers.get("Foo").remove(0));
+        assertThrows(UOP, () -> headers.get("foo").remove(0));
+        assertThrows(UOP, () -> headers.values().stream().findFirst().orElseThrow().remove(0));
+        assertThrows(UOP, () -> headers.entrySet().stream().findFirst().orElseThrow().getValue().remove(0));
+    }
+
+    static class TestHttpExchange extends StubHttpExchange {
+        final UnmodifiableHeaders headers;
+
+        TestHttpExchange(Headers headers) {
+            this.headers = new UnmodifiableHeaders(headers);
+        }
+
+        @Override
+        public Headers getRequestHeaders() {
+            return headers;
+        }
+    }
+
+    static class StubHttpExchange extends HttpExchange {
+        @Override public Headers getRequestHeaders() { return null; }
+        @Override public Headers getResponseHeaders() { return null; }
+        @Override public URI getRequestURI() { return null; }
+        @Override public String getRequestMethod() { return null; }
+        @Override public HttpContext getHttpContext() { return null; }
+        @Override public void close() { }
+        @Override public InputStream getRequestBody() { return null; }
+        @Override public OutputStream getResponseBody() { return null; }
+        @Override public void sendResponseHeaders(int rCode, long responseLength) { }
+        @Override public InetSocketAddress getRemoteAddress() { return null; }
+        @Override public int getResponseCode() { return 0; }
+        @Override public InetSocketAddress getLocalAddress() { return null; }
+        @Override public String getProtocol() { return null; }
+        @Override public Object getAttribute(String name) { return null; }
+        @Override public void setAttribute(String name, Object value) { }
+        @Override public void setStreams(InputStream i, OutputStream o) { }
+        @Override public HttpPrincipal getPrincipal() { return null; }
+    }
+}