Subversion Repositories openrisc

// 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

}