[UNDERTOW-2697] Handle properly followup values after Hpack.encode overflow

Author: baranowb

core/src/main/java/io/undertow/protocols/http2/HpackEncoder.java

@@ -95,7 +95,9 @@ public boolean shouldUseHuffman(HttpString header) {
 
     private byte[] overflowData;
     private int overflowPos;
-    private int overflowLength;
+    private int overflowLength = -1;
+    // hold last iterator intex over values, its used in case of overflow to kickstart from next entry if there is more than one
+    private int headersValueIterator = -1;
 
     static {
         Map<HttpString, TableEntry[]> map = new HashMap<>();
@@ -151,6 +153,7 @@ public State encode(HeaderMap headers, ByteBuffer target) {
                 target.put(overflowData[i]);
             }
             overflowData = null;
+            overflowLength = -1;
         }
 
         long it = headersIterator;
@@ -163,7 +166,9 @@ public State encode(HeaderMap headers, ByteBuffer target) {
             if (headers != currentHeaders) {
                 throw new IllegalStateException();
             }
-            it = headers.fiNext(it);
+            if( this.headersValueIterator == -1) {
+                it = headers.fiNext(it);
+            }
         }
         while (it != -1) {
             HeaderValues values = headers.fiCurrent(it);
@@ -182,7 +187,10 @@ public State encode(HeaderMap headers, ByteBuffer target) {
                 skip = true;
             }
             if (!skip) {
-                for (int i = 0; i < values.size(); ++i) {
+                //this is done to restart after overflow.
+                int valuesStartIndex = this.headersValueIterator == -1 ? 0 : this.headersValueIterator + 1;
+                this.headersValueIterator = -1;
+                for (int i = valuesStartIndex; i < values.size(); ++i) {
 
                     HttpString headerName = values.getHeaderName();
                     int required = 11 + headerName.length(); //we use 11 to make sure we have enough room for the variable length itegers
@@ -242,6 +250,10 @@ public State encode(HeaderMap headers, ByteBuffer target) {
                     if(overflowing) {
                         this.headersIterator = it;
                         this.overflowLength = current.position();
+                        if(values.size() > 1 && values.size() > i) {
+                            this.headersValueIterator = i;
+                            //set this only in case we have more, otherwise single entry will be handled properly.
+                        }
                         return State.OVERFLOW;
                     }
 

core/src/test/java/io/undertow/protocols/http2/HpackOverflowUnitTestCase.java

@@ -0,0 +1,91 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2026 Red Hat, Inc., and individual contributors
+ * as indicated by the @author tags.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package io.undertow.protocols.http2;
+
+import io.undertow.protocols.http2.HpackDecoder.HeaderEmitter;
+import io.undertow.testutils.category.UnitTest;
+import io.undertow.util.HeaderMap;
+import io.undertow.util.HttpString;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @author Kanatoko
+ */
+@Category(UnitTest.class)
+public class HpackOverflowUnitTestCase {
+
+    @Test
+    public void testStringLiteralContainingEOS() throws HpackException {
+        final int countOfSameNames = testImpl("X-Header-1", "X-Header-1");
+        final int countOfDifferentNames = testImpl("X-Header-1", "X-Header-2");
+        Assert.assertEquals(2, countOfSameNames);
+        Assert.assertEquals(2, countOfDifferentNames);
+    }
+
+    private static int testImpl(final String name1, final String name2) {
+        final HeaderMap headerMap = new HeaderMap();
+        headerMap.add(new HttpString(name1), getStr(300, (byte) 0x41));// overflow
+        headerMap.add(new HttpString(name2), getStr(150, (byte) 0x42));// skipped if name1 equals name2
+        final HpackEncoder encoder = new HpackEncoder(4096);
+        final ByteBuffer buffer1 = ByteBuffer.allocate(256);
+
+        // overflow
+        HpackEncoder.State result = encoder.encode(headerMap, buffer1);
+
+        Assert.assertEquals(HpackEncoder.State.OVERFLOW, result);
+        final ByteBuffer buffer2 = ByteBuffer.allocate(512);
+
+        // complete
+        result = encoder.encode(headerMap, buffer2);
+        Assert.assertEquals(HpackEncoder.State.COMPLETE, result);
+
+        final HpackDecoder decoder = new HpackDecoder(4096);
+
+        final AtomicInteger count = new AtomicInteger();
+        try {
+            buffer2.flip();
+            decoder.setHeaderEmitter(new HeaderEmitter() {
+
+                @Override
+                public void emitHeader(HttpString name, String value, boolean neverIndex) throws HpackException {
+                    count.incrementAndGet();
+
+                }
+            });
+            decoder.decode(buffer2, false);
+        } catch (HpackException e) {
+            e.printStackTrace();
+        }
+        return count.get();
+    }
+
+    private static String getStr(final int length, byte content) {
+        final byte[] buf = new byte[length];
+        Arrays.fill(buf, content);
+        return new String(buf);
+    }
+
+}