zipindex

ExampleReadFile demonstrates how to read the index of a file on disk.

package main

import (
	"fmt"

	"github.com/minio/zipindex"
)

func main() {
	files, err := zipindex.ReadFile("testdata/go-with-datadesc-sig.zip", nil)
	if err != nil {
		panic(err)
	}
	files.OptimizeSize()
	serialized, err := files.Serialize()
	if err != nil {
		panic(err)
	}

	file, err := zipindex.FindSerialized(serialized, "bar.txt")
	if err != nil {
		panic(err)
	}
	fmt.Printf("bar.txt: %+v", *file)
}

Output:

bar.txt: {Name:bar.txt CompressedSize64:4 UncompressedSize64:4 Offset:57 CRC32:0 Method:0 Flags:8 Custom:map[]}

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"log"

	"github.com/minio/zipindex"
)

func main() {
	exitOnErr := func(err error) {
		if err != nil {
			log.Fatalln(err)
		}
	}

	b, err := ioutil.ReadFile("testdata/big.zip")
	exitOnErr(err)
	// We only need the end of the file to parse the directory.
	// Usually this should be at least 64K on initial try.
	sz := 64 << 10
	var files zipindex.Files
	files, err = zipindex.ReadDir(b[len(b)-sz:], int64(len(b)), nil)
	// Omitted: Check if ErrNeedMoreData and retry with more data
	exitOnErr(err)

	// OptimizeSize files will make the size as efficient as possible
	// without loosing data.
	files.OptimizeSize()

	// Serialize files to binary.
	serialized, err := files.Serialize()
	exitOnErr(err)

	// This output may change if compression is improved.
	// Output is rounded up.
	fmt.Printf("Size of serialized data: %dKB\n", (len(serialized)+1023)/1024)

	// StripCRC(true) will strip CRC, even if there is no file descriptor.
	files.StripCRC(true)
	// StripFlags(1<<3) will strip all flags that aren't a file descriptor flag (bit 3).
	files.StripFlags(1 << 3)
	noCRC, err := files.Serialize()
	exitOnErr(err)

	// This output may change if compression is improved.
	// Output is rounded up.
	fmt.Printf("Size of serialized data without CRC: %dKB\n", (len(noCRC)+1023)/1024)

	// Deserialize the content (with CRC).
	files, err = zipindex.DeserializeFiles(serialized)
	exitOnErr(err)

	file := files.Find("file-10.txt")
	fmt.Printf("Reading file: %+v\n", *file)

	// Create a reader with entire zip file...
	rs := bytes.NewReader(b)
	// Seek to the file offset.
	_, err = rs.Seek(file.Offset, io.SeekStart)
	exitOnErr(err)

	// Provide the forwarded reader..
	rc, err := file.Open(rs)
	exitOnErr(err)
	defer rc.Close()

	// Read the zip file content.
	content, err := ioutil.ReadAll(rc)
	exitOnErr(err)

	fmt.Printf("File content is '%s'\n", string(content))

}

Output:

Size of serialized data: 6KB
Size of serialized data without CRC: 1KB
Reading file: {Name:file-10.txt CompressedSize64:2 UncompressedSize64:2 Offset:410 CRC32:2707236321 Method:0 Flags:0 Custom:map[]}
File content is '10'

package main

import (
	"errors"
	"fmt"
	"io/ioutil"

	"github.com/minio/zipindex"
)

func main() {
	b, err := ioutil.ReadFile("testdata/big.zip")
	if err != nil {
		panic(err)
	}
	// We only need the end of the file to parse the directory.
	// Usually this should be at least 64K on initial try.
	sz := 10 << 10
	var files zipindex.Files
	for {
		files, err = zipindex.ReadDir(b[len(b)-sz:], int64(len(b)), nil)
		if err == nil {
			fmt.Printf("Got %d files\n", len(files))
			break
		}
		var terr zipindex.ErrNeedMoreData
		if errors.As(err, &terr) {
			if terr.FromEnd > 1<<20 {
				panic("we will only provide max 1MB data")
			}
			sz = int(terr.FromEnd)
			fmt.Printf("Retrying with %d bytes at the end of file\n", sz)
		} else {
			// Unable to parse...
			panic(err)
		}
	}

	fmt.Printf("First file: %+v", files[0])
}

Output:

Retrying with 57912 bytes at the end of file
Got 1000 files
First file: {Name:file-0.txt CompressedSize64:1 UncompressedSize64:1 Offset:0 CRC32:4108050209 Method:0 Flags:0 Custom:map[]}

ExampleReadFile demonstrates how to read the index of a file on disk.

package main

import (
	"fmt"

	"github.com/minio/zipindex"
)

func main() {
	files, err := zipindex.ReadFile("testdata/go-with-datadesc-sig.zip", nil)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Got %d files\n", len(files))
	fmt.Printf("First file: %+v", files[0])
}

Output:

Got 2 files
First file: {Name:foo.txt CompressedSize64:4 UncompressedSize64:4 Offset:0 CRC32:2117232040 Method:0 Flags:8 Custom:map[]}

ExampleReadFile demonstrates how to read the index of a file on disk.

package main

import (
	"fmt"
	"os"

	"github.com/minio/zipindex"
)

func main() {
	f, err := os.Open("testdata/big.zip")
	if err != nil {
		panic(err)
	}
	fi, err := f.Stat()
	if err != nil {
		panic(err)
	}

	// Read and allow up to 10MB index.
	files, err := zipindex.ReaderAt(f, fi.Size(), 10<<20, nil)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Got %d files\n", len(files))
	fmt.Printf("First file: %+v", files[0])
}

Output:

Got 1000 files
First file: {Name:file-0.txt CompressedSize64:1 UncompressedSize64:1 Offset:0 CRC32:4108050209 Method:0 Flags:0 Custom:map[]}