zstd: don't clear the registered dictionary when decoding past the window (#1177)

* zstd: don't clear the registered dictionary when decoding past the window

executeSequences set hist.dict.content = nil when the frame history grew
past the window. hist.dict is the same *dict registered via
WithDecoderDicts/WithDecoderDictRaw, so this blanked the dictionary for
every later decode on the decoder: after one streaming decode of a
dictionary frame larger than the window, subsequent decodes of a valid
dictionary frame failed with 'match offset (...) bigger than current
history'. The write was dead for the current decode (the streaming path
reads its own hist.decoders.dict copy) and only ever corrupted reuse.

Drop the mutation and keep the window trim; the shared dictionary is now
left intact, matching the sync decode path.

Add TestDecoderDictReuseAfterLargeStream (fails before, passes after).

* go fix

* Move test into existing file and simplify the test somewhat. Verified that it still reproduces.

---------

Co-authored-by: Klaus Post <klauspost@gmail.com>

Author: sueun-dev

zstd/blockdec.go

@@ -674,10 +674,6 @@ func (b *blockDec) executeSequences(hist *history) error {
 	hbytes := hist.b
 	if len(hbytes) > hist.windowSize {
 		hbytes = hbytes[len(hbytes)-hist.windowSize:]
-		// We do not need history anymore.
-		if hist.dict != nil {
-			hist.dict.content = nil
-		}
 	}
 	hist.decoders.windowSize = hist.windowSize
 	hist.decoders.out = b.dst[:0]

zstd/dict_test.go

@@ -1056,3 +1056,51 @@ func TestSharedDecoderTrainedDictRace(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+// hideLen wraps a reader so the decoder cannot detect a *bytes.Reader and take
+// the small-buffer sync path; this forces the concurrent streaming decode path.
+type hideLen struct{ r io.Reader }
+
+func (h hideLen) Read(p []byte) (int, error) { return h.r.Read(p) }
+
+// TestDecoderDictReuseAfterLargeStream verifies that streaming-decoding a
+// dictionary-compressed frame whose output exceeds the window does not corrupt
+// the registered dictionary for later decodes on the same decoder.
+func TestDecoderDictReuseAfterLargeStream(t *testing.T) {
+	rng := rand.New(rand.NewSource(1))
+	dictContent := make([]byte, 8<<10)
+	rng.Read(dictContent)
+	const dictID = 12345
+	const windowSize = 256 << 10
+
+	// The payload starts with the dictionary content (so the encoder emits a
+	// match into the dictionary) and is long enough that decoded history
+	// exceeds the window while compressed blocks are still being executed.
+	payload := bytes.Repeat(dictContent, 2*windowSize/len(dictContent))
+
+	enc, err := NewWriter(nil, WithEncoderDictRaw(dictID, dictContent), WithWindowSize(windowSize))
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := enc.EncodeAll(payload, nil)
+	enc.Close()
+
+	dec, err := NewReader(nil, WithDecoderDictRaw(dictID, dictContent))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer dec.Close()
+
+	for i := range 3 {
+		if err := dec.Reset(hideLen{bytes.NewReader(frame)}); err != nil {
+			t.Fatalf("reset %d: %v", i, err)
+		}
+		got, err := io.ReadAll(dec)
+		if err != nil {
+			t.Fatalf("decode %d of a valid dictionary frame failed: %v", i, err)
+		}
+		if !bytes.Equal(got, payload) {
+			t.Fatalf("decode %d: output mismatch: got %d bytes, want %d", i, len(got), len(payload))
+		}
+	}
+}