fix for issue 125 - lz4 data corruption when concurrency is used

writer.go

@@ -173,7 +173,10 @@ func (z *Writer) writeHeader() error {
 
 // Write compresses data from the supplied buffer into the underlying io.Writer.
 // Write does not return until the data has been written.
-func (z *Writer) Write(buf []byte) (int, error) {
+func (z *Writer) Write(buffer []byte) (int, error) {
+	buf := make([]byte, len(buffer))
+	copy(buf, buffer)
+
 	if !z.Header.done {
 		if err := z.writeHeader(); err != nil {
 			return 0, err
@@ -223,7 +226,10 @@ func (z *Writer) Write(buf []byte) (int, error) {
 }
 
 // compressBlock compresses a block.
-func (z *Writer) compressBlock(data []byte) error {
+func (z *Writer) compressBlock(dataBlock []byte) error {
+	data := make([]byte, len(dataBlock))
+	copy(data, dataBlock)
+
 	if !z.NoChecksum {
 		_, _ = z.checksum.Write(data)
 	}

writer_test.go

@@ -1,6 +1,7 @@
 package lz4_test
 
 import (
+	"bufio"
 	"bytes"
 	"fmt"
 	"io"
@@ -183,3 +184,60 @@ func TestIssue71(t *testing.T) {
 		})
 	}
 }
+
+func TestIssue125(t *testing.T) {
+	goldenFiles := []string{
+		"testdata/e.txt",
+		"testdata/gettysburg.txt",
+		"testdata/Mark.Twain-Tom.Sawyer.txt",
+		"testdata/Mark.Twain-Tom.Sawyer_long.txt",
+		"testdata/pg1661.txt",
+		"testdata/pi.txt",
+		"testdata/random.data",
+		"testdata/repeat.txt",
+		"testdata/vmlinux_LZ4_19377",
+	}
+
+	for _, fname := range goldenFiles {
+		for _, concurrency := range []int{0, 4, -1} {
+			label := fmt.Sprintf("%s(%d)", fname, concurrency)
+			t.Run(label, func(t *testing.T) {
+				t.Parallel()
+
+				// this issue doesn't happen when read the entire file into a []byte
+				// and then use bytes.NewReader() since it actually does a copy on its
+				// own for each call to Read(), so we use *os.File directly with Copy()
+				f, err := os.Open(fname)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer f.Close()
+
+				var out bytes.Buffer
+				writer := lz4.NewWriter(&out).WithConcurrency(concurrency)
+				writer.Header = lz4.Header{
+					// we use a small enough block size so it is easier to trigger the issue
+					// as most examples files are small
+					BlockMaxSize: 1024 * 64,
+				}
+
+				_, err = io.Copy(writer, f)
+				if err != nil {
+					t.Fatal(err)
+				}
+				writer.Close()
+
+				reader := lz4.NewReader(&out)
+
+				var d bytes.Buffer
+				decompressed := bufio.NewWriter(&d)
+
+				_, err = io.Copy(decompressed, reader)
+				if err != nil {
+					t.Fail()
+					t.Log(err)
+				}
+			})
+		}
+	}
+}