Figured out it was the filters for XZ that was causing problems

Added lzma and xz decompression.
Renamed Zlib to Gzip

internal/compression/gzip.go

@@ -6,11 +6,11 @@ import (
 	"io"
 )
 
-//Zlib is a decompressor for gzip type compression
-type Zlib struct{}
+//Gzip is a decompressor for gzip type compression. Uses zlib for compression and decompression
+type Gzip struct{}
 
 //Decompress reads the entirety of the given reader and returns it uncompressed as a byte slice.
-func (z *Zlib) Decompress(r io.Reader) ([]byte, error) {
+func (g *Gzip) Decompress(r io.Reader) ([]byte, error) {
 	rdr, err := zlib.NewReader(r)
 	if err != nil {
 		return nil, err
@@ -24,7 +24,7 @@ func (z *Zlib) Decompress(r io.Reader) ([]byte, error) {
 }
 
 //Compress compresses the given data (as a byte array) and returns the compressed data.
-func (z *Zlib) Compress(data []byte) ([]byte, error) {
+func (g *Gzip) Compress(data []byte) ([]byte, error) {
 	var buf bytes.Buffer
 	wrt := zlib.NewWriter(&buf)
 	defer wrt.Close()

internal/compression/lzma.go

@@ -0,0 +1,25 @@
+package compression
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/ulikunitz/xz/lzma"
+)
+
+//Lzma is a lzma decompressor
+type Lzma struct{}
+
+//Decompress decompresses all the data in the given reader and returns the uncompressed bytes.
+func (l *Lzma) Decompress(rdr io.Reader) ([]byte, error) {
+	r, err := lzma.NewReader(rdr)
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

internal/compression/xz.go

@@ -0,0 +1,55 @@
+package compression
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/ulikunitz/xz"
+)
+
+type xzInit struct {
+	DictionarySize int32
+	Filters        int32
+}
+
+//Xz is a Xz decompressor.
+type Xz struct {
+	DictionarySize int32
+	HasFilters     bool
+}
+
+//NewXzCompressorWithOptions creates a new Xz compressor/decompressor that reads the compressor options from the given reader.
+func NewXzCompressorWithOptions(rdr io.Reader) (*Xz, error) {
+	var x Xz
+	var init xzInit
+	err := binary.Read(rdr, binary.LittleEndian, &init)
+	if err != nil {
+		return nil, err
+	}
+	x.DictionarySize = init.DictionarySize
+	//TODO: When I can do filters, parse the filters
+	if init.Filters != 0 {
+		x.HasFilters = true
+	}
+	return &x, nil
+}
+
+//Decompress decompresses all the data from the rdr and returns the uncompressed bytes.
+func (x *Xz) Decompress(rdr io.Reader) ([]byte, error) {
+	r, err := xz.NewReader(rdr)
+	if err != nil {
+		return nil, err
+	}
+	r.DictCap = int(x.DictionarySize)
+	err = r.Verify()
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}