OutputStreamMonitor.getContents() inserts U+FFFD when a multibyte character is split across two reads

Đang mở
  • Có gì không ổn?
#3,058 2 bình luận 0 reaction 0 người được giao Xem trên GitHub

Maintainer thường phản hồi trong vòng 1 ngày

@dimitribekale đang làm issue này rồi.

Từ ngày 5/11/2026.

  • #1 của @dimitribekale — đã đóng, không merge
  • #3060 của @dimitribekale — đang mở

Đánh giá

Độ khó
4/5
Thời gian dự kiến
1-2 ngày
Mức phù hợp với người mới
25/100
Loại issue
Lỗi
Độ rõ ràng
Đặc tả rõ ràng
Mức độ hoạt động
Đình trệ
Công nghệ
java
Lĩnh vực
backend

Hướng nghiên cứu

Start with debug/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/OutputStreamMonitor.java, especially getContents(), flushContents(), and setBuffered(), and read the related OutputStreamMonitorTests coverage. Reproduce the split UTF-8 read described in the issue and check how decoding behaves when getContents() is called after each read. Done means the returned text is o and then oöO without an intervening flush, while the existing flush test still passes.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.

Mô tả

bug

org.eclipse.debug.internal.core.OutputStreamMonitor.getContents() returns corrupted text when a
multibyte character arrives split across two reads of the process stream and getContents() is
called after each read without flushContents() in between.

Cause. getContents() (master c49150d04204, 2026-11-04, lines 191–202) decodes the whole accumulated byte
buffer with fBufferedDecoder, a stateful StreamDecoder that keeps the bytes of an incomplete
trailing character between calls. The read thread clears fCachedDecodedContents on every append,
so the next call re-feeds bytes the decoder has already consumed. The retained lead byte is then
followed by the first byte of the buffer again, which the decoder reports as malformed input (U+FFFD).

Reproduce. UTF-8 monitor, input "oöO" (6F C3 B6 4F), written as 6F C3 then B6 4F,
getContents() after each write (the attached Repro.java does this with a PipedOutputStream and
the same subclass trick as OutputStreamMonitorTests):

  • Expected: "o", then "oöO"
  • Actual: "o", then "�oöO"

The existing testBufferedOutputStreamMonitor uses this input but flushes between the reads, so it
does not catch the case.

Impact. IStreamMonitor.getContents() is API and monitors are buffered from construction.
ProcessConsole reads the contents once and then unbuffers, so the Console view is not affected;
clients that poll a buffered monitor while the process is writing get wrong text. Minor.

Proposed fix. Decode only the bytes not yet fed to the decoder and accumulate the result, so
nothing is re-fed; flushContents() and setBuffered() reset the accumulated text and the fed-byte
count and keep the decoder state, as today. Verified fail-then-pass against master compiled
standalone, and the flush sequence of testBufferedOutputStreamMonitor keeps its current result.
A regression test in the style of that test is included below. Happy to open a PR if this is
confirmed.

Patch 
--- a/debug/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/OutputStreamMonitor.java
+++ b/debug/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/OutputStreamMonitor.java
@@ -70,7 +70,9 @@
 	 * of an incomplete character.
 	 */
 	private StreamDecoder fBufferedDecoder;
+	/** Decoded form of the first {@link #fDecodedLength} bytes of {@link #fContents}. */
 	private String fCachedDecodedContents;
+	private int fDecodedLength;
 
 	/**
 	 * The thread which reads from the stream
@@ -193,11 +195,12 @@
 		if (!isBuffered()) {
 			return ""; //$NON-NLS-1$
 		}
-		if (fCachedDecodedContents != null) {
-			return fCachedDecodedContents;
-		}
 		byte[] data = getData();
-		fCachedDecodedContents = fBufferedDecoder.decode(data, 0, data.length);
+		if (fDecodedLength < data.length) {
+			// decode only the bytes not yet fed to the stateful decoder
+			fCachedDecodedContents += fBufferedDecoder.decode(data, fDecodedLength, data.length - fDecodedLength);
+			fDecodedLength = data.length;
+		}
 		return fCachedDecodedContents;
 	}
 
@@ -236,7 +239,6 @@
 					if (read > 0) {
 						synchronized (this) {
 							if (isBuffered()) {
-								fCachedDecodedContents = null;
 								fContents.write(buffer, 0, read);
 							}
 							fireStreamAppended(buffer, 0, read);
@@ -306,7 +308,8 @@
 	@Override
 	public synchronized void setBuffered(boolean buffer) {
 		if (isBuffered() != buffer) {
-			fCachedDecodedContents = null;
+			fCachedDecodedContents = ""; //$NON-NLS-1$
+			fDecodedLength = 0;
 			if (buffer) {
 				fContents = new ByteArrayOutputStream();
 				fBufferedDecoder = new StreamDecoder(fCharset == null ? Charset.defaultCharset() : fCharset);
@@ -320,7 +323,8 @@
 	@Override
 	public synchronized void flushContents() {
 		if (isBuffered()) {
-			fCachedDecodedContents = null;
+			fCachedDecodedContents = ""; //$NON-NLS-1$
+			fDecodedLength = 0;
 			fContents.reset();
 		}
 	}
Regression test for OutputStreamMonitorTests 
/**
 * A multibyte character split across two reads must not be corrupted when
 * getContents() is called after each read without flushing in between.
 */
@Test
public void testBufferedContentsWithSplitCharacterAndNoFlush() throws Exception {
	String input = "oöO";
	byte[] byteInput = input.getBytes(StandardCharsets.UTF_8);
	BinaryListener binaryListener = new BinaryListener();
	monitor.addBinaryListener(binaryListener);

	sysout.write(byteInput, 0, 2);
	sysout.flush();
	monitor.startMonitoring();
	binaryListener.waitForBytes(2);
	assertThat(monitor.getContents()).isEqualTo(input.substring(0, 1));

	sysout.write(byteInput, 2, byteInput.length - 2);
	sysout.flush();
	binaryListener.waitForBytes(byteInput.length);
	assertThat(monitor.getContents()).isEqualTo(input);
	binaryListener.assertNoExceptions();
}
Standalone reproducer (Repro.java)

Compile OutputStreamMonitor.java and StreamDecoder.java from master together with this file
against the Eclipse SDK plug-ins (JDK 17+), run Repro; exit code 1 on the current code, 0 with
the patch.

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.nio.charset.StandardCharsets;

import org.eclipse.debug.core.IBinaryStreamListener;
import org.eclipse.debug.internal.core.OutputStreamMonitor;

public class Repro {
	static class TestOutputStreamMonitor extends OutputStreamMonitor {
		TestOutputStreamMonitor(java.io.InputStream in) { super(in, StandardCharsets.UTF_8); }
		public void startMonitoring() { super.startMonitoring("repro"); }
	}

	public static void main(String[] args) throws Exception {
		String input = "oöO";
		byte[] bytes = input.getBytes(StandardCharsets.UTF_8);   // 6F C3 B6 4F
		PipedOutputStream sysout = new PipedOutputStream();
		PipedInputStream in = new PipedInputStream(sysout);
		TestOutputStreamMonitor monitor = new TestOutputStreamMonitor(in);
		int[] received = {0};
		monitor.addBinaryListener((IBinaryStreamListener) (data, m) -> { synchronized (received) { received[0] += data.length; received.notifyAll(); } });

		sysout.write(bytes, 0, 2);                        // 'o' + first byte of 'ö'
		sysout.flush();
		monitor.startMonitoring();
		waitFor(received, 2);
		String first = monitor.getContents();             // "o", decoder keeps 0xC3

		sysout.write(bytes, 2, 2);                        // second byte of 'ö' + 'O', no flushContents in between
		sysout.flush();
		waitFor(received, 4);
		String second = monitor.getContents();
		sysout.close();

		System.out.println("first  getContents(): " + show(first));
		System.out.println("second getContents(): " + show(second) + "   expected " + show(input));
		System.exit(second.equals(input) ? 0 : 1);
	}

	static void waitFor(int[] c, int n) throws InterruptedException {
		synchronized (c) { long end = System.currentTimeMillis() + 10000; while (c[0] < n && System.currentTimeMillis() < end) c.wait(100); }
	}

	static String show(String s) {
		StringBuilder b = new StringBuilder("\"");
		for (char ch : s.toCharArray()) b.append(ch < 128 ? String.valueOf(ch) : String.format("<U+%04X>", (int) ch));
		return b.append('"').toString();
	}
}

Provenance. This defect was found during an academic study of LLM-assisted code review at Jeonbuk National University (Jeonju, South Korea). The initial analysis was produced by an automated LLM-based reviewer and then manually verified by the authors: we confirmed the defect mechanism by reading the source at HEAD, and the reproducer above compiles and exhibits the failure against the real code. The reviewer's own patch (a fresh decoder per call) fixed this case but broke the flush sequence that the existing testBufferedOutputStreamMonitor asserts, so the patch proposed here is the authors' correction. We are disclosing this origin in line with project policies on AI-assisted contributions. We report it because we believe it is a genuine defect, and we will respect the project's triage either way; a "not a bug" outcome is valuable to us as a correction.

Ngôn ngữ chính
Java
Star
165
Fork
174
Merge trung bình
4 ngày 56 phút
Pull request đã merge (30 ngày)
36

Chuẩn bị môi trường

Bắt đầu từ đâu

  1. Đọc hết issue, rồi đọc hướng dẫn đóng góp của dự án.
  2. Bình luận trên issue rằng bạn sẽ nhận — tránh hai người làm cùng một việc.
  3. Fork repository và làm thay đổi trên một nhánh.
  4. Mở pull request có tham chiếu số hiệu của issue.

Issue khác của eclipse-platform/eclipse.platform

Tất cả issue của eclipse-platform/eclipse.platform

Issue tương tự

Thêm issue về Java

Nhận issue mới trong hộp thư của bạn

Bản tóm tắt ngắn những issue GitHub phù hợp với người mới.