| // 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 provides support for reading and writing ZIP archives. |
| |
| See: http://www.pkware.com/documents/casestudies/APPNOTE.TXT |
| |
| This package does not support ZIP64 or disk spanning. |
| */ |
| package zip |
| |
| import ( |
| "errors" |
| "os" |
| "time" |
| ) |
| |
| // Compression methods. |
| const ( |
| Store uint16 = 0 |
| Deflate uint16 = 8 |
| ) |
| |
| const ( |
| fileHeaderSignature = 0x04034b50 |
| directoryHeaderSignature = 0x02014b50 |
| directoryEndSignature = 0x06054b50 |
| fileHeaderLen = 30 // + filename + extra |
| directoryHeaderLen = 46 // + filename + extra + comment |
| directoryEndLen = 22 // + comment |
| dataDescriptorLen = 12 |
| |
| // Constants for the first byte in CreatorVersion |
| creatorFAT = 0 |
| creatorUnix = 3 |
| creatorNTFS = 11 |
| creatorVFAT = 14 |
| creatorMacOSX = 19 |
| ) |
| |
| type FileHeader struct { |
| Name string |
| CreatorVersion uint16 |
| ReaderVersion uint16 |
| Flags uint16 |
| Method uint16 |
| ModifiedTime uint16 // MS-DOS time |
| ModifiedDate uint16 // MS-DOS date |
| CRC32 uint32 |
| CompressedSize uint32 |
| UncompressedSize uint32 |
| Extra []byte |
| ExternalAttrs uint32 // Meaning depends on CreatorVersion |
| Comment string |
| } |
| |
| // FileInfo returns an os.FileInfo for the FileHeader. |
| func (h *FileHeader) FileInfo() os.FileInfo { |
| return headerFileInfo{h} |
| } |
| |
| // headerFileInfo implements os.FileInfo. |
| type headerFileInfo struct { |
| fh *FileHeader |
| } |
| |
| func (fi headerFileInfo) Name() string { return fi.fh.Name } |
| func (fi headerFileInfo) Size() int64 { return int64(fi.fh.UncompressedSize) } |
| func (fi headerFileInfo) IsDir() bool { return fi.Mode().IsDir() } |
| func (fi headerFileInfo) ModTime() time.Time { return fi.fh.ModTime() } |
| func (fi headerFileInfo) Mode() os.FileMode { return fi.fh.Mode() } |
| func (fi headerFileInfo) Sys() interface{} { return fi.fh } |
| |
| // FileInfoHeader creates a partially-populated FileHeader from an |
| // os.FileInfo. |
| func FileInfoHeader(fi os.FileInfo) (*FileHeader, error) { |
| size := fi.Size() |
| if size > (1<<32 - 1) { |
| return nil, errors.New("zip: file over 4GB") |
| } |
| fh := &FileHeader{ |
| Name: fi.Name(), |
| UncompressedSize: uint32(size), |
| } |
| fh.SetModTime(fi.ModTime()) |
| fh.SetMode(fi.Mode()) |
| return fh, nil |
| } |
| |
| type directoryEnd struct { |
| diskNbr uint16 // unused |
| dirDiskNbr uint16 // unused |
| dirRecordsThisDisk uint16 // unused |
| directoryRecords uint16 |
| directorySize uint32 |
| directoryOffset uint32 // relative to file |
| commentLen uint16 |
| comment string |
| } |
| |
| func recoverError(errp *error) { |
| if e := recover(); e != nil { |
| if err, ok := e.(error); ok { |
| *errp = err |
| return |
| } |
| panic(e) |
| } |
| } |
| |
| // msDosTimeToTime converts an MS-DOS date and time into a time.Time. |
| // The resolution is 2s. |
| // See: http://msdn.microsoft.com/en-us/library/ms724247(v=VS.85).aspx |
| func msDosTimeToTime(dosDate, dosTime uint16) time.Time { |
| return time.Date( |
| // date bits 0-4: day of month; 5-8: month; 9-15: years since 1980 |
| int(dosDate>>9+1980), |
| time.Month(dosDate>>5&0xf), |
| int(dosDate&0x1f), |
| |
| // time bits 0-4: second/2; 5-10: minute; 11-15: hour |
| int(dosTime>>11), |
| int(dosTime>>5&0x3f), |
| int(dosTime&0x1f*2), |
| 0, // nanoseconds |
| |
| time.UTC, |
| ) |
| } |
| |
| // timeToMsDosTime converts a time.Time to an MS-DOS date and time. |
| // The resolution is 2s. |
| // See: http://msdn.microsoft.com/en-us/library/ms724274(v=VS.85).aspx |
| func timeToMsDosTime(t time.Time) (fDate uint16, fTime uint16) { |
| t = t.In(time.UTC) |
| fDate = uint16(t.Day() + int(t.Month())<<5 + (t.Year()-1980)<<9) |
| fTime = uint16(t.Second()/2 + t.Minute()<<5 + t.Hour()<<11) |
| return |
| } |
| |
| // ModTime returns the modification time. |
| // The resolution is 2s. |
| func (h *FileHeader) ModTime() time.Time { |
| return msDosTimeToTime(h.ModifiedDate, h.ModifiedTime) |
| } |
| |
| // SetModTime sets the ModifiedTime and ModifiedDate fields to the given time. |
| // The resolution is 2s. |
| func (h *FileHeader) SetModTime(t time.Time) { |
| h.ModifiedDate, h.ModifiedTime = timeToMsDosTime(t) |
| } |
| |
| const ( |
| // Unix constants. The specification doesn't mention them, |
| // but these seem to be the values agreed on by tools. |
| s_IFMT = 0xf000 |
| s_IFSOCK = 0xc000 |
| s_IFLNK = 0xa000 |
| s_IFREG = 0x8000 |
| s_IFBLK = 0x6000 |
| s_IFDIR = 0x4000 |
| s_IFCHR = 0x2000 |
| s_IFIFO = 0x1000 |
| s_ISUID = 0x800 |
| s_ISGID = 0x400 |
| s_ISVTX = 0x200 |
| |
| msdosDir = 0x10 |
| msdosReadOnly = 0x01 |
| ) |
| |
| // Mode returns the permission and mode bits for the FileHeader. |
| func (h *FileHeader) Mode() (mode os.FileMode) { |
| switch h.CreatorVersion >> 8 { |
| case creatorUnix, creatorMacOSX: |
| mode = unixModeToFileMode(h.ExternalAttrs >> 16) |
| case creatorNTFS, creatorVFAT, creatorFAT: |
| mode = msdosModeToFileMode(h.ExternalAttrs) |
| } |
| if len(h.Name) > 0 && h.Name[len(h.Name)-1] == '/' { |
| mode |= os.ModeDir |
| } |
| return mode |
| } |
| |
| // SetMode changes the permission and mode bits for the FileHeader. |
| func (h *FileHeader) SetMode(mode os.FileMode) { |
| h.CreatorVersion = h.CreatorVersion&0xff | creatorUnix<<8 |
| h.ExternalAttrs = fileModeToUnixMode(mode) << 16 |
| |
| // set MSDOS attributes too, as the original zip does. |
| if mode&os.ModeDir != 0 { |
| h.ExternalAttrs |= msdosDir |
| } |
| if mode&0200 == 0 { |
| h.ExternalAttrs |= msdosReadOnly |
| } |
| } |
| |
| func msdosModeToFileMode(m uint32) (mode os.FileMode) { |
| if m&msdosDir != 0 { |
| mode = os.ModeDir | 0777 |
| } else { |
| mode = 0666 |
| } |
| if m&msdosReadOnly != 0 { |
| mode &^= 0222 |
| } |
| return mode |
| } |
| |
| func fileModeToUnixMode(mode os.FileMode) uint32 { |
| var m uint32 |
| switch mode & os.ModeType { |
| default: |
| m = s_IFREG |
| case os.ModeDir: |
| m = s_IFDIR |
| case os.ModeSymlink: |
| m = s_IFLNK |
| case os.ModeNamedPipe: |
| m = s_IFIFO |
| case os.ModeSocket: |
| m = s_IFSOCK |
| case os.ModeDevice: |
| if mode&os.ModeCharDevice != 0 { |
| m = s_IFCHR |
| } else { |
| m = s_IFBLK |
| } |
| } |
| if mode&os.ModeSetuid != 0 { |
| m |= s_ISUID |
| } |
| if mode&os.ModeSetgid != 0 { |
| m |= s_ISGID |
| } |
| if mode&os.ModeSticky != 0 { |
| m |= s_ISVTX |
| } |
| return m | uint32(mode&0777) |
| } |
| |
| func unixModeToFileMode(m uint32) os.FileMode { |
| mode := os.FileMode(m & 0777) |
| switch m & s_IFMT { |
| case s_IFBLK: |
| mode |= os.ModeDevice |
| case s_IFCHR: |
| mode |= os.ModeDevice | os.ModeCharDevice |
| case s_IFDIR: |
| mode |= os.ModeDir |
| case s_IFIFO: |
| mode |= os.ModeNamedPipe |
| case s_IFLNK: |
| mode |= os.ModeSymlink |
| case s_IFREG: |
| // nothing to do |
| case s_IFSOCK: |
| mode |= os.ModeSocket |
| } |
| if m&s_ISGID != 0 { |
| mode |= os.ModeSetgid |
| } |
| if m&s_ISUID != 0 { |
| mode |= os.ModeSetuid |
| } |
| if m&s_ISVTX != 0 { |
| mode |= os.ModeSticky |
| } |
| return mode |
| } |
