-- * All instances of "." and ".." are factored out. -+ * All segments of "." and ".." are factored out. - * Null is returned if the path tries to .. above its root. - *
- * -- * @param path the path to convert, decoded, with path separators '/' and no queries. -+ * @param uri the encoded URI from the path onwards, which may contain query strings and/or fragments - * @return the canonical path, or null if path traversal above root. -+ * @see #canonicalPath(String) -+ * @see #canonicalURI(String) - */ -- public static String canonicalPath(String path) -+ public static String canonicalURI(String uri) - { -- // See https://tools.ietf.org/html/rfc3986#section-5.2.4 -- -- if (path == null || path.isEmpty()) -- return path; -+ if (uri == null || uri.isEmpty()) -+ return uri; - -- int end = path.length(); -+ boolean slash = true; -+ int end = uri.length(); - int i = 0; -- int dots = 0; - -+ // Initially just loop looking if we may need to normalize - loop: while (i < end) - { -- char c = path.charAt(i); -+ char c = uri.charAt(i); - switch (c) - { - case '/': -- dots = 0; -+ slash = true; - break; - - case '.': -- if (dots == 0) -- { -- dots = 1; -+ if (slash) - break loop; -- } -- dots = -1; -+ slash = false; - break; - -+ case '?': -+ case '#': -+ // Nothing to normalize so return original path -+ return uri; -+ - default: -- dots = -1; -+ slash = false; - } - - i++; - } - -+ // Nothing to normalize so return original path - if (i == end) -- return path; -+ return uri; - -- StringBuilder canonical = new StringBuilder(path.length()); -- canonical.append(path, 0, i); -+ // We probably need to normalize, so copy to path so far into builder -+ StringBuilder canonical = new StringBuilder(uri.length()); -+ canonical.append(uri, 0, i); - -+ // Loop looking for single and double dot segments -+ int dots = 1; - i++; -- while (i <= end) -+ loop : while (i < end) - { -- char c = i < end ? path.charAt(i) : '\0'; -+ char c = uri.charAt(i); - switch (c) - { -- case '\0': -- if (dots == 2) -- { -- if (canonical.length() < 2) -- return null; -- canonical.setLength(canonical.length() - 1); -- canonical.setLength(canonical.lastIndexOf("/") + 1); -- } -- break; -- - case '/': -- switch (dots) -- { -- case 1: -- break; -- -- case 2: -- if (canonical.length() < 2) -- return null; -- canonical.setLength(canonical.length() - 1); -- canonical.setLength(canonical.lastIndexOf("/") + 1); -- break; -- -- default: -- canonical.append(c); -- } -+ if (doDotsSlash(canonical, dots)) -+ return null; -+ slash = true; - dots = 0; - break; - -+ case '?': -+ case '#': -+ // finish normalization at a query -+ break loop; -+ - case '.': -- switch (dots) -- { -- case 0: -- dots = 1; -- break; -- case 1: -- dots = 2; -- break; -- case 2: -- canonical.append("..."); -- dots = -1; -- break; -- default: -- canonical.append('.'); -- } -+ // Count dots only if they are leading in the segment -+ if (dots > 0) -+ dots++; -+ else if (slash) -+ dots = 1; -+ else -+ canonical.append('.'); -+ slash = false; - break; - - default: -- switch (dots) -- { -- case 1: -- canonical.append('.'); -- break; -- case 2: -- canonical.append(".."); -- break; -- default: -- } -+ // Add leading dots to the path -+ while (dots-- > 0) -+ canonical.append('.'); - canonical.append(c); -- dots = -1; -+ dots = 0; -+ slash = false; - } -- - i++; - } -+ -+ // process any remaining dots -+ if (doDots(canonical, dots)) -+ return null; -+ -+ // append any query -+ if (i < end) -+ canonical.append(uri, i, end); -+ - return canonical.toString(); - } - - /** -- * Convert a path to a cananonical form. -- *-- * All instances of "." and ".." are factored out. -- *
-+ * @param path the encoded URI from the path onwards, which may contain query strings and/or fragments -+ * @return the canonical path, or null if path traversal above root. -+ * @deprecated Use {@link #canonicalURI(String)} -+ */ -+ @Deprecated -+ public static String canonicalEncodedPath(String path) -+ { -+ return canonicalURI(path); -+ } -+ -+ /** -+ * Convert a decoded URI path to a canonical form. - *-+ * All segments of "." and ".." are factored out. - * Null is returned if the path tries to .. above its root. - *
- * -- * @param path the path to convert (expects URI/URL form, encoded, and with path separators '/') -+ * @param path the decoded URI path to convert. Any special characters (e.g. '?', "#") are assumed to be part of -+ * the path segments. - * @return the canonical path, or null if path traversal above root. -+ * @see #canonicalURI(String) - */ -- public static String canonicalEncodedPath(String path) -+ public static String canonicalPath(String path) - { - if (path == null || path.isEmpty()) - return path; -@@ -927,8 +921,8 @@ public class URIUtil - int end = path.length(); - int i = 0; - -- loop: -- while (i < end) -+ // Initially just loop looking if we may need to normalize -+ loop: while (i < end) - { - char c = path.charAt(i); - switch (c) -@@ -943,9 +937,6 @@ public class URIUtil - slash = false; - break; - -- case '?': -- return path; -- - default: - slash = false; - } -@@ -953,56 +944,31 @@ public class URIUtil - i++; - } - -+ // Nothing to normalize so return original path - if (i == end) - return path; - -+ // We probably need to normalize, so copy to path so far into builder - StringBuilder canonical = new StringBuilder(path.length()); - canonical.append(path, 0, i); - -+ // Loop looking for single and double dot segments - int dots = 1; - i++; -- while (i <= end) -+ while (i < end) - { -- char c = i < end ? path.charAt(i) : '\0'; -+ char c = path.charAt(i); - switch (c) - { -- case '\0': - case '/': -- case '?': -- switch (dots) -- { -- case 0: -- if (c != '\0') -- canonical.append(c); -- break; -- -- case 1: -- if (c == '?') -- canonical.append(c); -- break; -- -- case 2: -- if (canonical.length() < 2) -- return null; -- canonical.setLength(canonical.length() - 1); -- canonical.setLength(canonical.lastIndexOf("/") + 1); -- if (c == '?') -- canonical.append(c); -- break; -- default: -- while (dots-- > 0) -- { -- canonical.append('.'); -- } -- if (c != '\0') -- canonical.append(c); -- } -- -+ if (doDotsSlash(canonical, dots)) -+ return null; - slash = true; - dots = 0; - break; - - case '.': -+ // Count dots only if they are leading in the segment - if (dots > 0) - dots++; - else if (slash) -@@ -1013,20 +979,66 @@ public class URIUtil - break; - - default: -+ // Add leading dots to the path - while (dots-- > 0) -- { - canonical.append('.'); -- } - canonical.append(c); - dots = 0; - slash = false; - } -- - i++; - } -+ -+ // process any remaining dots -+ if (doDots(canonical, dots)) -+ return null; -+ - return canonical.toString(); - } - -+ private static boolean doDots(StringBuilder canonical, int dots) -+ { -+ switch (dots) -+ { -+ case 0: -+ case 1: -+ break; -+ case 2: -+ if (canonical.length() < 2) -+ return true; -+ canonical.setLength(canonical.length() - 1); -+ canonical.setLength(canonical.lastIndexOf("/") + 1); -+ break; -+ default: -+ while (dots-- > 0) -+ canonical.append('.'); -+ } -+ return false; -+ } -+ -+ private static boolean doDotsSlash(StringBuilder canonical, int dots) -+ { -+ switch (dots) -+ { -+ case 0: -+ canonical.append('/'); -+ break; -+ case 1: -+ break; -+ case 2: -+ if (canonical.length() < 2) -+ return true; -+ canonical.setLength(canonical.length() - 1); -+ canonical.setLength(canonical.lastIndexOf("/") + 1); -+ break; -+ default: -+ while (dots-- > 0) -+ canonical.append('.'); -+ canonical.append('/'); -+ } -+ return false; -+ } -+ - /** - * Convert a path to a compact form. - * All instances of "//" and "///" etc. are factored out to single "/" -diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java -index 9ccfe96..d62b117 100644 ---- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java -+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/FileResource.java -@@ -271,8 +271,11 @@ public class FileResource extends Resource - assertValidPath(path); - path = org.eclipse.jetty.util.URIUtil.canonicalPath(path); - -- if (path == null) -- throw new MalformedURLException(); -+ // Check that the path is within the root, -+ // but use the original path to create the -+ // resource, to preserve aliasing. -+ if (URIUtil.canonicalPath(path) == null) -+ throw new MalformedURLException(path); - - if ("/".equals(path)) - return this; -diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java -index af377b1..67a31b3 100644 ---- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java -+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/PathResource.java -@@ -97,6 +97,13 @@ public class PathResource extends Resource - abs = path.toAbsolutePath(); - } - -+ // Any normalization difference means it's an alias, -+ // and we don't want to bother further to follow -+ // symlinks as it's an alias anyway. -+ Path normal = path.normalize(); -+ if (!isSameName(abs, normal)) -+ return normal; -+ - try - { - if (Files.isSymbolicLink(path)) -@@ -104,11 +111,8 @@ public class PathResource extends Resource - if (Files.exists(path)) - { - Path real = abs.toRealPath(FOLLOW_LINKS); -- - if (!isSameName(abs, real)) -- { - return real; -- } - } - } - catch (IOException e) -@@ -363,12 +367,13 @@ public class PathResource extends Resource - @Override - public Resource addPath(final String subpath) throws IOException - { -- String cpath = URIUtil.canonicalPath(subpath); -- -- if ((cpath == null) || (cpath.length() == 0)) -+ // Check that the path is within the root, -+ // but use the original path to create the -+ // resource, to preserve aliasing. -+ if (URIUtil.canonicalPath(subpath) == null) - throw new MalformedURLException(subpath); - -- if ("/".equals(cpath)) -+ if ("/".equals(subpath)) - return this; - - // subpaths are always under PathResource -diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java -index 4574436..3448e94 100644 ---- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java -+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/Resource.java -@@ -459,10 +459,12 @@ public abstract class Resource implements ResourceFactory, Closeable - * Returns the resource contained inside the current resource with the - * given name. - * -- * @param path The path segment to add, which is not encoded -+ * @param path The path segment to add, which is not encoded. The path may be non canonical, but if so then -+ * the resulting Resource will return true from {@link #isAlias()}. - * @return the Resource for the resolved path within this Resource. - * @throws IOException if unable to resolve the path -- * @throws MalformedURLException if the resolution of the path fails because the input path parameter is malformed. -+ * @throws MalformedURLException if the resolution of the path fails because the input path parameter is malformed, or -+ * a relative path attempts to access above the root resource. - */ - public abstract Resource addPath(String path) - throws IOException, MalformedURLException; -diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java -index ffd9c1c..40d68ab 100644 ---- a/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java -+++ b/jetty-util/src/main/java/org/eclipse/jetty/util/resource/URLResource.java -@@ -271,10 +271,11 @@ public class URLResource extends Resource - public Resource addPath(String path) - throws IOException - { -- if (path == null) -- return null; -- -- path = URIUtil.canonicalPath(path); -+ // Check that the path is within the root, -+ // but use the original path to create the -+ // resource, to preserve aliasing. -+ if (URIUtil.canonicalPath(path) == null) -+ throw new MalformedURLException(path); - - return newResource(URIUtil.addEncodedPaths(_url.toExternalForm(), URIUtil.encodePath(path)), _useCaches); - } -diff --git a/jetty-util/src/test/java/org/eclipse/jetty/util/URIUtilCanonicalPathTest.java b/jetty-util/src/test/java/org/eclipse/jetty/util/URIUtilCanonicalPathTest.java -index 82f2771..a272926 100644 ---- a/jetty-util/src/test/java/org/eclipse/jetty/util/URIUtilCanonicalPathTest.java -+++ b/jetty-util/src/test/java/org/eclipse/jetty/util/URIUtilCanonicalPathTest.java -@@ -149,4 +149,24 @@ public class URIUtilCanonicalPathTest - { - assertThat(URIUtil.canonicalPath(input), is(expectedResult)); - } -+ -+ public static Stream++ * field-vchar = VCHAR / obs-text ++ * obs-text = %x80-FF ++ * VCHAR = %x21-7E ++ *++ * @param c the character to test. ++ * @return the original character or the replacement character ' ' or '?', ++ * the return value is guaranteed to be a valid ISO-8859-1 character. ++ */ ++ public static char sanitizeFieldVchar(char c) ++ { ++ switch (c) ++ { ++ // A recipient of CR, LF, or NUL within a field value MUST either reject the message ++ // or replace each of those characters with SP before further processing ++ case '\r': ++ case '\n': ++ case 0x00: ++ return ' '; ++ ++ default: ++ if (isIllegalFieldVchar(c)) ++ return '?'; ++ } ++ return c; ++ } ++ ++ /** ++ * Checks whether this is an invalid VCHAR based on RFC9110. ++ * If this not a valid ISO-8859-1 character or a control character ++ * we say that it is illegal. ++ * ++ * @param c the character to test. ++ * @return true if this is invalid VCHAR. ++ */ ++ public static boolean isIllegalFieldVchar(char c) ++ { ++ return (c >= 256 || c < ' '); ++ } + } + +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/EncodingException.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/EncodingException.java +new file mode 100644 +index 0000000..5f05557 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/EncodingException.java +@@ -0,0 +1,27 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++public class EncodingException extends Exception ++{ ++ public EncodingException(String message) ++ { ++ super(message); ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/Huffman.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/Huffman.java +new file mode 100644 +index 0000000..6e2cb33 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/Huffman.java +@@ -0,0 +1,357 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++/** ++ * This class contains the Huffman Codes defined in RFC7541. ++ */ ++public class Huffman ++{ ++ private Huffman() ++ { ++ } ++ ++ // Appendix C: Huffman Codes ++ // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C ++ static final int[][] CODES = ++ { ++ /* ( 0) |11111111|11000 */ {0x1ff8, 13}, ++ /* ( 1) |11111111|11111111|1011000 */ {0x7fffd8, 23}, ++ /* ( 2) |11111111|11111111|11111110|0010 */ {0xfffffe2, 28}, ++ /* ( 3) |11111111|11111111|11111110|0011 */ {0xfffffe3, 28}, ++ /* ( 4) |11111111|11111111|11111110|0100 */ {0xfffffe4, 28}, ++ /* ( 5) |11111111|11111111|11111110|0101 */ {0xfffffe5, 28}, ++ /* ( 6) |11111111|11111111|11111110|0110 */ {0xfffffe6, 28}, ++ /* ( 7) |11111111|11111111|11111110|0111 */ {0xfffffe7, 28}, ++ /* ( 8) |11111111|11111111|11111110|1000 */ {0xfffffe8, 28}, ++ /* ( 9) |11111111|11111111|11101010 */ {0xffffea, 24}, ++ /* ( 10) |11111111|11111111|11111111|111100 */ {0x3ffffffc, 30}, ++ /* ( 11) |11111111|11111111|11111110|1001 */ {0xfffffe9, 28}, ++ /* ( 12) |11111111|11111111|11111110|1010 */ {0xfffffea, 28}, ++ /* ( 13) |11111111|11111111|11111111|111101 */ {0x3ffffffd, 30}, ++ /* ( 14) |11111111|11111111|11111110|1011 */ {0xfffffeb, 28}, ++ /* ( 15) |11111111|11111111|11111110|1100 */ {0xfffffec, 28}, ++ /* ( 16) |11111111|11111111|11111110|1101 */ {0xfffffed, 28}, ++ /* ( 17) |11111111|11111111|11111110|1110 */ {0xfffffee, 28}, ++ /* ( 18) |11111111|11111111|11111110|1111 */ {0xfffffef, 28}, ++ /* ( 19) |11111111|11111111|11111111|0000 */ {0xffffff0, 28}, ++ /* ( 20) |11111111|11111111|11111111|0001 */ {0xffffff1, 28}, ++ /* ( 21) |11111111|11111111|11111111|0010 */ {0xffffff2, 28}, ++ /* ( 22) |11111111|11111111|11111111|111110 */ {0x3ffffffe, 30}, ++ /* ( 23) |11111111|11111111|11111111|0011 */ {0xffffff3, 28}, ++ /* ( 24) |11111111|11111111|11111111|0100 */ {0xffffff4, 28}, ++ /* ( 25) |11111111|11111111|11111111|0101 */ {0xffffff5, 28}, ++ /* ( 26) |11111111|11111111|11111111|0110 */ {0xffffff6, 28}, ++ /* ( 27) |11111111|11111111|11111111|0111 */ {0xffffff7, 28}, ++ /* ( 28) |11111111|11111111|11111111|1000 */ {0xffffff8, 28}, ++ /* ( 29) |11111111|11111111|11111111|1001 */ {0xffffff9, 28}, ++ /* ( 30) |11111111|11111111|11111111|1010 */ {0xffffffa, 28}, ++ /* ( 31) |11111111|11111111|11111111|1011 */ {0xffffffb, 28}, ++ /*' ' ( 32) |010100 */ {0x14, 6}, ++ /*'!' ( 33) |11111110|00 */ {0x3f8, 10}, ++ /*'"' ( 34) |11111110|01 */ {0x3f9, 10}, ++ /*'#' ( 35) |11111111|1010 */ {0xffa, 12}, ++ /*'$' ( 36) |11111111|11001 */ {0x1ff9, 13}, ++ /*'%' ( 37) |010101 */ {0x15, 6}, ++ /*'&' ( 38) |11111000 */ {0xf8, 8}, ++ /*''' ( 39) |11111111|010 */ {0x7fa, 11}, ++ /*'(' ( 40) |11111110|10 */ {0x3fa, 10}, ++ /*')' ( 41) |11111110|11 */ {0x3fb, 10}, ++ /*'*' ( 42) |11111001 */ {0xf9, 8}, ++ /*'+' ( 43) |11111111|011 */ {0x7fb, 11}, ++ /*',' ( 44) |11111010 */ {0xfa, 8}, ++ /*'-' ( 45) |010110 */ {0x16, 6}, ++ /*'.' ( 46) |010111 */ {0x17, 6}, ++ /*'/' ( 47) |011000 */ {0x18, 6}, ++ /*'0' ( 48) |00000 */ {0x0, 5}, ++ /*'1' ( 49) |00001 */ {0x1, 5}, ++ /*'2' ( 50) |00010 */ {0x2, 5}, ++ /*'3' ( 51) |011001 */ {0x19, 6}, ++ /*'4' ( 52) |011010 */ {0x1a, 6}, ++ /*'5' ( 53) |011011 */ {0x1b, 6}, ++ /*'6' ( 54) |011100 */ {0x1c, 6}, ++ /*'7' ( 55) |011101 */ {0x1d, 6}, ++ /*'8' ( 56) |011110 */ {0x1e, 6}, ++ /*'9' ( 57) |011111 */ {0x1f, 6}, ++ /*':' ( 58) |1011100 */ {0x5c, 7}, ++ /*';' ( 59) |11111011 */ {0xfb, 8}, ++ /*'<' ( 60) |11111111|1111100 */ {0x7ffc, 15}, ++ /*'=' ( 61) |100000 */ {0x20, 6}, ++ /*'>' ( 62) |11111111|1011 */ {0xffb, 12}, ++ /*'?' ( 63) |11111111|00 */ {0x3fc, 10}, ++ /*'@' ( 64) |11111111|11010 */ {0x1ffa, 13}, ++ /*'A' ( 65) |100001 */ {0x21, 6}, ++ /*'B' ( 66) |1011101 */ {0x5d, 7}, ++ /*'C' ( 67) |1011110 */ {0x5e, 7}, ++ /*'D' ( 68) |1011111 */ {0x5f, 7}, ++ /*'E' ( 69) |1100000 */ {0x60, 7}, ++ /*'F' ( 70) |1100001 */ {0x61, 7}, ++ /*'G' ( 71) |1100010 */ {0x62, 7}, ++ /*'H' ( 72) |1100011 */ {0x63, 7}, ++ /*'I' ( 73) |1100100 */ {0x64, 7}, ++ /*'J' ( 74) |1100101 */ {0x65, 7}, ++ /*'K' ( 75) |1100110 */ {0x66, 7}, ++ /*'L' ( 76) |1100111 */ {0x67, 7}, ++ /*'M' ( 77) |1101000 */ {0x68, 7}, ++ /*'N' ( 78) |1101001 */ {0x69, 7}, ++ /*'O' ( 79) |1101010 */ {0x6a, 7}, ++ /*'P' ( 80) |1101011 */ {0x6b, 7}, ++ /*'Q' ( 81) |1101100 */ {0x6c, 7}, ++ /*'R' ( 82) |1101101 */ {0x6d, 7}, ++ /*'S' ( 83) |1101110 */ {0x6e, 7}, ++ /*'T' ( 84) |1101111 */ {0x6f, 7}, ++ /*'U' ( 85) |1110000 */ {0x70, 7}, ++ /*'V' ( 86) |1110001 */ {0x71, 7}, ++ /*'W' ( 87) |1110010 */ {0x72, 7}, ++ /*'X' ( 88) |11111100 */ {0xfc, 8}, ++ /*'Y' ( 89) |1110011 */ {0x73, 7}, ++ /*'Z' ( 90) |11111101 */ {0xfd, 8}, ++ /*'[' ( 91) |11111111|11011 */ {0x1ffb, 13}, ++ /*'\' ( 92) |11111111|11111110|000 */ {0x7fff0, 19}, ++ /*']' ( 93) |11111111|11100 */ {0x1ffc, 13}, ++ /*'^' ( 94) |11111111|111100 */ {0x3ffc, 14}, ++ /*'_' ( 95) |100010 */ {0x22, 6}, ++ /*'`' ( 96) |11111111|1111101 */ {0x7ffd, 15}, ++ /*'a' ( 97) |00011 */ {0x3, 5}, ++ /*'b' ( 98) |100011 */ {0x23, 6}, ++ /*'c' ( 99) |00100 */ {0x4, 5}, ++ /*'d' (100) |100100 */ {0x24, 6}, ++ /*'e' (101) |00101 */ {0x5, 5}, ++ /*'f' (102) |100101 */ {0x25, 6}, ++ /*'g' (103) |100110 */ {0x26, 6}, ++ /*'h' (104) |100111 */ {0x27, 6}, ++ /*'i' (105) |00110 */ {0x6, 5}, ++ /*'j' (106) |1110100 */ {0x74, 7}, ++ /*'k' (107) |1110101 */ {0x75, 7}, ++ /*'l' (108) |101000 */ {0x28, 6}, ++ /*'m' (109) |101001 */ {0x29, 6}, ++ /*'n' (110) |101010 */ {0x2a, 6}, ++ /*'o' (111) |00111 */ {0x7, 5}, ++ /*'p' (112) |101011 */ {0x2b, 6}, ++ /*'q' (113) |1110110 */ {0x76, 7}, ++ /*'r' (114) |101100 */ {0x2c, 6}, ++ /*'s' (115) |01000 */ {0x8, 5}, ++ /*'t' (116) |01001 */ {0x9, 5}, ++ /*'u' (117) |101101 */ {0x2d, 6}, ++ /*'v' (118) |1110111 */ {0x77, 7}, ++ /*'w' (119) |1111000 */ {0x78, 7}, ++ /*'x' (120) |1111001 */ {0x79, 7}, ++ /*'y' (121) |1111010 */ {0x7a, 7}, ++ /*'z' (122) |1111011 */ {0x7b, 7}, ++ /*'{' (123) |11111111|1111110 */ {0x7ffe, 15}, ++ /*'|' (124) |11111111|100 */ {0x7fc, 11}, ++ /*'}' (125) |11111111|111101 */ {0x3ffd, 14}, ++ /*'~' (126) |11111111|11101 */ {0x1ffd, 13}, ++ /* (127) |11111111|11111111|11111111|1100 */ {0xffffffc, 28}, ++ /* (128) |11111111|11111110|0110 */ {0xfffe6, 20}, ++ /* (129) |11111111|11111111|010010 */ {0x3fffd2, 22}, ++ /* (130) |11111111|11111110|0111 */ {0xfffe7, 20}, ++ /* (131) |11111111|11111110|1000 */ {0xfffe8, 20}, ++ /* (132) |11111111|11111111|010011 */ {0x3fffd3, 22}, ++ /* (133) |11111111|11111111|010100 */ {0x3fffd4, 22}, ++ /* (134) |11111111|11111111|010101 */ {0x3fffd5, 22}, ++ /* (135) |11111111|11111111|1011001 */ {0x7fffd9, 23}, ++ /* (136) |11111111|11111111|010110 */ {0x3fffd6, 22}, ++ /* (137) |11111111|11111111|1011010 */ {0x7fffda, 23}, ++ /* (138) |11111111|11111111|1011011 */ {0x7fffdb, 23}, ++ /* (139) |11111111|11111111|1011100 */ {0x7fffdc, 23}, ++ /* (140) |11111111|11111111|1011101 */ {0x7fffdd, 23}, ++ /* (141) |11111111|11111111|1011110 */ {0x7fffde, 23}, ++ /* (142) |11111111|11111111|11101011 */ {0xffffeb, 24}, ++ /* (143) |11111111|11111111|1011111 */ {0x7fffdf, 23}, ++ /* (144) |11111111|11111111|11101100 */ {0xffffec, 24}, ++ /* (145) |11111111|11111111|11101101 */ {0xffffed, 24}, ++ /* (146) |11111111|11111111|010111 */ {0x3fffd7, 22}, ++ /* (147) |11111111|11111111|1100000 */ {0x7fffe0, 23}, ++ /* (148) |11111111|11111111|11101110 */ {0xffffee, 24}, ++ /* (149) |11111111|11111111|1100001 */ {0x7fffe1, 23}, ++ /* (150) |11111111|11111111|1100010 */ {0x7fffe2, 23}, ++ /* (151) |11111111|11111111|1100011 */ {0x7fffe3, 23}, ++ /* (152) |11111111|11111111|1100100 */ {0x7fffe4, 23}, ++ /* (153) |11111111|11111110|11100 */ {0x1fffdc, 21}, ++ /* (154) |11111111|11111111|011000 */ {0x3fffd8, 22}, ++ /* (155) |11111111|11111111|1100101 */ {0x7fffe5, 23}, ++ /* (156) |11111111|11111111|011001 */ {0x3fffd9, 22}, ++ /* (157) |11111111|11111111|1100110 */ {0x7fffe6, 23}, ++ /* (158) |11111111|11111111|1100111 */ {0x7fffe7, 23}, ++ /* (159) |11111111|11111111|11101111 */ {0xffffef, 24}, ++ /* (160) |11111111|11111111|011010 */ {0x3fffda, 22}, ++ /* (161) |11111111|11111110|11101 */ {0x1fffdd, 21}, ++ /* (162) |11111111|11111110|1001 */ {0xfffe9, 20}, ++ /* (163) |11111111|11111111|011011 */ {0x3fffdb, 22}, ++ /* (164) |11111111|11111111|011100 */ {0x3fffdc, 22}, ++ /* (165) |11111111|11111111|1101000 */ {0x7fffe8, 23}, ++ /* (166) |11111111|11111111|1101001 */ {0x7fffe9, 23}, ++ /* (167) |11111111|11111110|11110 */ {0x1fffde, 21}, ++ /* (168) |11111111|11111111|1101010 */ {0x7fffea, 23}, ++ /* (169) |11111111|11111111|011101 */ {0x3fffdd, 22}, ++ /* (170) |11111111|11111111|011110 */ {0x3fffde, 22}, ++ /* (171) |11111111|11111111|11110000 */ {0xfffff0, 24}, ++ /* (172) |11111111|11111110|11111 */ {0x1fffdf, 21}, ++ /* (173) |11111111|11111111|011111 */ {0x3fffdf, 22}, ++ /* (174) |11111111|11111111|1101011 */ {0x7fffeb, 23}, ++ /* (175) |11111111|11111111|1101100 */ {0x7fffec, 23}, ++ /* (176) |11111111|11111111|00000 */ {0x1fffe0, 21}, ++ /* (177) |11111111|11111111|00001 */ {0x1fffe1, 21}, ++ /* (178) |11111111|11111111|100000 */ {0x3fffe0, 22}, ++ /* (179) |11111111|11111111|00010 */ {0x1fffe2, 21}, ++ /* (180) |11111111|11111111|1101101 */ {0x7fffed, 23}, ++ /* (181) |11111111|11111111|100001 */ {0x3fffe1, 22}, ++ /* (182) |11111111|11111111|1101110 */ {0x7fffee, 23}, ++ /* (183) |11111111|11111111|1101111 */ {0x7fffef, 23}, ++ /* (184) |11111111|11111110|1010 */ {0xfffea, 20}, ++ /* (185) |11111111|11111111|100010 */ {0x3fffe2, 22}, ++ /* (186) |11111111|11111111|100011 */ {0x3fffe3, 22}, ++ /* (187) |11111111|11111111|100100 */ {0x3fffe4, 22}, ++ /* (188) |11111111|11111111|1110000 */ {0x7ffff0, 23}, ++ /* (189) |11111111|11111111|100101 */ {0x3fffe5, 22}, ++ /* (190) |11111111|11111111|100110 */ {0x3fffe6, 22}, ++ /* (191) |11111111|11111111|1110001 */ {0x7ffff1, 23}, ++ /* (192) |11111111|11111111|11111000|00 */ {0x3ffffe0, 26}, ++ /* (193) |11111111|11111111|11111000|01 */ {0x3ffffe1, 26}, ++ /* (194) |11111111|11111110|1011 */ {0xfffeb, 20}, ++ /* (195) |11111111|11111110|001 */ {0x7fff1, 19}, ++ /* (196) |11111111|11111111|100111 */ {0x3fffe7, 22}, ++ /* (197) |11111111|11111111|1110010 */ {0x7ffff2, 23}, ++ /* (198) |11111111|11111111|101000 */ {0x3fffe8, 22}, ++ /* (199) |11111111|11111111|11110110|0 */ {0x1ffffec, 25}, ++ /* (200) |11111111|11111111|11111000|10 */ {0x3ffffe2, 26}, ++ /* (201) |11111111|11111111|11111000|11 */ {0x3ffffe3, 26}, ++ /* (202) |11111111|11111111|11111001|00 */ {0x3ffffe4, 26}, ++ /* (203) |11111111|11111111|11111011|110 */ {0x7ffffde, 27}, ++ /* (204) |11111111|11111111|11111011|111 */ {0x7ffffdf, 27}, ++ /* (205) |11111111|11111111|11111001|01 */ {0x3ffffe5, 26}, ++ /* (206) |11111111|11111111|11110001 */ {0xfffff1, 24}, ++ /* (207) |11111111|11111111|11110110|1 */ {0x1ffffed, 25}, ++ /* (208) |11111111|11111110|010 */ {0x7fff2, 19}, ++ /* (209) |11111111|11111111|00011 */ {0x1fffe3, 21}, ++ /* (210) |11111111|11111111|11111001|10 */ {0x3ffffe6, 26}, ++ /* (211) |11111111|11111111|11111100|000 */ {0x7ffffe0, 27}, ++ /* (212) |11111111|11111111|11111100|001 */ {0x7ffffe1, 27}, ++ /* (213) |11111111|11111111|11111001|11 */ {0x3ffffe7, 26}, ++ /* (214) |11111111|11111111|11111100|010 */ {0x7ffffe2, 27}, ++ /* (215) |11111111|11111111|11110010 */ {0xfffff2, 24}, ++ /* (216) |11111111|11111111|00100 */ {0x1fffe4, 21}, ++ /* (217) |11111111|11111111|00101 */ {0x1fffe5, 21}, ++ /* (218) |11111111|11111111|11111010|00 */ {0x3ffffe8, 26}, ++ /* (219) |11111111|11111111|11111010|01 */ {0x3ffffe9, 26}, ++ /* (220) |11111111|11111111|11111111|1101 */ {0xffffffd, 28}, ++ /* (221) |11111111|11111111|11111100|011 */ {0x7ffffe3, 27}, ++ /* (222) |11111111|11111111|11111100|100 */ {0x7ffffe4, 27}, ++ /* (223) |11111111|11111111|11111100|101 */ {0x7ffffe5, 27}, ++ /* (224) |11111111|11111110|1100 */ {0xfffec, 20}, ++ /* (225) |11111111|11111111|11110011 */ {0xfffff3, 24}, ++ /* (226) |11111111|11111110|1101 */ {0xfffed, 20}, ++ /* (227) |11111111|11111111|00110 */ {0x1fffe6, 21}, ++ /* (228) |11111111|11111111|101001 */ {0x3fffe9, 22}, ++ /* (229) |11111111|11111111|00111 */ {0x1fffe7, 21}, ++ /* (230) |11111111|11111111|01000 */ {0x1fffe8, 21}, ++ /* (231) |11111111|11111111|1110011 */ {0x7ffff3, 23}, ++ /* (232) |11111111|11111111|101010 */ {0x3fffea, 22}, ++ /* (233) |11111111|11111111|101011 */ {0x3fffeb, 22}, ++ /* (234) |11111111|11111111|11110111|0 */ {0x1ffffee, 25}, ++ /* (235) |11111111|11111111|11110111|1 */ {0x1ffffef, 25}, ++ /* (236) |11111111|11111111|11110100 */ {0xfffff4, 24}, ++ /* (237) |11111111|11111111|11110101 */ {0xfffff5, 24}, ++ /* (238) |11111111|11111111|11111010|10 */ {0x3ffffea, 26}, ++ /* (239) |11111111|11111111|1110100 */ {0x7ffff4, 23}, ++ /* (240) |11111111|11111111|11111010|11 */ {0x3ffffeb, 26}, ++ /* (241) |11111111|11111111|11111100|110 */ {0x7ffffe6, 27}, ++ /* (242) |11111111|11111111|11111011|00 */ {0x3ffffec, 26}, ++ /* (243) |11111111|11111111|11111011|01 */ {0x3ffffed, 26}, ++ /* (244) |11111111|11111111|11111100|111 */ {0x7ffffe7, 27}, ++ /* (245) |11111111|11111111|11111101|000 */ {0x7ffffe8, 27}, ++ /* (246) |11111111|11111111|11111101|001 */ {0x7ffffe9, 27}, ++ /* (247) |11111111|11111111|11111101|010 */ {0x7ffffea, 27}, ++ /* (248) |11111111|11111111|11111101|011 */ {0x7ffffeb, 27}, ++ /* (249) |11111111|11111111|11111111|1110 */ {0xffffffe, 28}, ++ /* (250) |11111111|11111111|11111101|100 */ {0x7ffffec, 27}, ++ /* (251) |11111111|11111111|11111101|101 */ {0x7ffffed, 27}, ++ /* (252) |11111111|11111111|11111101|110 */ {0x7ffffee, 27}, ++ /* (253) |11111111|11111111|11111101|111 */ {0x7ffffef, 27}, ++ /* (254) |11111111|11111111|11111110|000 */ {0x7fffff0, 27}, ++ /* (255) |11111111|11111111|11111011|10 */ {0x3ffffee, 26}, ++ /*EOS (256) |11111111|11111111|11111111|111111 */ {0x3fffffff, 30} ++ }; ++ ++ static final int[][] LCCODES = new int[CODES.length][]; ++ static final char EOS = 256; ++ ++ // Huffman decode tree stored in a flattened char array for good ++ // locality of reference. ++ static final char[] tree; ++ static final char[] rowsym; ++ static final byte[] rowbits; ++ ++ // Build the Huffman lookup tree and LC TABLE ++ static ++ { ++ System.arraycopy(CODES, 0, LCCODES, 0, CODES.length); ++ for (int i = 'A'; i <= 'Z'; i++) ++ { ++ LCCODES[i] = LCCODES['a' + i - 'A']; ++ } ++ ++ int r = 0; ++ for (int[] ints : CODES) ++ { ++ r += (ints[1] + 7) / 8; ++ } ++ tree = new char[r * 256]; ++ rowsym = new char[r]; ++ rowbits = new byte[r]; ++ ++ r = 0; ++ for (int sym = 0; sym < CODES.length; sym++) ++ { ++ int code = CODES[sym][0]; ++ int len = CODES[sym][1]; ++ ++ int current = 0; ++ ++ while (len > 8) ++ { ++ len -= 8; ++ int i = ((code >>> len) & 0xFF); ++ ++ int t = current * 256 + i; ++ current = tree[t]; ++ if (current == 0) ++ { ++ tree[t] = (char)++r; ++ current = r; ++ } ++ } ++ ++ int terminal = ++r; ++ rowsym[r] = (char)sym; ++ int b = len & 0x07; ++ int terminalBits = b == 0 ? 8 : b; ++ ++ rowbits[r] = (byte)terminalBits; ++ int shift = 8 - len; ++ int start = current * 256 + ((code << shift) & 0xFF); ++ int end = start + (1 << shift); ++ for (int i = start; i < end; i++) ++ { ++ tree[i] = (char)terminal; ++ } ++ } ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanDecoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanDecoder.java +new file mode 100644 +index 0000000..48851c1 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanDecoder.java +@@ -0,0 +1,143 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++import org.eclipse.jetty.http.HttpTokens; ++import org.eclipse.jetty.util.CharsetStringBuilder; ++ ++import static org.eclipse.jetty.http.compression.Huffman.rowbits; ++import static org.eclipse.jetty.http.compression.Huffman.rowsym; ++ ++/** ++ *
Used to decoded Huffman encoded strings.
++ * ++ *Characters which are illegal field-vchar values are replaced with ++ * either ' ' or '?' as described in RFC9110
++ */ ++public class HuffmanDecoder ++{ ++ private final CharsetStringBuilder.Iso88591StringBuilder _builder = new CharsetStringBuilder.Iso88591StringBuilder(); ++ private int _length = 0; ++ private int _count = 0; ++ private int _node = 0; ++ private int _current = 0; ++ private int _bits = 0; ++ ++ /** ++ * @param length in bytes of the huffman data. ++ */ ++ public void setLength(int length) ++ { ++ if (_count != 0) ++ throw new IllegalStateException(); ++ _length = length; ++ } ++ ++ /** ++ * @param buffer the buffer containing the Huffman encoded bytes. ++ * @return the decoded String. ++ * @throws EncodingException if the huffman encoding is invalid. ++ */ ++ public String decode(ByteBuffer buffer) throws EncodingException ++ { ++ for (; _count < _length; _count++) ++ { ++ if (!buffer.hasRemaining()) ++ return null; ++ ++ int b = buffer.get() & 0xFF; ++ _current = (_current << 8) | b; ++ _bits += 8; ++ while (_bits >= 8) ++ { ++ int i = (_current >>> (_bits - 8)) & 0xFF; ++ _node = Huffman.tree[_node * 256 + i]; ++ if (rowbits[_node] != 0) ++ { ++ if (rowsym[_node] == Huffman.EOS) ++ { ++ reset(); ++ throw new EncodingException("eos_in_content"); ++ } ++ ++ // terminal node ++ char c = rowsym[_node]; ++ c = HttpTokens.sanitizeFieldVchar(c); ++ _builder.append((byte)c); ++ _bits -= rowbits[_node]; ++ _node = 0; ++ } ++ else ++ { ++ // non-terminal node ++ _bits -= 8; ++ } ++ } ++ } ++ ++ while (_bits > 0) ++ { ++ int i = (_current << (8 - _bits)) & 0xFF; ++ int lastNode = _node; ++ _node = Huffman.tree[_node * 256 + i]; ++ ++ if (rowbits[_node] == 0 || rowbits[_node] > _bits) ++ { ++ int requiredPadding = 0; ++ for (int j = 0; j < _bits; j++) ++ { ++ requiredPadding = (requiredPadding << 1) | 1; ++ } ++ ++ if ((i >> (8 - _bits)) != requiredPadding) ++ throw new EncodingException("incorrect_padding"); ++ ++ _node = lastNode; ++ break; ++ } ++ ++ char c = rowsym[_node]; ++ c = HttpTokens.sanitizeFieldVchar(c); ++ _builder.append((byte)c); ++ _bits -= rowbits[_node]; ++ _node = 0; ++ } ++ ++ if (_node != 0) ++ { ++ reset(); ++ throw new EncodingException("bad_termination"); ++ } ++ ++ String value = _builder.build(); ++ reset(); ++ return value; ++ } ++ ++ public void reset() ++ { ++ _builder.reset(); ++ _count = 0; ++ _current = 0; ++ _node = 0; ++ _bits = 0; ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanEncoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanEncoder.java +new file mode 100644 +index 0000000..533fc21 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/HuffmanEncoder.java +@@ -0,0 +1,142 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++import org.eclipse.jetty.http.HttpTokens; ++ ++import static org.eclipse.jetty.http.compression.Huffman.CODES; ++import static org.eclipse.jetty.http.compression.Huffman.LCCODES; ++ ++/** ++ *Used to encode strings Huffman encoding.
++ * ++ *Characters are encoded with ISO-8859-1, if any multi-byte characters or ++ * control characters are present the encoder will throw {@link EncodingException}.
++ */ ++public class HuffmanEncoder ++{ ++ private HuffmanEncoder() ++ { ++ } ++ ++ /** ++ * @param s the string to encode. ++ * @return the number of octets needed to encode the string, or -1 if it cannot be encoded. ++ */ ++ public static int octetsNeeded(String s) ++ { ++ return octetsNeeded(CODES, s); ++ } ++ ++ /** ++ * @param b the byte array to encode. ++ * @return the number of octets needed to encode the bytes, or -1 if it cannot be encoded. ++ */ ++ public static int octetsNeeded(byte[] b) ++ { ++ int needed = 0; ++ for (byte value : b) ++ { ++ int c = 0xFF & value; ++ needed += CODES[c][1]; ++ } ++ return (needed + 7) / 8; ++ } ++ ++ /** ++ * @param buffer the buffer to encode into. ++ * @param s the string to encode. ++ */ ++ public static void encode(ByteBuffer buffer, String s) ++ { ++ encode(CODES, buffer, s); ++ } ++ ++ /** ++ * @param s the string to encode in lowercase. ++ * @return the number of octets needed to encode the string, or -1 if it cannot be encoded. ++ */ ++ public static int octetsNeededLowerCase(String s) ++ { ++ return octetsNeeded(LCCODES, s); ++ } ++ ++ /** ++ * @param buffer the buffer to encode into in lowercase. ++ * @param s the string to encode. ++ */ ++ public static void encodeLowerCase(ByteBuffer buffer, String s) ++ { ++ encode(LCCODES, buffer, s); ++ } ++ ++ private static int octetsNeeded(final int[][] table, String s) ++ { ++ int needed = 0; ++ int len = s.length(); ++ for (int i = 0; i < len; i++) ++ { ++ char c = s.charAt(i); ++ if (HttpTokens.isIllegalFieldVchar(c)) ++ return -1; ++ needed += table[c][1]; ++ } ++ ++ return (needed + 7) / 8; ++ } ++ ++ /** ++ * @param table The table to encode by ++ * @param buffer The buffer to encode to ++ * @param s The string to encode ++ */ ++ private static void encode(final int[][] table, ByteBuffer buffer, String s) ++ { ++ long current = 0; ++ int n = 0; ++ int len = s.length(); ++ for (int i = 0; i < len; i++) ++ { ++ char c = s.charAt(i); ++ if (HttpTokens.isIllegalFieldVchar(c)) ++ throw new IllegalArgumentException(); ++ int code = table[c][0]; ++ int bits = table[c][1]; ++ ++ current <<= bits; ++ current |= code; ++ n += bits; ++ ++ while (n >= 8) ++ { ++ n -= 8; ++ buffer.put((byte)(current >> n)); ++ } ++ } ++ ++ if (n > 0) ++ { ++ current <<= (8 - n); ++ current |= (0xFF >>> n); ++ buffer.put((byte)(current)); ++ } ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerDecoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerDecoder.java +new file mode 100644 +index 0000000..590b8c1 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerDecoder.java +@@ -0,0 +1,113 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++/** ++ * Used to decode integers as described in RFC7541. ++ */ ++public class NBitIntegerDecoder ++{ ++ private int _prefix; ++ private long _total; ++ private long _multiplier; ++ private boolean _started; ++ ++ /** ++ * Set the prefix length in of the integer representation in bits. ++ * A prefix of 6 means the integer representation starts after the first 2 bits. ++ * @param prefix the number of bits in the integer prefix. ++ */ ++ public void setPrefix(int prefix) ++ { ++ if (_started) ++ throw new IllegalStateException(); ++ _prefix = prefix; ++ } ++ ++ /** ++ * Decode an integer from the buffer. If the buffer does not contain the complete integer representation ++ * a value of -1 is returned to indicate that more data is needed to complete parsing. ++ * This should be only after the prefix has been set with {@link #setPrefix(int)}. ++ * @param buffer the buffer containing the encoded integer. ++ * @return the decoded integer or -1 to indicate that more data is needed. ++ * @throws ArithmeticException if the value overflows a int. ++ */ ++ public int decodeInt(ByteBuffer buffer) ++ { ++ return Math.toIntExact(decodeLong(buffer)); ++ } ++ ++ /** ++ * Decode a long from the buffer. If the buffer does not contain the complete integer representation ++ * a value of -1 is returned to indicate that more data is needed to complete parsing. ++ * This should be only after the prefix has been set with {@link #setPrefix(int)}. ++ * @param buffer the buffer containing the encoded integer. ++ * @return the decoded long or -1 to indicate that more data is needed. ++ * @throws ArithmeticException if the value overflows a long. ++ */ ++ public long decodeLong(ByteBuffer buffer) ++ { ++ if (!_started) ++ { ++ if (!buffer.hasRemaining()) ++ return -1; ++ ++ _started = true; ++ _multiplier = 1; ++ int nbits = 0xFF >>> (8 - _prefix); ++ _total = buffer.get() & nbits; ++ if (_total < nbits) ++ { ++ long total = _total; ++ reset(); ++ return total; ++ } ++ } ++ ++ while (true) ++ { ++ // If we have no more remaining we return -1 to indicate that more data is needed to continue parsing. ++ if (!buffer.hasRemaining()) ++ return -1; ++ ++ int b = buffer.get() & 0xFF; ++ _total = Math.addExact(_total, (b & 127) * _multiplier); ++ _multiplier = Math.multiplyExact(_multiplier, 128); ++ if ((b & 128) == 0) ++ { ++ long total = _total; ++ reset(); ++ return total; ++ } ++ } ++ } ++ ++ /** ++ * Reset the internal state of the parser. ++ */ ++ public void reset() ++ { ++ _prefix = 0; ++ _total = 0; ++ _multiplier = 1; ++ _started = false; ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerEncoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerEncoder.java +new file mode 100644 +index 0000000..f78440f +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitIntegerEncoder.java +@@ -0,0 +1,96 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++/** ++ * Used to encode integers as described in RFC7541. ++ */ ++public class NBitIntegerEncoder ++{ ++ private NBitIntegerEncoder() ++ { ++ } ++ ++ /** ++ * @param prefix the prefix used to encode this long. ++ * @param value the integer to encode. ++ * @return the number of octets it would take to encode the long. ++ */ ++ public static int octetsNeeded(int prefix, long value) ++ { ++ if (prefix <= 0 || prefix > 8) ++ throw new IllegalArgumentException(); ++ ++ int nbits = 0xFF >>> (8 - prefix); ++ value = value - nbits; ++ if (value < 0) ++ return 1; ++ if (value == 0) ++ return 2; ++ int lz = Long.numberOfLeadingZeros(value); ++ int log = 64 - lz; ++ ++ // The return value is 1 for the prefix + the number of 7-bit groups necessary to encode the value. ++ return 1 + (log + 6) / 7; ++ } ++ ++ /** ++ * ++ * @param buffer the buffer to encode into. ++ * @param prefix the prefix used to encode this long. ++ * @param value the long to encode into the buffer. ++ */ ++ public static void encode(ByteBuffer buffer, int prefix, long value) ++ { ++ if (prefix <= 0 || prefix > 8) ++ throw new IllegalArgumentException(); ++ ++ // If prefix is 8 we add an empty byte as we initially modify last byte from the buffer. ++ if (prefix == 8) ++ buffer.put((byte)0x00); ++ ++ int bits = 0xFF >>> (8 - prefix); ++ int p = buffer.position() - 1; ++ if (value < bits) ++ { ++ buffer.put(p, (byte)((buffer.get(p) & ~bits) | value)); ++ } ++ else ++ { ++ buffer.put(p, (byte)(buffer.get(p) | bits)); ++ long length = value - bits; ++ while (true) ++ { ++ // The value of ~0x7F is different to 0x80 because of all the 1s from the MSB. ++ if ((length & ~0x7FL) == 0) ++ { ++ buffer.put((byte)length); ++ return; ++ } ++ else ++ { ++ buffer.put((byte)((length & 0x7F) | 0x80)); ++ length >>>= 7; ++ } ++ } ++ } ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringDecoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringDecoder.java +new file mode 100644 +index 0000000..a871597 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringDecoder.java +@@ -0,0 +1,138 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++import org.eclipse.jetty.util.CharsetStringBuilder; ++ ++/** ++ *Used to decode string literals as described in RFC7541.
++ * ++ *The string literal representation consists of a single bit to indicate whether huffman encoding is used, ++ * followed by the string byte length encoded with the n-bit integer representation also from RFC7541, and ++ * the bytes of the string are directly after this.
++ * ++ *Characters which are illegal field-vchar values are replaced with ++ * either ' ' or '?' as described in RFC9110
++ */ ++public class NBitStringDecoder ++{ ++ private final NBitIntegerDecoder _integerDecoder; ++ private final HuffmanDecoder _huffmanBuilder; ++ private final CharsetStringBuilder.Iso88591StringBuilder _builder; ++ private boolean _huffman; ++ private int _count; ++ private int _length; ++ private int _prefix; ++ ++ private State _state = State.PARSING; ++ ++ private enum State ++ { ++ PARSING, ++ LENGTH, ++ VALUE ++ } ++ ++ public NBitStringDecoder() ++ { ++ _integerDecoder = new NBitIntegerDecoder(); ++ _huffmanBuilder = new HuffmanDecoder(); ++ _builder = new CharsetStringBuilder.Iso88591StringBuilder(); ++ } ++ ++ /** ++ * Set the prefix length in of the string representation in bits. ++ * A prefix of 6 means the string representation starts after the first 2 bits. ++ * @param prefix the number of bits in the string prefix. ++ */ ++ public void setPrefix(int prefix) ++ { ++ if (_state != State.PARSING) ++ throw new IllegalStateException(); ++ _prefix = prefix; ++ } ++ ++ /** ++ * Decode a string from the buffer. If the buffer does not contain the complete string representation ++ * then a value of null is returned to indicate that more data is needed to complete parsing. ++ * This should be only after the prefix has been set with {@link #setPrefix(int)}. ++ * @param buffer the buffer containing the encoded string. ++ * @return the decoded string or null to indicate that more data is needed. ++ * @throws ArithmeticException if the string length value overflows a int. ++ * @throws EncodingException if the string encoding is invalid. ++ */ ++ public String decode(ByteBuffer buffer) throws EncodingException ++ { ++ while (true) ++ { ++ switch (_state) ++ { ++ case PARSING: ++ byte firstByte = buffer.get(buffer.position()); ++ _huffman = ((0x80 >>> (8 - _prefix)) & firstByte) != 0; ++ _state = State.LENGTH; ++ _integerDecoder.setPrefix(_prefix - 1); ++ continue; ++ ++ case LENGTH: ++ _length = _integerDecoder.decodeInt(buffer); ++ if (_length < 0) ++ return null; ++ _state = State.VALUE; ++ _huffmanBuilder.setLength(_length); ++ continue; ++ ++ case VALUE: ++ String value = _huffman ? _huffmanBuilder.decode(buffer) : stringDecode(buffer); ++ if (value != null) ++ reset(); ++ return value; ++ ++ default: ++ throw new IllegalStateException(_state.name()); ++ } ++ } ++ } ++ ++ private String stringDecode(ByteBuffer buffer) ++ { ++ for (; _count < _length; _count++) ++ { ++ if (!buffer.hasRemaining()) ++ return null; ++ _builder.append(buffer.get()); ++ } ++ ++ return _builder.build(); ++ } ++ ++ public void reset() ++ { ++ _state = State.PARSING; ++ _integerDecoder.reset(); ++ _huffmanBuilder.reset(); ++ _builder.reset(); ++ _prefix = 0; ++ _count = 0; ++ _length = 0; ++ _huffman = false; ++ } ++} +diff --git a/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringEncoder.java b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringEncoder.java +new file mode 100644 +index 0000000..5729ec0 +--- /dev/null ++++ b/jetty-http/src/main/java/org/eclipse/jetty/http/compression/NBitStringEncoder.java +@@ -0,0 +1,82 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http.compression; ++ ++import java.nio.ByteBuffer; ++ ++import org.eclipse.jetty.http.HttpTokens; ++ ++public class NBitStringEncoder ++{ ++ private NBitStringEncoder() ++ { ++ } ++ ++ public static int octetsNeeded(int prefix, String value, boolean huffman) ++ { ++ if (prefix <= 0 || prefix > 8) ++ throw new IllegalArgumentException(); ++ ++ int contentPrefix = (prefix == 1) ? 8 : prefix - 1; ++ int encodedValueSize = huffman ? HuffmanEncoder.octetsNeeded(value) : value.length(); ++ int encodedLengthSize = NBitIntegerEncoder.octetsNeeded(contentPrefix, encodedValueSize); ++ ++ // If prefix was 1, then we count an extra byte needed for the prefix. ++ return encodedLengthSize + encodedValueSize + (prefix == 1 ? 1 : 0); ++ } ++ ++ public static void encode(ByteBuffer buffer, int prefix, String value, boolean huffman) ++ { ++ if (prefix <= 0 || prefix > 8) ++ throw new IllegalArgumentException(); ++ ++ byte huffmanFlag = huffman ? (byte)(0x01 << (prefix - 1)) : (byte)0x00; ++ if (prefix == 8) ++ { ++ buffer.put(huffmanFlag); ++ } ++ else ++ { ++ int p = buffer.position() - 1; ++ buffer.put(p, (byte)(buffer.get(p) | huffmanFlag)); ++ } ++ ++ // Start encoding size & content in rest of prefix. ++ // If prefix was 1 we set it back to 8 to indicate to start on a new byte. ++ prefix = (prefix == 1) ? 8 : prefix - 1; ++ ++ if (huffman) ++ { ++ int encodedValueSize = HuffmanEncoder.octetsNeeded(value); ++ NBitIntegerEncoder.encode(buffer, prefix, encodedValueSize); ++ HuffmanEncoder.encode(buffer, value); ++ } ++ else ++ { ++ int encodedValueSize = value.length(); ++ NBitIntegerEncoder.encode(buffer, prefix, encodedValueSize); ++ for (int i = 0; i < encodedValueSize; i++) ++ { ++ char c = value.charAt(i); ++ c = HttpTokens.sanitizeFieldVchar(c); ++ buffer.put((byte)c); ++ } ++ } ++ } ++} +diff --git a/jetty-http/src/test/java/org/eclipse/jetty/http/HuffmanTest.java b/jetty-http/src/test/java/org/eclipse/jetty/http/HuffmanTest.java +new file mode 100644 +index 0000000..e9e5ae8 +--- /dev/null ++++ b/jetty-http/src/test/java/org/eclipse/jetty/http/HuffmanTest.java +@@ -0,0 +1,168 @@ ++// ++// ======================================================================== ++// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. ++// ------------------------------------------------------------------------ ++// All rights reserved. This program and the accompanying materials ++// are made available under the terms of the Eclipse Public License v1.0 ++// and Apache License v2.0 which accompanies this distribution. ++// ++// The Eclipse Public License is available at ++// http://www.eclipse.org/legal/epl-v10.html ++// ++// The Apache License v2.0 is available at ++// http://www.opensource.org/licenses/apache2.0.php ++// ++// You may elect to redistribute this code under either of these licenses. ++// ======================================================================== ++// ++ ++package org.eclipse.jetty.http; ++ ++import java.nio.ByteBuffer; ++import java.util.Locale; ++import java.util.stream.Stream; ++ ++import org.eclipse.jetty.http.compression.EncodingException; ++import org.eclipse.jetty.http.compression.HuffmanDecoder; ++import org.eclipse.jetty.http.compression.HuffmanEncoder; ++import org.eclipse.jetty.util.BufferUtil; ++import org.eclipse.jetty.util.TypeUtil; ++import org.junit.jupiter.params.ParameterizedTest; ++import org.junit.jupiter.params.provider.Arguments; ++import org.junit.jupiter.params.provider.MethodSource; ++ ++import static org.hamcrest.MatcherAssert.assertThat; ++import static org.hamcrest.Matchers.equalTo; ++import static org.hamcrest.Matchers.greaterThan; ++import static org.junit.jupiter.api.Assertions.assertEquals; ++import static org.junit.jupiter.api.Assertions.assertThrows; ++ ++public class HuffmanTest ++{ ++ public static String decode(ByteBuffer buffer, int length) throws EncodingException ++ { ++ HuffmanDecoder huffmanDecoder = new HuffmanDecoder(); ++ huffmanDecoder.setLength(length); ++ String decoded = huffmanDecoder.decode(buffer); ++ if (decoded == null) ++ throw new EncodingException("invalid string encoding"); ++ ++ huffmanDecoder.reset(); ++ return decoded; ++ } ++ ++ public static StreamSets the limit for the encoder HPACK dynamic table capacity.
++ *Setting this value to {@code 0} disables the use of the dynamic table.
++ * ++ * @param maxEncoderTableCapacity The HPACK encoder dynamic table maximum capacity ++ */ ++ public void setMaxEncoderTableCapacity(int maxEncoderTableCapacity) ++ { ++ this.maxEncoderTableCapacity = maxEncoderTableCapacity; ++ } ++ ++ @ManagedAttribute("The HPACK decoder dynamic table maximum capacity") ++ public int getMaxDecoderTableCapacity() ++ { ++ return maxDecoderTableCapacity; ++ } ++ ++ public void setMaxDecoderTableCapacity(int maxDecoderTableCapacity) ++ { ++ this.maxDecoderTableCapacity = maxDecoderTableCapacity; ++ } ++ ++ @Deprecated + @ManagedAttribute("The HPACK dynamic table maximum size") + public int getMaxDynamicTableSize() + { +- return maxDynamicTableSize; ++ return getMaxDecoderTableCapacity(); + } + ++ @Deprecated + public void setMaxDynamicTableSize(int maxDynamicTableSize) + { +- this.maxDynamicTableSize = maxDynamicTableSize; ++ setMaxDecoderTableCapacity(maxDynamicTableSize); + } + + @ManagedAttribute("The max size of header block fragments") +@@ -407,6 +465,17 @@ public class HTTP2Client extends ContainerLifeCycle + this.maxHeaderBlockFragment = maxHeaderBlockFragment; + } + ++ @ManagedAttribute("The max size of response headers") ++ public int getMaxResponseHeadersSize() ++ { ++ return maxResponseHeadersSize; ++ } ++ ++ public void setMaxResponseHeadersSize(int maxResponseHeadersSize) ++ { ++ this.maxResponseHeadersSize = maxResponseHeadersSize; ++ } ++ + public void connect(InetSocketAddress address, Session.Listener listener, PromiseThe HTTP/2 specification requires that stream ids are monotonically increasing, +- * see https://tools.ietf.org/html/rfc7540#section-5.1.1.
++ * see RFC 7540, 5.1.1. + *This implementation uses a queue to atomically reserve a stream id and claim + * a slot in the queue; the slot is then assigned the entries to write.
+ *Concurrent threads push slots in the queue but only one thread flushes + * the slots, up to the slot that has a non-null entries to write, therefore + * guaranteeing that frames are sent strictly in their stream id order.
+ *This class also coordinates the creation of streams with the close of +- * the session, see https://tools.ietf.org/html/rfc7540#section-6.8.
++ * the session, see ++ * RFC 7540, 6.8. + */ + private class StreamsState + { +@@ -2168,7 +2220,7 @@ public abstract class HTTP2Session extends ContainerLifeCycle implements ISessio + if (flushing == null) + flushing = thread; + else if (flushing != thread) +- return; // another thread is flushing ++ return; // Another thread is flushing. + + Slot slot = slots.peek(); + entries = slot == null ? null : slot.entries; +@@ -2176,7 +2228,8 @@ public abstract class HTTP2Session extends ContainerLifeCycle implements ISessio + if (entries == null) + { + flushing = null; +- break; // No more slots or null entries, so we may iterate on the flusher ++ // No more slots or null entries, so we may iterate on the flusher. ++ break; + } + + slots.poll(); +diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/generator/Generator.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/generator/Generator.java +index 97f9aea..b4c3c27 100644 +--- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/generator/Generator.java ++++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/generator/Generator.java +@@ -35,15 +35,21 @@ public class Generator + + public Generator(ByteBufferPool byteBufferPool) + { +- this(byteBufferPool, 4096, 0); ++ this(byteBufferPool, 0); + } + ++ @Deprecated + public Generator(ByteBufferPool byteBufferPool, int maxDynamicTableSize, int maxHeaderBlockFragment) ++ { ++ this(byteBufferPool, maxHeaderBlockFragment); ++ } ++ ++ public Generator(ByteBufferPool byteBufferPool, int maxHeaderBlockFragment) + { + this.byteBufferPool = byteBufferPool; + + headerGenerator = new HeaderGenerator(); +- hpackEncoder = new HpackEncoder(maxDynamicTableSize); ++ hpackEncoder = new HpackEncoder(); + + this.generators = new FrameGenerator[FrameType.values().length]; + this.generators[FrameType.HEADERS.getType()] = new HeadersGenerator(headerGenerator, hpackEncoder, maxHeaderBlockFragment); +@@ -66,14 +72,21 @@ public class Generator + return byteBufferPool; + } + ++ public HpackEncoder getHpackEncoder() ++ { ++ return hpackEncoder; ++ } ++ ++ @Deprecated + public void setValidateHpackEncoding(boolean validateEncoding) + { +- hpackEncoder.setValidateEncoding(validateEncoding); ++ getHpackEncoder().setValidateEncoding(validateEncoding); + } + +- public void setHeaderTableSize(int headerTableSize) ++ @Deprecated ++ public void setHeaderTableSize(int maxTableSize) + { +- hpackEncoder.setRemoteMaxDynamicTableSize(headerTableSize); ++ getHpackEncoder().setTableCapacity(maxTableSize); + } + + public void setMaxFrameSize(int maxFrameSize) +@@ -91,8 +104,9 @@ public class Generator + return dataGenerator.generate(lease, frame, maxLength); + } + ++ @Deprecated + public void setMaxHeaderListSize(int value) + { +- hpackEncoder.setMaxHeaderListSize(value); ++ getHpackEncoder().setMaxHeaderListSize(value); + } + } +diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeaderBlockParser.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeaderBlockParser.java +index 48becb1..848864d 100644 +--- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeaderBlockParser.java ++++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeaderBlockParser.java +@@ -50,6 +50,11 @@ public class HeaderBlockParser + this.notifier = notifier; + } + ++ public int getMaxHeaderListSize() ++ { ++ return hpackDecoder.getMaxHeaderListSize(); ++ } ++ + /** + * Parses @{code blockLength} HPACK bytes from the given {@code buffer}. + * +diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeadersBodyParser.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeadersBodyParser.java +index e222420..909d49f 100644 +--- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeadersBodyParser.java ++++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/HeadersBodyParser.java +@@ -194,6 +194,10 @@ public class HeadersBodyParser extends BodyParser + { + if (hasFlag(Flags.END_HEADERS)) + { ++ int maxLength = headerBlockParser.getMaxHeaderListSize(); ++ if (maxLength > 0 && length > maxLength) ++ return connectionFailure(buffer, ErrorCode.REFUSED_STREAM_ERROR.code, "invalid_headers_frame"); ++ + MetaData metaData = headerBlockParser.parse(buffer, length); + if (metaData == HeaderBlockParser.SESSION_FAILURE) + return false; +diff --git a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/Parser.java b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/Parser.java +index 5e2dfd0..1d727f7 100644 +--- a/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/Parser.java ++++ b/jetty-http2/http2-common/src/main/java/org/eclipse/jetty/http2/parser/Parser.java +@@ -49,33 +49,47 @@ public class Parser + private static final Logger LOG = Log.getLogger(Parser.class); + + private final ByteBufferPool byteBufferPool; +- private final Listener listener; + private final HeaderParser headerParser; + private final HpackDecoder hpackDecoder; + private final BodyParser[] bodyParsers; ++ private Listener listener; + private UnknownBodyParser unknownBodyParser; +- private int maxFrameLength = Frame.DEFAULT_MAX_LENGTH; ++ private int maxFrameSize = Frame.DEFAULT_MAX_LENGTH; + private int maxSettingsKeys = SettingsFrame.DEFAULT_MAX_KEYS; + private boolean continuation; + private State state = State.HEADER; + ++ @Deprecated + public Parser(ByteBufferPool byteBufferPool, Listener listener, int maxDynamicTableSize, int maxHeaderSize) + { +- this(byteBufferPool, listener, maxDynamicTableSize, maxHeaderSize, RateControl.NO_RATE_CONTROL); ++ this(byteBufferPool, maxHeaderSize, RateControl.NO_RATE_CONTROL); + } + +- public Parser(ByteBufferPool byteBufferPool, Listener listener, int maxDynamicTableSize, int maxHeaderSize, RateControl rateControl) ++ public Parser(ByteBufferPool byteBufferPool, int maxHeaderSize) ++ { ++ this(byteBufferPool, maxHeaderSize, RateControl.NO_RATE_CONTROL); ++ } ++ ++ public Parser(ByteBufferPool byteBufferPool, int maxHeaderSize, RateControl rateControl) + { + this.byteBufferPool = byteBufferPool; +- this.listener = listener; + this.headerParser = new HeaderParser(rateControl == null ? RateControl.NO_RATE_CONTROL : rateControl); +- this.hpackDecoder = new HpackDecoder(maxDynamicTableSize, maxHeaderSize); ++ this.hpackDecoder = new HpackDecoder(maxHeaderSize); + this.bodyParsers = new BodyParser[FrameType.values().length]; + } + ++ @Deprecated + public void init(UnaryOperatorSets the limit for the capacity of the dynamic header table.
++ *This value acts as a limit for the values received from the ++ * remote peer via the HPACK dynamic table size update instruction.
++ *After calling this method, a SETTINGS frame must be sent to the other ++ * peer, containing the {@code SETTINGS_HEADER_TABLE_SIZE} setting with ++ * the value passed as argument to this method.
++ * ++ * @param maxTableCapacity the limit for capacity of the dynamic header table ++ */ ++ public void setMaxTableCapacity(int maxTableCapacity) ++ { ++ _maxTableCapacity = maxTableCapacity; ++ } ++ ++ /** ++ * @param maxTableSizeLimit the local dynamic table max size ++ * @deprecated use {@link #setMaxTableCapacity(int)} instead ++ */ ++ @Deprecated ++ public void setLocalMaxDynamicTableSize(int maxTableSizeLimit) ++ { ++ setMaxTableCapacity(maxTableSizeLimit); ++ } ++ ++ public int getMaxHeaderListSize() ++ { ++ return _builder.getMaxSize(); ++ } ++ ++ public void setMaxHeaderListSize(int maxHeaderListSize) + { +- _localMaxDynamicTableSize = localMaxdynamciTableSize; ++ _builder.setMaxSize(maxHeaderListSize); + } + + public MetaData decode(ByteBuffer buffer) throws HpackException.SessionException, HpackException.StreamException +@@ -69,27 +118,22 @@ public class HpackDecoder + if (LOG.isDebugEnabled()) + LOG.debug(String.format("CtxTbl[%x] decoding %d octets", _context.hashCode(), buffer.remaining())); + +- // If the buffer is big, don't even think about decoding it +- if (buffer.remaining() > _builder.getMaxSize()) +- throw new HpackException.SessionException("431 Request Header Fields too large"); ++ // If the buffer is larger than the max headers size, don't even start decoding it. ++ int maxSize = _builder.getMaxSize(); ++ if (maxSize > 0 && buffer.remaining() > maxSize) ++ throw new HpackException.SessionException("Header fields size too large"); + + boolean emitted = false; +- + while (buffer.hasRemaining()) + { +- if (LOG.isDebugEnabled() && buffer.hasArray()) +- { +- int l = Math.min(buffer.remaining(), 32); +- LOG.debug("decode {}{}", +- TypeUtil.toHexString(buffer.array(), buffer.arrayOffset() + buffer.position(), l), +- l < buffer.remaining() ? "..." : ""); +- } ++ if (LOG.isDebugEnabled()) ++ LOG.debug("decode {}", BufferUtil.toHexString(buffer)); + + byte b = buffer.get(); + if (b < 0) + { + // 7.1 indexed if the high bit is set +- int index = NBitInteger.decode(buffer, 7); ++ int index = integerDecode(buffer, 7); + Entry entry = _context.get(index); + if (entry == null) + throw new HpackException.SessionException("Unknown index %d", index); +@@ -130,11 +174,11 @@ public class HpackDecoder + case 2: // 7.3 + case 3: // 7.3 + // change table size +- int size = NBitInteger.decode(buffer, 5); ++ int size = integerDecode(buffer, 5); + if (LOG.isDebugEnabled()) +- LOG.debug("decode resize=" + size); +- if (size > _localMaxDynamicTableSize) +- throw new IllegalArgumentException(); ++ LOG.debug("decode resize={}", size); ++ if (size > getMaxTableCapacity()) ++ throw new HpackException.CompressionException("Dynamic table resize exceeded max limit"); + if (emitted) + throw new HpackException.CompressionException("Dynamic table resize after fields"); + _context.resize(size); +@@ -143,7 +187,7 @@ public class HpackDecoder + case 0: // 7.2.2 + case 1: // 7.2.3 + indexed = false; +- nameIndex = NBitInteger.decode(buffer, 4); ++ nameIndex = integerDecode(buffer, 4); + break; + + case 4: // 7.2.1 +@@ -151,7 +195,7 @@ public class HpackDecoder + case 6: // 7.2.1 + case 7: // 7.2.1 + indexed = true; +- nameIndex = NBitInteger.decode(buffer, 6); ++ nameIndex = integerDecode(buffer, 6); + break; + + default: +@@ -170,12 +214,11 @@ public class HpackDecoder + else + { + huffmanName = (buffer.get() & 0x80) == 0x80; +- int length = NBitInteger.decode(buffer, 7); +- _builder.checkSize(length, huffmanName); ++ int length = integerDecode(buffer, 7); + if (huffmanName) +- name = Huffman.decode(buffer, length); ++ name = huffmanDecode(buffer, length); + else +- name = toASCIIString(buffer, length); ++ name = toISO88591String(buffer, length); + check: + for (int i = name.length(); i-- > 0; ) + { +@@ -211,12 +254,11 @@ public class HpackDecoder + + // decode the value + boolean huffmanValue = (buffer.get() & 0x80) == 0x80; +- int length = NBitInteger.decode(buffer, 7); +- _builder.checkSize(length, huffmanValue); ++ int length = integerDecode(buffer, 7); + if (huffmanValue) +- value = Huffman.decode(buffer, length); ++ value = huffmanDecode(buffer, length); + else +- value = toASCIIString(buffer, length); ++ value = toISO88591String(buffer, length); + + // Make the new field + HttpField field; +@@ -277,19 +319,61 @@ public class HpackDecoder + return _builder.build(); + } + +- public static String toASCIIString(ByteBuffer buffer, int length) ++ private int integerDecode(ByteBuffer buffer, int prefix) throws HpackException.CompressionException ++ { ++ try ++ { ++ if (prefix != 8) ++ buffer.position(buffer.position() - 1); ++ ++ _integerDecoder.setPrefix(prefix); ++ int decodedInt = _integerDecoder.decodeInt(buffer); ++ if (decodedInt < 0) ++ throw new EncodingException("invalid integer encoding"); ++ return decodedInt; ++ } ++ catch (EncodingException e) ++ { ++ HpackException.CompressionException compressionException = new HpackException.CompressionException(e.getMessage()); ++ compressionException.initCause(e); ++ throw compressionException; ++ } ++ finally ++ { ++ _integerDecoder.reset(); ++ } ++ } ++ ++ private String huffmanDecode(ByteBuffer buffer, int length) throws HpackException.CompressionException ++ { ++ try ++ { ++ _huffmanDecoder.setLength(length); ++ String decoded = _huffmanDecoder.decode(buffer); ++ if (decoded == null) ++ throw new HpackException.CompressionException("invalid string encoding"); ++ return decoded; ++ } ++ catch (EncodingException e) ++ { ++ HpackException.CompressionException compressionException = new HpackException.CompressionException(e.getMessage()); ++ compressionException.initCause(e); ++ throw compressionException; ++ } ++ finally ++ { ++ _huffmanDecoder.reset(); ++ } ++ } ++ ++ public static String toISO88591String(ByteBuffer buffer, int length) + { +- StringBuilder builder = new StringBuilder(length); +- int position = buffer.position(); +- int start = buffer.arrayOffset() + position; +- int end = start + length; +- buffer.position(position + length); +- byte[] array = buffer.array(); +- for (int i = start; i < end; i++) ++ CharsetStringBuilder.Iso88591StringBuilder builder = new CharsetStringBuilder.Iso88591StringBuilder(); ++ for (int i = 0; i < length; ++i) + { +- builder.append((char)(0x7f & array[i])); ++ builder.append(HttpTokens.sanitizeFieldVchar((char)buffer.get())); + } +- return builder.toString(); ++ return builder.build(); + } + + @Override +diff --git a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackEncoder.java b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackEncoder.java +index 1011252..cb68bad 100644 +--- a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackEncoder.java ++++ b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackEncoder.java +@@ -19,7 +19,6 @@ + package org.eclipse.jetty.http2.hpack; + + import java.nio.ByteBuffer; +-import java.nio.charset.StandardCharsets; + import java.util.EnumMap; + import java.util.EnumSet; + import java.util.HashSet; +@@ -34,10 +33,13 @@ import org.eclipse.jetty.http.HttpStatus; + import org.eclipse.jetty.http.HttpVersion; + import org.eclipse.jetty.http.MetaData; + import org.eclipse.jetty.http.PreEncodedHttpField; ++import org.eclipse.jetty.http.compression.HuffmanEncoder; ++import org.eclipse.jetty.http.compression.NBitIntegerEncoder; ++import org.eclipse.jetty.http.compression.NBitStringEncoder; + import org.eclipse.jetty.http2.hpack.HpackContext.Entry; + import org.eclipse.jetty.http2.hpack.HpackContext.StaticEntry; ++import org.eclipse.jetty.util.BufferUtil; + import org.eclipse.jetty.util.StringUtil; +-import org.eclipse.jetty.util.TypeUtil; + import org.eclipse.jetty.util.log.Log; + import org.eclipse.jetty.util.log.Logger; + +@@ -97,34 +99,78 @@ public class HpackEncoder + + private final HpackContext _context; + private final boolean _debug; +- private int _remoteMaxDynamicTableSize; +- private int _localMaxDynamicTableSize; ++ private int _maxTableCapacity; ++ private int _tableCapacity; + private int _maxHeaderListSize; + private int _headerListSize; + private boolean _validateEncoding = true; + +- public HpackEncoder() +- { +- this(4096, 4096, -1); +- } +- ++ @Deprecated + public HpackEncoder(int localMaxDynamicTableSize) + { + this(localMaxDynamicTableSize, 4096, -1); + } + ++ @Deprecated + public HpackEncoder(int localMaxDynamicTableSize, int remoteMaxDynamicTableSize) + { + this(localMaxDynamicTableSize, remoteMaxDynamicTableSize, -1); + } + ++ @Deprecated + public HpackEncoder(int localMaxDynamicTableSize, int remoteMaxDynamicTableSize, int maxHeaderListSize) + { +- _context = new HpackContext(remoteMaxDynamicTableSize); +- _remoteMaxDynamicTableSize = remoteMaxDynamicTableSize; +- _localMaxDynamicTableSize = localMaxDynamicTableSize; +- _maxHeaderListSize = maxHeaderListSize; ++ this(); ++ setLocalMaxDynamicTableSize(localMaxDynamicTableSize); ++ setRemoteMaxDynamicTableSize(remoteMaxDynamicTableSize); ++ setMaxHeaderListSize(maxHeaderListSize); ++ } ++ ++ public HpackEncoder() ++ { ++ _context = new HpackContext(0); + _debug = LOG.isDebugEnabled(); ++ setMaxTableCapacity(HpackContext.DEFAULT_MAX_TABLE_CAPACITY); ++ setTableCapacity(HpackContext.DEFAULT_MAX_TABLE_CAPACITY); ++ } ++ ++ public int getMaxTableCapacity() ++ { ++ return _maxTableCapacity; ++ } ++ ++ /** ++ *Sets the limit for the capacity of the dynamic header table.
++ *This value is set by the remote peer via the ++ * {@code SETTINGS_HEADER_TABLE_SIZE} setting.
++ * ++ * @param maxTableSizeLimit the limit for capacity of the dynamic header table ++ */ ++ public void setMaxTableCapacity(int maxTableSizeLimit) ++ { ++ _maxTableCapacity = maxTableSizeLimit; ++ } ++ ++ public int getTableCapacity() ++ { ++ return _tableCapacity; ++ } ++ ++ /** ++ *Sets the capacity of the dynamic header table.
++ *The value of the capacity may be changed from {@code 0} ++ * up to {@link #getMaxTableCapacity()}. ++ * An HPACK instruction with the new capacity value will ++ * be sent to the decoder when the next call to ++ * {@link #encode(ByteBuffer, MetaData)} is made.
++ * ++ * @param tableCapacity the capacity of the dynamic header table ++ */ ++ public void setTableCapacity(int tableCapacity) ++ { ++ if (tableCapacity > getMaxTableCapacity()) ++ throw new IllegalArgumentException("Max table capacity exceeded"); ++ _tableCapacity = tableCapacity; + } + + public int getMaxHeaderListSize() +@@ -142,14 +188,16 @@ public class HpackEncoder + return _context; + } + +- public void setRemoteMaxDynamicTableSize(int remoteMaxDynamicTableSize) ++ @Deprecated ++ public void setRemoteMaxDynamicTableSize(int maxTableSize) + { +- _remoteMaxDynamicTableSize = remoteMaxDynamicTableSize; ++ setTableCapacity(maxTableSize); + } + +- public void setLocalMaxDynamicTableSize(int localMaxDynamicTableSize) ++ @Deprecated ++ public void setLocalMaxDynamicTableSize(int maxTableSizeLimit) + { +- _localMaxDynamicTableSize = localMaxDynamicTableSize; ++ setMaxTableCapacity(maxTableSizeLimit); + } + + public boolean isValidateEncoding() +@@ -185,10 +233,10 @@ public class HpackEncoder + _headerListSize = 0; + int pos = buffer.position(); + +- // Check the dynamic table sizes! +- int maxDynamicTableSize = Math.min(_remoteMaxDynamicTableSize, _localMaxDynamicTableSize); +- if (maxDynamicTableSize != _context.getMaxDynamicTableSize()) +- encodeMaxDynamicTableSize(buffer, maxDynamicTableSize); ++ // If max table size changed, send the correspondent instruction. ++ int tableCapacity = getTableCapacity(); ++ if (tableCapacity != _context.getMaxDynamicTableSize()) ++ encodeMaxDynamicTableSize(buffer, tableCapacity); + + // Add Request/response meta fields + if (metadata.isRequest()) +@@ -255,13 +303,9 @@ public class HpackEncoder + } + } + +- // Check size +- if (_maxHeaderListSize > 0 && _headerListSize > _maxHeaderListSize) +- { +- LOG.warn("Header list size too large {} > {} for {}", _headerListSize, _maxHeaderListSize); +- if (LOG.isDebugEnabled()) +- LOG.debug("metadata={}", metadata); +- } ++ int maxHeaderListSize = getMaxHeaderListSize(); ++ if (maxHeaderListSize > 0 && _headerListSize > maxHeaderListSize) ++ throw new HpackException.SessionException("Header size %d > %d", _headerListSize, maxHeaderListSize); + + if (LOG.isDebugEnabled()) + LOG.debug(String.format("CtxTbl[%x] encoded %d octets", _context.hashCode(), buffer.position() - pos)); +@@ -278,13 +322,11 @@ public class HpackEncoder + } + } + +- public void encodeMaxDynamicTableSize(ByteBuffer buffer, int maxDynamicTableSize) ++ public void encodeMaxDynamicTableSize(ByteBuffer buffer, int maxTableSize) + { +- if (maxDynamicTableSize > _remoteMaxDynamicTableSize) +- throw new IllegalArgumentException(); + buffer.put((byte)0x20); +- NBitInteger.encode(buffer, 5, maxDynamicTableSize); +- _context.resize(maxDynamicTableSize); ++ NBitIntegerEncoder.encode(buffer, 5, maxTableSize); ++ _context.resize(maxTableSize); + } + + public void encode(ByteBuffer buffer, HttpField field) +@@ -295,8 +337,6 @@ public class HpackEncoder + int fieldSize = field.getName().length() + field.getValue().length(); + _headerListSize += fieldSize + 32; + +- final int p = _debug ? buffer.position() : -1; +- + String encoding = null; + + // Is there an index entry for the field? +@@ -314,9 +354,9 @@ public class HpackEncoder + { + int index = _context.index(entry); + buffer.put((byte)0x80); +- NBitInteger.encode(buffer, 7, index); ++ NBitIntegerEncoder.encode(buffer, 7, index); + if (_debug) +- encoding = "IdxField" + (entry.isStatic() ? "S" : "") + (1 + NBitInteger.octectsNeeded(7, index)); ++ encoding = "IdxField" + (entry.isStatic() ? "S" : "") + NBitIntegerEncoder.octetsNeeded(7, index); + } + } + else +@@ -390,19 +430,19 @@ public class HpackEncoder + + if (_debug) + encoding = "Lit" + +- ((name == null) ? "HuffN" : ("IdxN" + (name.isStatic() ? "S" : "") + (1 + NBitInteger.octectsNeeded(4, _context.index(name))))) + ++ ((name == null) ? "HuffN" : ("IdxN" + (name.isStatic() ? "S" : "") + (1 + NBitIntegerEncoder.octetsNeeded(4, _context.index(name))))) + + (huffman ? "HuffV" : "LitV") + + (neverIndex ? "!!Idx" : "!Idx"); + } + else if (fieldSize >= _context.getMaxDynamicTableSize() || header == HttpHeader.CONTENT_LENGTH && !"0".equals(field.getValue())) + { +- // The field is too large or a non zero content length, so do not index. ++ // The field is too large or a non-zero content length, so do not index. + indexed = false; + encodeName(buffer, (byte)0x00, 4, header.asString(), name); + encodeValue(buffer, true, field.getValue()); + if (_debug) + encoding = "Lit" + +- ((name == null) ? "HuffN" : "IdxNS" + (1 + NBitInteger.octectsNeeded(4, _context.index(name)))) + ++ ((name == null) ? "HuffN" : "IdxNS" + (1 + NBitIntegerEncoder.octetsNeeded(4, _context.index(name)))) + + "HuffV!Idx"; + } + else +@@ -413,7 +453,7 @@ public class HpackEncoder + encodeName(buffer, (byte)0x40, 6, header.asString(), name); + encodeValue(buffer, huffman, field.getValue()); + if (_debug) +- encoding = ((name == null) ? "LitHuffN" : ("LitIdxN" + (name.isStatic() ? "S" : "") + (1 + NBitInteger.octectsNeeded(6, _context.index(name))))) + ++ encoding = ((name == null) ? "LitHuffN" : ("LitIdxN" + (name.isStatic() ? "S" : "") + (1 + NBitIntegerEncoder.octetsNeeded(6, _context.index(name))))) + + (huffman ? "HuffVIdx" : "LitVIdx"); + } + } +@@ -425,10 +465,8 @@ public class HpackEncoder + + if (_debug) + { +- byte[] bytes = new byte[buffer.position() - p]; +- buffer.position(p); +- buffer.get(bytes); +- LOG.debug("encode {}:'{}' to '{}'", encoding, field, TypeUtil.toHexString(bytes)); ++ if (LOG.isDebugEnabled()) ++ LOG.debug("encode {}:'{}' to '{}'", encoding, field, BufferUtil.toHexString((ByteBuffer)buffer.duplicate().flip())); + } + } + +@@ -440,55 +478,17 @@ public class HpackEncoder + // leave name index bits as 0 + // Encode the name always with lowercase huffman + buffer.put((byte)0x80); +- NBitInteger.encode(buffer, 7, Huffman.octetsNeededLC(name)); +- Huffman.encodeLC(buffer, name); ++ NBitIntegerEncoder.encode(buffer, 7, HuffmanEncoder.octetsNeededLowerCase(name)); ++ HuffmanEncoder.encodeLowerCase(buffer, name); + } + else + { +- NBitInteger.encode(buffer, bits, _context.index(entry)); ++ NBitIntegerEncoder.encode(buffer, bits, _context.index(entry)); + } + } + + static void encodeValue(ByteBuffer buffer, boolean huffman, String value) + { +- if (huffman) +- { +- // huffman literal value +- buffer.put((byte)0x80); +- +- int needed = Huffman.octetsNeeded(value); +- if (needed >= 0) +- { +- NBitInteger.encode(buffer, 7, needed); +- Huffman.encode(buffer, value); +- } +- else +- { +- // Not iso_8859_1 +- byte[] bytes = value.getBytes(StandardCharsets.UTF_8); +- NBitInteger.encode(buffer, 7, Huffman.octetsNeeded(bytes)); +- Huffman.encode(buffer, bytes); +- } +- } +- else +- { +- // add literal assuming iso_8859_1 +- buffer.put((byte)0x00).mark(); +- NBitInteger.encode(buffer, 7, value.length()); +- for (int i = 0; i < value.length(); i++) +- { +- char c = value.charAt(i); +- if (c < ' ' || c > 127) +- { +- // Not iso_8859_1, so re-encode as UTF-8 +- buffer.reset(); +- byte[] bytes = value.getBytes(StandardCharsets.UTF_8); +- NBitInteger.encode(buffer, 7, bytes.length); +- buffer.put(bytes, 0, bytes.length); +- return; +- } +- buffer.put((byte)c); +- } +- } ++ NBitStringEncoder.encode(buffer, 8, value, huffman); + } + } +diff --git a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackException.java b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackException.java +index 2aad122..df89d80 100644 +--- a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackException.java ++++ b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackException.java +@@ -18,7 +18,6 @@ + + package org.eclipse.jetty.http2.hpack; + +-@SuppressWarnings("serial") + public abstract class HpackException extends Exception + { + HpackException(String messageFormat, Object... args) +@@ -35,7 +34,7 @@ public abstract class HpackException extends Exception + */ + public static class StreamException extends HpackException + { +- StreamException(String messageFormat, Object... args) ++ public StreamException(String messageFormat, Object... args) + { + super(messageFormat, args); + } +@@ -48,7 +47,7 @@ public abstract class HpackException extends Exception + */ + public static class SessionException extends HpackException + { +- SessionException(String messageFormat, Object... args) ++ public SessionException(String messageFormat, Object... args) + { + super(messageFormat, args); + } +diff --git a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackFieldPreEncoder.java b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackFieldPreEncoder.java +index 769819d..629ef2c 100644 +--- a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackFieldPreEncoder.java ++++ b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/HpackFieldPreEncoder.java +@@ -23,6 +23,8 @@ import java.nio.ByteBuffer; + import org.eclipse.jetty.http.HttpFieldPreEncoder; + import org.eclipse.jetty.http.HttpHeader; + import org.eclipse.jetty.http.HttpVersion; ++import org.eclipse.jetty.http.compression.HuffmanEncoder; ++import org.eclipse.jetty.http.compression.NBitIntegerEncoder; + import org.eclipse.jetty.util.BufferUtil; + + /** +@@ -31,18 +33,12 @@ import org.eclipse.jetty.util.BufferUtil; + public class HpackFieldPreEncoder implements HttpFieldPreEncoder + { + +- /** +- * @see org.eclipse.jetty.http.HttpFieldPreEncoder#getHttpVersion() +- */ + @Override + public HttpVersion getHttpVersion() + { + return HttpVersion.HTTP_2; + } + +- /** +- * @see org.eclipse.jetty.http.HttpFieldPreEncoder#getEncodedField(org.eclipse.jetty.http.HttpHeader, java.lang.String, java.lang.String) +- */ + @Override + public byte[] getEncodedField(HttpHeader header, String name, String value) + { +@@ -78,12 +74,12 @@ public class HpackFieldPreEncoder implements HttpFieldPreEncoder + + int nameIdx = HpackContext.staticIndex(header); + if (nameIdx > 0) +- NBitInteger.encode(buffer, bits, nameIdx); ++ NBitIntegerEncoder.encode(buffer, bits, nameIdx); + else + { + buffer.put((byte)0x80); +- NBitInteger.encode(buffer, 7, Huffman.octetsNeededLC(name)); +- Huffman.encodeLC(buffer, name); ++ NBitIntegerEncoder.encode(buffer, 7, HuffmanEncoder.octetsNeededLowerCase(name)); ++ HuffmanEncoder.encodeLowerCase(buffer, name); + } + + HpackEncoder.encodeValue(buffer, huffman, value); +diff --git a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/Huffman.java b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/Huffman.java +deleted file mode 100644 +index 26e948b..0000000 +--- a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/Huffman.java ++++ /dev/null +@@ -1,551 +0,0 @@ +-// +-// ======================================================================== +-// Copyright (c) 1995-2022 Mort Bay Consulting Pty Ltd and others. +-// ------------------------------------------------------------------------ +-// All rights reserved. This program and the accompanying materials +-// are made available under the terms of the Eclipse Public License v1.0 +-// and Apache License v2.0 which accompanies this distribution. +-// +-// The Eclipse Public License is available at +-// http://www.eclipse.org/legal/epl-v10.html +-// +-// The Apache License v2.0 is available at +-// http://www.opensource.org/licenses/apache2.0.php +-// +-// You may elect to redistribute this code under either of these licenses. +-// ======================================================================== +-// +- +-package org.eclipse.jetty.http2.hpack; +- +-import java.nio.ByteBuffer; +- +-import org.eclipse.jetty.util.Utf8StringBuilder; +- +-public class Huffman +-{ +- +- // Appendix C: Huffman Codes +- // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C +- static final int[][] CODES = +- { +- /* ( 0) |11111111|11000 */ {0x1ff8, 13}, +- /* ( 1) |11111111|11111111|1011000 */ {0x7fffd8, 23}, +- /* ( 2) |11111111|11111111|11111110|0010 */ {0xfffffe2, 28}, +- /* ( 3) |11111111|11111111|11111110|0011 */ {0xfffffe3, 28}, +- /* ( 4) |11111111|11111111|11111110|0100 */ {0xfffffe4, 28}, +- /* ( 5) |11111111|11111111|11111110|0101 */ {0xfffffe5, 28}, +- /* ( 6) |11111111|11111111|11111110|0110 */ {0xfffffe6, 28}, +- /* ( 7) |11111111|11111111|11111110|0111 */ {0xfffffe7, 28}, +- /* ( 8) |11111111|11111111|11111110|1000 */ {0xfffffe8, 28}, +- /* ( 9) |11111111|11111111|11101010 */ {0xffffea, 24}, +- /* ( 10) |11111111|11111111|11111111|111100 */ {0x3ffffffc, 30}, +- /* ( 11) |11111111|11111111|11111110|1001 */ {0xfffffe9, 28}, +- /* ( 12) |11111111|11111111|11111110|1010 */ {0xfffffea, 28}, +- /* ( 13) |11111111|11111111|11111111|111101 */ {0x3ffffffd, 30}, +- /* ( 14) |11111111|11111111|11111110|1011 */ {0xfffffeb, 28}, +- /* ( 15) |11111111|11111111|11111110|1100 */ {0xfffffec, 28}, +- /* ( 16) |11111111|11111111|11111110|1101 */ {0xfffffed, 28}, +- /* ( 17) |11111111|11111111|11111110|1110 */ {0xfffffee, 28}, +- /* ( 18) |11111111|11111111|11111110|1111 */ {0xfffffef, 28}, +- /* ( 19) |11111111|11111111|11111111|0000 */ {0xffffff0, 28}, +- /* ( 20) |11111111|11111111|11111111|0001 */ {0xffffff1, 28}, +- /* ( 21) |11111111|11111111|11111111|0010 */ {0xffffff2, 28}, +- /* ( 22) |11111111|11111111|11111111|111110 */ {0x3ffffffe, 30}, +- /* ( 23) |11111111|11111111|11111111|0011 */ {0xffffff3, 28}, +- /* ( 24) |11111111|11111111|11111111|0100 */ {0xffffff4, 28}, +- /* ( 25) |11111111|11111111|11111111|0101 */ {0xffffff5, 28}, +- /* ( 26) |11111111|11111111|11111111|0110 */ {0xffffff6, 28}, +- /* ( 27) |11111111|11111111|11111111|0111 */ {0xffffff7, 28}, +- /* ( 28) |11111111|11111111|11111111|1000 */ {0xffffff8, 28}, +- /* ( 29) |11111111|11111111|11111111|1001 */ {0xffffff9, 28}, +- /* ( 30) |11111111|11111111|11111111|1010 */ {0xffffffa, 28}, +- /* ( 31) |11111111|11111111|11111111|1011 */ {0xffffffb, 28}, +- /*' ' ( 32) |010100 */ {0x14, 6}, +- /*'!' ( 33) |11111110|00 */ {0x3f8, 10}, +- /*'"' ( 34) |11111110|01 */ {0x3f9, 10}, +- /*'#' ( 35) |11111111|1010 */ {0xffa, 12}, +- /*'$' ( 36) |11111111|11001 */ {0x1ff9, 13}, +- /*'%' ( 37) |010101 */ {0x15, 6}, +- /*'&' ( 38) |11111000 */ {0xf8, 8}, +- /*''' ( 39) |11111111|010 */ {0x7fa, 11}, +- /*'(' ( 40) |11111110|10 */ {0x3fa, 10}, +- /*')' ( 41) |11111110|11 */ {0x3fb, 10}, +- /*'*' ( 42) |11111001 */ {0xf9, 8}, +- /*'+' ( 43) |11111111|011 */ {0x7fb, 11}, +- /*',' ( 44) |11111010 */ {0xfa, 8}, +- /*'-' ( 45) |010110 */ {0x16, 6}, +- /*'.' ( 46) |010111 */ {0x17, 6}, +- /*'/' ( 47) |011000 */ {0x18, 6}, +- /*'0' ( 48) |00000 */ {0x0, 5}, +- /*'1' ( 49) |00001 */ {0x1, 5}, +- /*'2' ( 50) |00010 */ {0x2, 5}, +- /*'3' ( 51) |011001 */ {0x19, 6}, +- /*'4' ( 52) |011010 */ {0x1a, 6}, +- /*'5' ( 53) |011011 */ {0x1b, 6}, +- /*'6' ( 54) |011100 */ {0x1c, 6}, +- /*'7' ( 55) |011101 */ {0x1d, 6}, +- /*'8' ( 56) |011110 */ {0x1e, 6}, +- /*'9' ( 57) |011111 */ {0x1f, 6}, +- /*':' ( 58) |1011100 */ {0x5c, 7}, +- /*';' ( 59) |11111011 */ {0xfb, 8}, +- /*'<' ( 60) |11111111|1111100 */ {0x7ffc, 15}, +- /*'=' ( 61) |100000 */ {0x20, 6}, +- /*'>' ( 62) |11111111|1011 */ {0xffb, 12}, +- /*'?' ( 63) |11111111|00 */ {0x3fc, 10}, +- /*'@' ( 64) |11111111|11010 */ {0x1ffa, 13}, +- /*'A' ( 65) |100001 */ {0x21, 6}, +- /*'B' ( 66) |1011101 */ {0x5d, 7}, +- /*'C' ( 67) |1011110 */ {0x5e, 7}, +- /*'D' ( 68) |1011111 */ {0x5f, 7}, +- /*'E' ( 69) |1100000 */ {0x60, 7}, +- /*'F' ( 70) |1100001 */ {0x61, 7}, +- /*'G' ( 71) |1100010 */ {0x62, 7}, +- /*'H' ( 72) |1100011 */ {0x63, 7}, +- /*'I' ( 73) |1100100 */ {0x64, 7}, +- /*'J' ( 74) |1100101 */ {0x65, 7}, +- /*'K' ( 75) |1100110 */ {0x66, 7}, +- /*'L' ( 76) |1100111 */ {0x67, 7}, +- /*'M' ( 77) |1101000 */ {0x68, 7}, +- /*'N' ( 78) |1101001 */ {0x69, 7}, +- /*'O' ( 79) |1101010 */ {0x6a, 7}, +- /*'P' ( 80) |1101011 */ {0x6b, 7}, +- /*'Q' ( 81) |1101100 */ {0x6c, 7}, +- /*'R' ( 82) |1101101 */ {0x6d, 7}, +- /*'S' ( 83) |1101110 */ {0x6e, 7}, +- /*'T' ( 84) |1101111 */ {0x6f, 7}, +- /*'U' ( 85) |1110000 */ {0x70, 7}, +- /*'V' ( 86) |1110001 */ {0x71, 7}, +- /*'W' ( 87) |1110010 */ {0x72, 7}, +- /*'X' ( 88) |11111100 */ {0xfc, 8}, +- /*'Y' ( 89) |1110011 */ {0x73, 7}, +- /*'Z' ( 90) |11111101 */ {0xfd, 8}, +- /*'[' ( 91) |11111111|11011 */ {0x1ffb, 13}, +- /*'\' ( 92) |11111111|11111110|000 */ {0x7fff0, 19}, +- /*']' ( 93) |11111111|11100 */ {0x1ffc, 13}, +- /*'^' ( 94) |11111111|111100 */ {0x3ffc, 14}, +- /*'_' ( 95) |100010 */ {0x22, 6}, +- /*'`' ( 96) |11111111|1111101 */ {0x7ffd, 15}, +- /*'a' ( 97) |00011 */ {0x3, 5}, +- /*'b' ( 98) |100011 */ {0x23, 6}, +- /*'c' ( 99) |00100 */ {0x4, 5}, +- /*'d' (100) |100100 */ {0x24, 6}, +- /*'e' (101) |00101 */ {0x5, 5}, +- /*'f' (102) |100101 */ {0x25, 6}, +- /*'g' (103) |100110 */ {0x26, 6}, +- /*'h' (104) |100111 */ {0x27, 6}, +- /*'i' (105) |00110 */ {0x6, 5}, +- /*'j' (106) |1110100 */ {0x74, 7}, +- /*'k' (107) |1110101 */ {0x75, 7}, +- /*'l' (108) |101000 */ {0x28, 6}, +- /*'m' (109) |101001 */ {0x29, 6}, +- /*'n' (110) |101010 */ {0x2a, 6}, +- /*'o' (111) |00111 */ {0x7, 5}, +- /*'p' (112) |101011 */ {0x2b, 6}, +- /*'q' (113) |1110110 */ {0x76, 7}, +- /*'r' (114) |101100 */ {0x2c, 6}, +- /*'s' (115) |01000 */ {0x8, 5}, +- /*'t' (116) |01001 */ {0x9, 5}, +- /*'u' (117) |101101 */ {0x2d, 6}, +- /*'v' (118) |1110111 */ {0x77, 7}, +- /*'w' (119) |1111000 */ {0x78, 7}, +- /*'x' (120) |1111001 */ {0x79, 7}, +- /*'y' (121) |1111010 */ {0x7a, 7}, +- /*'z' (122) |1111011 */ {0x7b, 7}, +- /*'{' (123) |11111111|1111110 */ {0x7ffe, 15}, +- /*'|' (124) |11111111|100 */ {0x7fc, 11}, +- /*'}' (125) |11111111|111101 */ {0x3ffd, 14}, +- /*'~' (126) |11111111|11101 */ {0x1ffd, 13}, +- /* (127) |11111111|11111111|11111111|1100 */ {0xffffffc, 28}, +- /* (128) |11111111|11111110|0110 */ {0xfffe6, 20}, +- /* (129) |11111111|11111111|010010 */ {0x3fffd2, 22}, +- /* (130) |11111111|11111110|0111 */ {0xfffe7, 20}, +- /* (131) |11111111|11111110|1000 */ {0xfffe8, 20}, +- /* (132) |11111111|11111111|010011 */ {0x3fffd3, 22}, +- /* (133) |11111111|11111111|010100 */ {0x3fffd4, 22}, +- /* (134) |11111111|11111111|010101 */ {0x3fffd5, 22}, +- /* (135) |11111111|11111111|1011001 */ {0x7fffd9, 23}, +- /* (136) |11111111|11111111|010110 */ {0x3fffd6, 22}, +- /* (137) |11111111|11111111|1011010 */ {0x7fffda, 23}, +- /* (138) |11111111|11111111|1011011 */ {0x7fffdb, 23}, +- /* (139) |11111111|11111111|1011100 */ {0x7fffdc, 23}, +- /* (140) |11111111|11111111|1011101 */ {0x7fffdd, 23}, +- /* (141) |11111111|11111111|1011110 */ {0x7fffde, 23}, +- /* (142) |11111111|11111111|11101011 */ {0xffffeb, 24}, +- /* (143) |11111111|11111111|1011111 */ {0x7fffdf, 23}, +- /* (144) |11111111|11111111|11101100 */ {0xffffec, 24}, +- /* (145) |11111111|11111111|11101101 */ {0xffffed, 24}, +- /* (146) |11111111|11111111|010111 */ {0x3fffd7, 22}, +- /* (147) |11111111|11111111|1100000 */ {0x7fffe0, 23}, +- /* (148) |11111111|11111111|11101110 */ {0xffffee, 24}, +- /* (149) |11111111|11111111|1100001 */ {0x7fffe1, 23}, +- /* (150) |11111111|11111111|1100010 */ {0x7fffe2, 23}, +- /* (151) |11111111|11111111|1100011 */ {0x7fffe3, 23}, +- /* (152) |11111111|11111111|1100100 */ {0x7fffe4, 23}, +- /* (153) |11111111|11111110|11100 */ {0x1fffdc, 21}, +- /* (154) |11111111|11111111|011000 */ {0x3fffd8, 22}, +- /* (155) |11111111|11111111|1100101 */ {0x7fffe5, 23}, +- /* (156) |11111111|11111111|011001 */ {0x3fffd9, 22}, +- /* (157) |11111111|11111111|1100110 */ {0x7fffe6, 23}, +- /* (158) |11111111|11111111|1100111 */ {0x7fffe7, 23}, +- /* (159) |11111111|11111111|11101111 */ {0xffffef, 24}, +- /* (160) |11111111|11111111|011010 */ {0x3fffda, 22}, +- /* (161) |11111111|11111110|11101 */ {0x1fffdd, 21}, +- /* (162) |11111111|11111110|1001 */ {0xfffe9, 20}, +- /* (163) |11111111|11111111|011011 */ {0x3fffdb, 22}, +- /* (164) |11111111|11111111|011100 */ {0x3fffdc, 22}, +- /* (165) |11111111|11111111|1101000 */ {0x7fffe8, 23}, +- /* (166) |11111111|11111111|1101001 */ {0x7fffe9, 23}, +- /* (167) |11111111|11111110|11110 */ {0x1fffde, 21}, +- /* (168) |11111111|11111111|1101010 */ {0x7fffea, 23}, +- /* (169) |11111111|11111111|011101 */ {0x3fffdd, 22}, +- /* (170) |11111111|11111111|011110 */ {0x3fffde, 22}, +- /* (171) |11111111|11111111|11110000 */ {0xfffff0, 24}, +- /* (172) |11111111|11111110|11111 */ {0x1fffdf, 21}, +- /* (173) |11111111|11111111|011111 */ {0x3fffdf, 22}, +- /* (174) |11111111|11111111|1101011 */ {0x7fffeb, 23}, +- /* (175) |11111111|11111111|1101100 */ {0x7fffec, 23}, +- /* (176) |11111111|11111111|00000 */ {0x1fffe0, 21}, +- /* (177) |11111111|11111111|00001 */ {0x1fffe1, 21}, +- /* (178) |11111111|11111111|100000 */ {0x3fffe0, 22}, +- /* (179) |11111111|11111111|00010 */ {0x1fffe2, 21}, +- /* (180) |11111111|11111111|1101101 */ {0x7fffed, 23}, +- /* (181) |11111111|11111111|100001 */ {0x3fffe1, 22}, +- /* (182) |11111111|11111111|1101110 */ {0x7fffee, 23}, +- /* (183) |11111111|11111111|1101111 */ {0x7fffef, 23}, +- /* (184) |11111111|11111110|1010 */ {0xfffea, 20}, +- /* (185) |11111111|11111111|100010 */ {0x3fffe2, 22}, +- /* (186) |11111111|11111111|100011 */ {0x3fffe3, 22}, +- /* (187) |11111111|11111111|100100 */ {0x3fffe4, 22}, +- /* (188) |11111111|11111111|1110000 */ {0x7ffff0, 23}, +- /* (189) |11111111|11111111|100101 */ {0x3fffe5, 22}, +- /* (190) |11111111|11111111|100110 */ {0x3fffe6, 22}, +- /* (191) |11111111|11111111|1110001 */ {0x7ffff1, 23}, +- /* (192) |11111111|11111111|11111000|00 */ {0x3ffffe0, 26}, +- /* (193) |11111111|11111111|11111000|01 */ {0x3ffffe1, 26}, +- /* (194) |11111111|11111110|1011 */ {0xfffeb, 20}, +- /* (195) |11111111|11111110|001 */ {0x7fff1, 19}, +- /* (196) |11111111|11111111|100111 */ {0x3fffe7, 22}, +- /* (197) |11111111|11111111|1110010 */ {0x7ffff2, 23}, +- /* (198) |11111111|11111111|101000 */ {0x3fffe8, 22}, +- /* (199) |11111111|11111111|11110110|0 */ {0x1ffffec, 25}, +- /* (200) |11111111|11111111|11111000|10 */ {0x3ffffe2, 26}, +- /* (201) |11111111|11111111|11111000|11 */ {0x3ffffe3, 26}, +- /* (202) |11111111|11111111|11111001|00 */ {0x3ffffe4, 26}, +- /* (203) |11111111|11111111|11111011|110 */ {0x7ffffde, 27}, +- /* (204) |11111111|11111111|11111011|111 */ {0x7ffffdf, 27}, +- /* (205) |11111111|11111111|11111001|01 */ {0x3ffffe5, 26}, +- /* (206) |11111111|11111111|11110001 */ {0xfffff1, 24}, +- /* (207) |11111111|11111111|11110110|1 */ {0x1ffffed, 25}, +- /* (208) |11111111|11111110|010 */ {0x7fff2, 19}, +- /* (209) |11111111|11111111|00011 */ {0x1fffe3, 21}, +- /* (210) |11111111|11111111|11111001|10 */ {0x3ffffe6, 26}, +- /* (211) |11111111|11111111|11111100|000 */ {0x7ffffe0, 27}, +- /* (212) |11111111|11111111|11111100|001 */ {0x7ffffe1, 27}, +- /* (213) |11111111|11111111|11111001|11 */ {0x3ffffe7, 26}, +- /* (214) |11111111|11111111|11111100|010 */ {0x7ffffe2, 27}, +- /* (215) |11111111|11111111|11110010 */ {0xfffff2, 24}, +- /* (216) |11111111|11111111|00100 */ {0x1fffe4, 21}, +- /* (217) |11111111|11111111|00101 */ {0x1fffe5, 21}, +- /* (218) |11111111|11111111|11111010|00 */ {0x3ffffe8, 26}, +- /* (219) |11111111|11111111|11111010|01 */ {0x3ffffe9, 26}, +- /* (220) |11111111|11111111|11111111|1101 */ {0xffffffd, 28}, +- /* (221) |11111111|11111111|11111100|011 */ {0x7ffffe3, 27}, +- /* (222) |11111111|11111111|11111100|100 */ {0x7ffffe4, 27}, +- /* (223) |11111111|11111111|11111100|101 */ {0x7ffffe5, 27}, +- /* (224) |11111111|11111110|1100 */ {0xfffec, 20}, +- /* (225) |11111111|11111111|11110011 */ {0xfffff3, 24}, +- /* (226) |11111111|11111110|1101 */ {0xfffed, 20}, +- /* (227) |11111111|11111111|00110 */ {0x1fffe6, 21}, +- /* (228) |11111111|11111111|101001 */ {0x3fffe9, 22}, +- /* (229) |11111111|11111111|00111 */ {0x1fffe7, 21}, +- /* (230) |11111111|11111111|01000 */ {0x1fffe8, 21}, +- /* (231) |11111111|11111111|1110011 */ {0x7ffff3, 23}, +- /* (232) |11111111|11111111|101010 */ {0x3fffea, 22}, +- /* (233) |11111111|11111111|101011 */ {0x3fffeb, 22}, +- /* (234) |11111111|11111111|11110111|0 */ {0x1ffffee, 25}, +- /* (235) |11111111|11111111|11110111|1 */ {0x1ffffef, 25}, +- /* (236) |11111111|11111111|11110100 */ {0xfffff4, 24}, +- /* (237) |11111111|11111111|11110101 */ {0xfffff5, 24}, +- /* (238) |11111111|11111111|11111010|10 */ {0x3ffffea, 26}, +- /* (239) |11111111|11111111|1110100 */ {0x7ffff4, 23}, +- /* (240) |11111111|11111111|11111010|11 */ {0x3ffffeb, 26}, +- /* (241) |11111111|11111111|11111100|110 */ {0x7ffffe6, 27}, +- /* (242) |11111111|11111111|11111011|00 */ {0x3ffffec, 26}, +- /* (243) |11111111|11111111|11111011|01 */ {0x3ffffed, 26}, +- /* (244) |11111111|11111111|11111100|111 */ {0x7ffffe7, 27}, +- /* (245) |11111111|11111111|11111101|000 */ {0x7ffffe8, 27}, +- /* (246) |11111111|11111111|11111101|001 */ {0x7ffffe9, 27}, +- /* (247) |11111111|11111111|11111101|010 */ {0x7ffffea, 27}, +- /* (248) |11111111|11111111|11111101|011 */ {0x7ffffeb, 27}, +- /* (249) |11111111|11111111|11111111|1110 */ {0xffffffe, 28}, +- /* (250) |11111111|11111111|11111101|100 */ {0x7ffffec, 27}, +- /* (251) |11111111|11111111|11111101|101 */ {0x7ffffed, 27}, +- /* (252) |11111111|11111111|11111101|110 */ {0x7ffffee, 27}, +- /* (253) |11111111|11111111|11111101|111 */ {0x7ffffef, 27}, +- /* (254) |11111111|11111111|11111110|000 */ {0x7fffff0, 27}, +- /* (255) |11111111|11111111|11111011|10 */ {0x3ffffee, 26}, +- /*EOS (256) |11111111|11111111|11111111|111111 */ {0x3fffffff, 30} +- }; +- +- static final int[][] LCCODES = new int[CODES.length][]; +- static final char EOS = 256; +- +- // Huffman decode tree stored in a flattened char array for good +- // locality of reference. +- static final char[] tree; +- static final char[] rowsym; +- static final byte[] rowbits; +- +- // Build the Huffman lookup tree and LC TABLE +- static +- { +- System.arraycopy(CODES, 0, LCCODES, 0, CODES.length); +- for (int i = 'A'; i <= 'Z'; i++) +- { +- LCCODES[i] = LCCODES['a' + i - 'A']; +- } +- +- int r = 0; +- for (int i = 0; i < CODES.length; i++) +- { +- r += (CODES[i][1] + 7) / 8; +- } +- tree = new char[r * 256]; +- rowsym = new char[r]; +- rowbits = new byte[r]; +- +- r = 0; +- for (int sym = 0; sym < CODES.length; sym++) +- { +- int code = CODES[sym][0]; +- int len = CODES[sym][1]; +- +- int current = 0; +- +- while (len > 8) +- { +- len -= 8; +- int i = ((code >>> len) & 0xFF); +- +- int t = current * 256 + i; +- current = tree[t]; +- if (current == 0) +- { +- tree[t] = (char)++r; +- current = r; +- } +- } +- +- int terminal = ++r; +- rowsym[r] = (char)sym; +- int b = len & 0x07; +- int terminalBits = b == 0 ? 8 : b; +- +- rowbits[r] = (byte)terminalBits; +- int shift = 8 - len; +- int start = current * 256 + ((code << shift) & 0xFF); +- int end = start + (1 << shift); +- for (int i = start; i < end; i++) +- { +- tree[i] = (char)terminal; +- } +- } +- } +- +- public static String decode(ByteBuffer buffer) throws HpackException.CompressionException +- { +- return decode(buffer, buffer.remaining()); +- } +- +- public static String decode(ByteBuffer buffer, int length) throws HpackException.CompressionException +- { +- Utf8StringBuilder utf8 = new Utf8StringBuilder(length * 2); +- int node = 0; +- int current = 0; +- int bits = 0; +- +- for (int i = 0; i < length; i++) +- { +- int b = buffer.get() & 0xFF; +- current = (current << 8) | b; +- bits += 8; +- while (bits >= 8) +- { +- int c = (current >>> (bits - 8)) & 0xFF; +- node = tree[node * 256 + c]; +- if (rowbits[node] != 0) +- { +- if (rowsym[node] == EOS) +- throw new HpackException.CompressionException("EOS in content"); +- +- // terminal node +- utf8.append((byte)(0xFF & rowsym[node])); +- bits -= rowbits[node]; +- node = 0; +- } +- else +- { +- // non-terminal node +- bits -= 8; +- } +- } +- } +- +- while (bits > 0) +- { +- int c = (current << (8 - bits)) & 0xFF; +- int lastNode = node; +- node = tree[node * 256 + c]; +- +- if (rowbits[node] == 0 || rowbits[node] > bits) +- { +- int requiredPadding = 0; +- for (int i = 0; i < bits; i++) +- { +- requiredPadding = (requiredPadding << 1) | 1; +- } +- +- if ((c >> (8 - bits)) != requiredPadding) +- throw new HpackException.CompressionException("Incorrect padding"); +- +- node = lastNode; +- break; +- } +- +- utf8.append((byte)(0xFF & rowsym[node])); +- bits -= rowbits[node]; +- node = 0; +- } +- +- if (node != 0) +- throw new HpackException.CompressionException("Bad termination"); +- +- return utf8.toString(); +- } +- +- public static int octetsNeeded(String s) +- { +- return octetsNeeded(CODES, s); +- } +- +- public static int octetsNeeded(byte[] b) +- { +- return octetsNeeded(CODES, b); +- } +- +- public static void encode(ByteBuffer buffer, String s) +- { +- encode(CODES, buffer, s); +- } +- +- public static void encode(ByteBuffer buffer, byte[] b) +- { +- encode(CODES, buffer, b); +- } +- +- public static int octetsNeededLC(String s) +- { +- return octetsNeeded(LCCODES, s); +- } +- +- public static void encodeLC(ByteBuffer buffer, String s) +- { +- encode(LCCODES, buffer, s); +- } +- +- private static int octetsNeeded(final int[][] table, String s) +- { +- int needed = 0; +- int len = s.length(); +- for (int i = 0; i < len; i++) +- { +- char c = s.charAt(i); +- if (c >= 128 || c < ' ') +- return -1; +- needed += table[c][1]; +- } +- +- return (needed + 7) / 8; +- } +- +- private static int octetsNeeded(final int[][] table, byte[] b) +- { +- int needed = 0; +- int len = b.length; +- for (int i = 0; i < len; i++) +- { +- int c = 0xFF & b[i]; +- needed += table[c][1]; +- } +- return (needed + 7) / 8; +- } +- +- /** +- * @param table The table to encode by +- * @param buffer The buffer to encode to +- * @param s The string to encode +- */ +- private static void encode(final int[][] table, ByteBuffer buffer, String s) +- { +- long current = 0; +- int n = 0; +- int len = s.length(); +- for (int i = 0; i < len; i++) +- { +- char c = s.charAt(i); +- if (c >= 128 || c < ' ') +- throw new IllegalArgumentException(); +- int code = table[c][0]; +- int bits = table[c][1]; +- +- current <<= bits; +- current |= code; +- n += bits; +- +- while (n >= 8) +- { +- n -= 8; +- buffer.put((byte)(current >> n)); +- } +- } +- +- if (n > 0) +- { +- current <<= (8 - n); +- current |= (0xFF >>> n); +- buffer.put((byte)(current)); +- } +- } +- +- private static void encode(final int[][] table, ByteBuffer buffer, byte[] b) +- { +- long current = 0; +- int n = 0; +- +- int len = b.length; +- for (int i = 0; i < len; i++) +- { +- int c = 0xFF & b[i]; +- int code = table[c][0]; +- int bits = table[c][1]; +- +- current <<= bits; +- current |= code; +- n += bits; +- +- while (n >= 8) +- { +- n -= 8; +- buffer.put((byte)(current >> n)); +- } +- } +- +- if (n > 0) +- { +- current <<= (8 - n); +- current |= (0xFF >>> n); +- buffer.put((byte)(current)); +- } +- } +-} +diff --git a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/MetaDataBuilder.java b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/MetaDataBuilder.java +index df45309..9ed7253 100644 +--- a/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/MetaDataBuilder.java ++++ b/jetty-http2/http2-hpack/src/main/java/org/eclipse/jetty/http2/hpack/MetaDataBuilder.java +@@ -29,7 +29,7 @@ import org.eclipse.jetty.http2.hpack.HpackException.SessionException; + + public class MetaDataBuilder + { +- private final int _maxSize; ++ private int _maxSize; + private int _size; + private Integer _status; + private String _method; +@@ -60,6 +60,11 @@ public class MetaDataBuilder + return _maxSize; + } + ++ public void setMaxSize(int maxSize) ++ { ++ _maxSize = maxSize; ++ } ++ + /** + * Get the size. + * +@@ -70,17 +75,18 @@ public class MetaDataBuilder + return _size; + } + +- public void emit(HttpField field) throws HpackException.SessionException ++ public void emit(HttpField field) throws SessionException + { + HttpHeader header = field.getHeader(); + String name = field.getName(); +- if (name == null || name.length() == 0) +- throw new HpackException.SessionException("Header size 0"); ++ if (name == null || name.isEmpty()) ++ throw new SessionException("Header size 0"); + String value = field.getValue(); + int fieldSize = name.length() + (value == null ? 0 : value.length()); + _size += fieldSize + 32; +- if (_size > _maxSize) +- throw new HpackException.SessionException("Header size %d > %d", _size, _maxSize); ++ int maxSize = getMaxSize(); ++ if (maxSize > 0 && _size > maxSize) ++ throw new SessionException("Header size %d > %d", _size, maxSize); + + if (field instanceof StaticTableHttpField) + { +@@ -89,7 +95,7 @@ public class MetaDataBuilder + { + case C_STATUS: + if (checkPseudoHeader(header, _status)) +- _status = (Integer)staticField.getStaticValue(); ++ _status = staticField.getIntValue(); + _response = true; + break; + +@@ -157,7 +163,7 @@ public class MetaDataBuilder + case C_PATH: + if (checkPseudoHeader(header, _path)) + { +- if (value != null && value.length() > 0) ++ if (value != null && !value.isEmpty()) + _path = value; + else + streamException("No Path"); +@@ -201,7 +207,7 @@ public class MetaDataBuilder + } + } + +- protected void streamException(String messageFormat, Object... args) ++ public void streamException(String messageFormat, Object... args) + { + HpackException.StreamException stream = new HpackException.StreamException(messageFormat, args); + if (_streamException == null) +@@ -267,23 +273,7 @@ public cla