URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [archive/] [zip/] [reader.go] - Blame information for rev 747

Details | Compare with Previous | View Log


// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
package zip
 
import (
        "bufio"
        "compress/flate"
        "encoding/binary"
        "errors"
        "hash"
        "hash/crc32"
        "io"
        "io/ioutil"
        "os"
)
 
var (
        ErrFormat    = errors.New("zip: not a valid zip file")
        ErrAlgorithm = errors.New("zip: unsupported compression algorithm")
        ErrChecksum  = errors.New("zip: checksum error")
)
 
type Reader struct {
        r       io.ReaderAt
        File    []*File
        Comment string
}
 
type ReadCloser struct {
        f *os.File
        Reader
}
 
type File struct {
        FileHeader
        zipr         io.ReaderAt
        zipsize      int64
        headerOffset int64
}
 
func (f *File) hasDataDescriptor() bool {
        return f.Flags&0x8 != 0
}
 
// OpenReader will open the Zip file specified by name and return a ReadCloser.
func OpenReader(name string) (*ReadCloser, error) {
        f, err := os.Open(name)
        if err != nil {
                return nil, err
        }
        fi, err := f.Stat()
        if err != nil {
                f.Close()
                return nil, err
        }
        r := new(ReadCloser)
        if err := r.init(f, fi.Size()); err != nil {
                f.Close()
                return nil, err
        }
        r.f = f
        return r, nil
}
 
// NewReader returns a new Reader reading from r, which is assumed to
// have the given size in bytes.
func NewReader(r io.ReaderAt, size int64) (*Reader, error) {
        zr := new(Reader)
        if err := zr.init(r, size); err != nil {
                return nil, err
        }
        return zr, nil
}
 
func (z *Reader) init(r io.ReaderAt, size int64) error {
        end, err := readDirectoryEnd(r, size)
        if err != nil {
                return err
        }
        z.r = r
        z.File = make([]*File, 0, end.directoryRecords)
        z.Comment = end.comment
        rs := io.NewSectionReader(r, 0, size)
        if _, err = rs.Seek(int64(end.directoryOffset), os.SEEK_SET); err != nil {
                return err
        }
        buf := bufio.NewReader(rs)
 
        // The count of files inside a zip is truncated to fit in a uint16.
        // Gloss over this by reading headers until we encounter
        // a bad one, and then only report a ErrFormat or UnexpectedEOF if
        // the file count modulo 65536 is incorrect.
        for {
                f := &File{zipr: r, zipsize: size}
                err = readDirectoryHeader(f, buf)
                if err == ErrFormat || err == io.ErrUnexpectedEOF {
                        break
                }
                if err != nil {
                        return err
                }
                z.File = append(z.File, f)
        }
        if uint16(len(z.File)) != end.directoryRecords {
                // Return the readDirectoryHeader error if we read
                // the wrong number of directory entries.
                return err
        }
        return nil
}
 
// Close closes the Zip file, rendering it unusable for I/O.
func (rc *ReadCloser) Close() error {
        return rc.f.Close()
}
 
// Open returns a ReadCloser that provides access to the File's contents.
// Multiple files may be read concurrently.
func (f *File) Open() (rc io.ReadCloser, err error) {
        bodyOffset, err := f.findBodyOffset()
        if err != nil {
                return
        }
        size := int64(f.CompressedSize)
        if size == 0 && f.hasDataDescriptor() {
                // permit SectionReader to see the rest of the file
                size = f.zipsize - (f.headerOffset + bodyOffset)
        }
        r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, size)
        switch f.Method {
        case Store: // (no compression)
                rc = ioutil.NopCloser(r)
        case Deflate:
                rc = flate.NewReader(r)
        default:
                err = ErrAlgorithm
        }
        if rc != nil {
                rc = &checksumReader{rc, crc32.NewIEEE(), f, r}
        }
        return
}
 
type checksumReader struct {
        rc   io.ReadCloser
        hash hash.Hash32
        f    *File
        zipr io.Reader // for reading the data descriptor
}
 
func (r *checksumReader) Read(b []byte) (n int, err error) {
        n, err = r.rc.Read(b)
        r.hash.Write(b[:n])
        if err != io.EOF {
                return
        }
        if r.f.hasDataDescriptor() {
                if err = readDataDescriptor(r.zipr, r.f); err != nil {
                        return
                }
        }
        if r.hash.Sum32() != r.f.CRC32 {
                err = ErrChecksum
        }
        return
}
 
func (r *checksumReader) Close() error { return r.rc.Close() }
 
func readFileHeader(f *File, r io.Reader) error {
        var b [fileHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
        }
        c := binary.LittleEndian
        if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {
                return ErrFormat
        }
        f.ReaderVersion = c.Uint16(b[4:6])
        f.Flags = c.Uint16(b[6:8])
        f.Method = c.Uint16(b[8:10])
        f.ModifiedTime = c.Uint16(b[10:12])
        f.ModifiedDate = c.Uint16(b[12:14])
        f.CRC32 = c.Uint32(b[14:18])
        f.CompressedSize = c.Uint32(b[18:22])
        f.UncompressedSize = c.Uint32(b[22:26])
        filenameLen := int(c.Uint16(b[26:28]))
        extraLen := int(c.Uint16(b[28:30]))
        d := make([]byte, filenameLen+extraLen)
        if _, err := io.ReadFull(r, d); err != nil {
                return err
        }
        f.Name = string(d[:filenameLen])
        f.Extra = d[filenameLen:]
        return nil
}
 
// findBodyOffset does the minimum work to verify the file has a header
// and returns the file body offset.
func (f *File) findBodyOffset() (int64, error) {
        r := io.NewSectionReader(f.zipr, f.headerOffset, f.zipsize-f.headerOffset)
        var b [fileHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return 0, err
        }
        c := binary.LittleEndian
        if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {
                return 0, ErrFormat
        }
        filenameLen := int(c.Uint16(b[26:28]))
        extraLen := int(c.Uint16(b[28:30]))
        return int64(fileHeaderLen + filenameLen + extraLen), nil
}
 
// readDirectoryHeader attempts to read a directory header from r.
// It returns io.ErrUnexpectedEOF if it cannot read a complete header,
// and ErrFormat if it doesn't find a valid header signature.
func readDirectoryHeader(f *File, r io.Reader) error {
        var b [directoryHeaderLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
        }
        c := binary.LittleEndian
        if sig := c.Uint32(b[:4]); sig != directoryHeaderSignature {
                return ErrFormat
        }
        f.CreatorVersion = c.Uint16(b[4:6])
        f.ReaderVersion = c.Uint16(b[6:8])
        f.Flags = c.Uint16(b[8:10])
        f.Method = c.Uint16(b[10:12])
        f.ModifiedTime = c.Uint16(b[12:14])
        f.ModifiedDate = c.Uint16(b[14:16])
        f.CRC32 = c.Uint32(b[16:20])
        f.CompressedSize = c.Uint32(b[20:24])
        f.UncompressedSize = c.Uint32(b[24:28])
        filenameLen := int(c.Uint16(b[28:30]))
        extraLen := int(c.Uint16(b[30:32]))
        commentLen := int(c.Uint16(b[32:34]))
        // startDiskNumber := c.Uint16(b[34:36])    // Unused
        // internalAttributes := c.Uint16(b[36:38]) // Unused
        f.ExternalAttrs = c.Uint32(b[38:42])
        f.headerOffset = int64(c.Uint32(b[42:46]))
        d := make([]byte, filenameLen+extraLen+commentLen)
        if _, err := io.ReadFull(r, d); err != nil {
                return err
        }
        f.Name = string(d[:filenameLen])
        f.Extra = d[filenameLen : filenameLen+extraLen]
        f.Comment = string(d[filenameLen+extraLen:])
        return nil
}
 
func readDataDescriptor(r io.Reader, f *File) error {
        var b [dataDescriptorLen]byte
        if _, err := io.ReadFull(r, b[:]); err != nil {
                return err
        }
        c := binary.LittleEndian
        f.CRC32 = c.Uint32(b[:4])
        f.CompressedSize = c.Uint32(b[4:8])
        f.UncompressedSize = c.Uint32(b[8:12])
        return nil
}
 
func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) {
        // look for directoryEndSignature in the last 1k, then in the last 65k
        var b []byte
        for i, bLen := range []int64{1024, 65 * 1024} {
                if bLen > size {
                        bLen = size
                }
                b = make([]byte, int(bLen))
                if _, err := r.ReadAt(b, size-bLen); err != nil && err != io.EOF {
                        return nil, err
                }
                if p := findSignatureInBlock(b); p >= 0 {
                        b = b[p:]
                        break
                }
                if i == 1 || bLen == size {
                        return nil, ErrFormat
                }
        }
 
        // read header into struct
        c := binary.LittleEndian
        d := new(directoryEnd)
        d.diskNbr = c.Uint16(b[4:6])
        d.dirDiskNbr = c.Uint16(b[6:8])
        d.dirRecordsThisDisk = c.Uint16(b[8:10])
        d.directoryRecords = c.Uint16(b[10:12])
        d.directorySize = c.Uint32(b[12:16])
        d.directoryOffset = c.Uint32(b[16:20])
        d.commentLen = c.Uint16(b[20:22])
        d.comment = string(b[22 : 22+int(d.commentLen)])
        return d, nil
}
 
func findSignatureInBlock(b []byte) int {
        for i := len(b) - directoryEndLen; i >= 0; i-- {
                // defined from directoryEndSignature in struct.go
                if b[i] == 'P' && b[i+1] == 'K' && b[i+2] == 0x05 && b[i+3] == 0x06 {
                        // n is length of comment
                        n := int(b[i+directoryEndLen-2]) | int(b[i+directoryEndLen-1])<<8
                        if n+directoryEndLen+i == len(b) {
                                return i
                        }
                }
        }
        return -1
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [archive/] [zip/] [reader.go] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`// Copyright 2010 The Go Authors. All rights reserved.`
2			`// Use of this source code is governed by a BSD-style`
3			`// license that can be found in the LICENSE file.`
4
5			`package zip`
6
7			`import (`
8			`"bufio"`
9			`"compress/flate"`
10			`"encoding/binary"`
11			`"errors"`
12			`"hash"`
13			`"hash/crc32"`
14			`"io"`
15			`"io/ioutil"`
16			`"os"`
17			`)`
18
19			`var (`
20			`ErrFormat = errors.New("zip: not a valid zip file")`
21			`ErrAlgorithm = errors.New("zip: unsupported compression algorithm")`
22			`ErrChecksum = errors.New("zip: checksum error")`
23			`)`
24
25			`type Reader struct {`
26			`r io.ReaderAt`
27			`File []*File`
28			`Comment string`
29			`}`
30
31			`type ReadCloser struct {`
32			`f *os.File`
33			`Reader`
34			`}`
35
36			`type File struct {`
37			`FileHeader`
38			`zipr io.ReaderAt`
39			`zipsize int64`
40			`headerOffset int64`
41			`}`
42
43			`func (f *File) hasDataDescriptor() bool {`
44			`return f.Flags&0x8 != 0`
45			`}`
46
47			`// OpenReader will open the Zip file specified by name and return a ReadCloser.`
48			`func OpenReader(name string) (*ReadCloser, error) {`
49			`f, err := os.Open(name)`
50			`if err != nil {`
51			`return nil, err`
52			`}`
53			`fi, err := f.Stat()`
54			`if err != nil {`
55			`f.Close()`
56			`return nil, err`
57			`}`
58			`r := new(ReadCloser)`
59			`if err := r.init(f, fi.Size()); err != nil {`
60			`f.Close()`
61			`return nil, err`
62			`}`
63			`r.f = f`
64			`return r, nil`
65			`}`
66
67			`// NewReader returns a new Reader reading from r, which is assumed to`
68			`// have the given size in bytes.`
69			`func NewReader(r io.ReaderAt, size int64) (*Reader, error) {`
70			`zr := new(Reader)`
71			`if err := zr.init(r, size); err != nil {`
72			`return nil, err`
73			`}`
74			`return zr, nil`
75			`}`
76
77			`func (z *Reader) init(r io.ReaderAt, size int64) error {`
78			`end, err := readDirectoryEnd(r, size)`
79			`if err != nil {`
80			`return err`
81			`}`
82			`z.r = r`
83			`z.File = make([]*File, 0, end.directoryRecords)`
84			`z.Comment = end.comment`
85			`rs := io.NewSectionReader(r, 0, size)`
86			`if _, err = rs.Seek(int64(end.directoryOffset), os.SEEK_SET); err != nil {`
87			`return err`
88			`}`
89			`buf := bufio.NewReader(rs)`
90
91			`// The count of files inside a zip is truncated to fit in a uint16.`
92			`// Gloss over this by reading headers until we encounter`
93			`// a bad one, and then only report a ErrFormat or UnexpectedEOF if`
94			`// the file count modulo 65536 is incorrect.`
95			`for {`
96			`f := &File{zipr: r, zipsize: size}`
97			`err = readDirectoryHeader(f, buf)`
98			`if err == ErrFormat \|\| err == io.ErrUnexpectedEOF {`
99			`break`
100			`}`
101			`if err != nil {`
102			`return err`
103			`}`
104			`z.File = append(z.File, f)`
105			`}`
106			`if uint16(len(z.File)) != end.directoryRecords {`
107			`// Return the readDirectoryHeader error if we read`
108			`// the wrong number of directory entries.`
109			`return err`
110			`}`
111			`return nil`
112			`}`
113
114			`// Close closes the Zip file, rendering it unusable for I/O.`
115			`func (rc *ReadCloser) Close() error {`
116			`return rc.f.Close()`
117			`}`
118
119			`// Open returns a ReadCloser that provides access to the File's contents.`
120			`// Multiple files may be read concurrently.`
121			`func (f *File) Open() (rc io.ReadCloser, err error) {`
122			`bodyOffset, err := f.findBodyOffset()`
123			`if err != nil {`
124			`return`
125			`}`
126			`size := int64(f.CompressedSize)`
127			`if size == 0 && f.hasDataDescriptor() {`
128			`// permit SectionReader to see the rest of the file`
129			`size = f.zipsize - (f.headerOffset + bodyOffset)`
130			`}`
131			`r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset, size)`
132			`switch f.Method {`
133			`case Store: // (no compression)`
134			`rc = ioutil.NopCloser(r)`
135			`case Deflate:`
136			`rc = flate.NewReader(r)`
137			`default:`
138			`err = ErrAlgorithm`
139			`}`
140			`if rc != nil {`
141			`rc = &checksumReader{rc, crc32.NewIEEE(), f, r}`
142			`}`
143			`return`
144			`}`
145
146			`type checksumReader struct {`
147			`rc io.ReadCloser`
148			`hash hash.Hash32`
149			`f *File`
150			`zipr io.Reader // for reading the data descriptor`
151			`}`
152
153			`func (r *checksumReader) Read(b []byte) (n int, err error) {`
154			`n, err = r.rc.Read(b)`
155			`r.hash.Write(b[:n])`
156			`if err != io.EOF {`
157			`return`
158			`}`
159			`if r.f.hasDataDescriptor() {`
160			`if err = readDataDescriptor(r.zipr, r.f); err != nil {`
161			`return`
162			`}`
163			`}`
164			`if r.hash.Sum32() != r.f.CRC32 {`
165			`err = ErrChecksum`
166			`}`
167			`return`
168			`}`
169
170			`func (r *checksumReader) Close() error { return r.rc.Close() }`
171
172			`func readFileHeader(f *File, r io.Reader) error {`
173			`var b [fileHeaderLen]byte`
174			`if _, err := io.ReadFull(r, b[:]); err != nil {`
175			`return err`
176			`}`
177			`c := binary.LittleEndian`
178			`if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {`
179			`return ErrFormat`
180			`}`
181			`f.ReaderVersion = c.Uint16(b[4:6])`
182			`f.Flags = c.Uint16(b[6:8])`
183			`f.Method = c.Uint16(b[8:10])`
184			`f.ModifiedTime = c.Uint16(b[10:12])`
185			`f.ModifiedDate = c.Uint16(b[12:14])`
186			`f.CRC32 = c.Uint32(b[14:18])`
187			`f.CompressedSize = c.Uint32(b[18:22])`
188			`f.UncompressedSize = c.Uint32(b[22:26])`
189			`filenameLen := int(c.Uint16(b[26:28]))`
190			`extraLen := int(c.Uint16(b[28:30]))`
191			`d := make([]byte, filenameLen+extraLen)`
192			`if _, err := io.ReadFull(r, d); err != nil {`
193			`return err`
194			`}`
195			`f.Name = string(d[:filenameLen])`
196			`f.Extra = d[filenameLen:]`
197			`return nil`
198			`}`
199
200			`// findBodyOffset does the minimum work to verify the file has a header`
201			`// and returns the file body offset.`
202			`func (f *File) findBodyOffset() (int64, error) {`
203			`r := io.NewSectionReader(f.zipr, f.headerOffset, f.zipsize-f.headerOffset)`
204			`var b [fileHeaderLen]byte`
205			`if _, err := io.ReadFull(r, b[:]); err != nil {`
206			`return 0, err`
207			`}`
208			`c := binary.LittleEndian`
209			`if sig := c.Uint32(b[:4]); sig != fileHeaderSignature {`
210			`return 0, ErrFormat`
211			`}`
212			`filenameLen := int(c.Uint16(b[26:28]))`
213			`extraLen := int(c.Uint16(b[28:30]))`
214			`return int64(fileHeaderLen + filenameLen + extraLen), nil`
215			`}`
216
217			`// readDirectoryHeader attempts to read a directory header from r.`
218			`// It returns io.ErrUnexpectedEOF if it cannot read a complete header,`
219			`// and ErrFormat if it doesn't find a valid header signature.`
220			`func readDirectoryHeader(f *File, r io.Reader) error {`
221			`var b [directoryHeaderLen]byte`
222			`if _, err := io.ReadFull(r, b[:]); err != nil {`
223			`return err`
224			`}`
225			`c := binary.LittleEndian`
226			`if sig := c.Uint32(b[:4]); sig != directoryHeaderSignature {`
227			`return ErrFormat`
228			`}`
229			`f.CreatorVersion = c.Uint16(b[4:6])`
230			`f.ReaderVersion = c.Uint16(b[6:8])`
231			`f.Flags = c.Uint16(b[8:10])`
232			`f.Method = c.Uint16(b[10:12])`
233			`f.ModifiedTime = c.Uint16(b[12:14])`
234			`f.ModifiedDate = c.Uint16(b[14:16])`
235			`f.CRC32 = c.Uint32(b[16:20])`
236			`f.CompressedSize = c.Uint32(b[20:24])`
237			`f.UncompressedSize = c.Uint32(b[24:28])`
238			`filenameLen := int(c.Uint16(b[28:30]))`
239			`extraLen := int(c.Uint16(b[30:32]))`
240			`commentLen := int(c.Uint16(b[32:34]))`
241			`// startDiskNumber := c.Uint16(b[34:36]) // Unused`
242			`// internalAttributes := c.Uint16(b[36:38]) // Unused`
243			`f.ExternalAttrs = c.Uint32(b[38:42])`
244			`f.headerOffset = int64(c.Uint32(b[42:46]))`
245			`d := make([]byte, filenameLen+extraLen+commentLen)`
246			`if _, err := io.ReadFull(r, d); err != nil {`
247			`return err`
248			`}`
249			`f.Name = string(d[:filenameLen])`
250			`f.Extra = d[filenameLen : filenameLen+extraLen]`
251			`f.Comment = string(d[filenameLen+extraLen:])`
252			`return nil`
253			`}`
254
255			`func readDataDescriptor(r io.Reader, f *File) error {`
256			`var b [dataDescriptorLen]byte`
257			`if _, err := io.ReadFull(r, b[:]); err != nil {`
258			`return err`
259			`}`
260			`c := binary.LittleEndian`
261			`f.CRC32 = c.Uint32(b[:4])`
262			`f.CompressedSize = c.Uint32(b[4:8])`
263			`f.UncompressedSize = c.Uint32(b[8:12])`
264			`return nil`
265			`}`
266
267			`func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) {`
268			`// look for directoryEndSignature in the last 1k, then in the last 65k`
269			`var b []byte`
270			`for i, bLen := range []int64{1024, 65 * 1024} {`
271			`if bLen > size {`
272			`bLen = size`
273			`}`
274			`b = make([]byte, int(bLen))`
275			`if _, err := r.ReadAt(b, size-bLen); err != nil && err != io.EOF {`
276			`return nil, err`
277			`}`
278			`if p := findSignatureInBlock(b); p >= 0 {`
279			`b = b[p:]`
280			`break`
281			`}`
282			`if i == 1 \|\| bLen == size {`
283			`return nil, ErrFormat`
284			`}`
285			`}`
286
287			`// read header into struct`
288			`c := binary.LittleEndian`
289			`d := new(directoryEnd)`
290			`d.diskNbr = c.Uint16(b[4:6])`
291			`d.dirDiskNbr = c.Uint16(b[6:8])`
292			`d.dirRecordsThisDisk = c.Uint16(b[8:10])`
293			`d.directoryRecords = c.Uint16(b[10:12])`
294			`d.directorySize = c.Uint32(b[12:16])`
295			`d.directoryOffset = c.Uint32(b[16:20])`
296			`d.commentLen = c.Uint16(b[20:22])`
297			`d.comment = string(b[22 : 22+int(d.commentLen)])`
298			`return d, nil`
299			`}`
300
301			`func findSignatureInBlock(b []byte) int {`
302			`for i := len(b) - directoryEndLen; i >= 0; i-- {`
303			`// defined from directoryEndSignature in struct.go`
304			`if b[i] == 'P' && b[i+1] == 'K' && b[i+2] == 0x05 && b[i+3] == 0x06 {`
305			`// n is length of comment`
306			`n := int(b[i+directoryEndLen-2]) \| int(b[i+directoryEndLen-1])<<8`
307			`if n+directoryEndLen+i == len(b) {`
308			`return i`
309			`}`
310			`}`
311			`}`
312			`return -1`
313			`}`