| 1 | // Copyright 2011 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 zipfs file provides an implementation of the FileSystem |
| 6 | // interface based on the contents of a .zip file. |
| 7 | // |
| 8 | // Assumptions: |
| 9 | // |
| 10 | // - The file paths stored in the zip file must use a slash ('/') as path |
| 11 | // separator; and they must be relative (i.e., they must not start with |
| 12 | // a '/' - this is usually the case if the file was created w/o special |
| 13 | // options). |
| 14 | // - The zip file system treats the file paths found in the zip internally |
| 15 | // like absolute paths w/o a leading '/'; i.e., the paths are considered |
| 16 | // relative to the root of the file system. |
| 17 | // - All path arguments to file system methods must be absolute paths. |
| 18 | package zipfs // import "golang.org/x/tools/godoc/vfs/zipfs" |
| 19 | |
| 20 | import ( |
| 21 | "archive/zip" |
| 22 | "fmt" |
| 23 | "go/build" |
| 24 | "io" |
| 25 | "os" |
| 26 | "path" |
| 27 | "path/filepath" |
| 28 | "sort" |
| 29 | "strings" |
| 30 | "time" |
| 31 | |
| 32 | "golang.org/x/tools/godoc/vfs" |
| 33 | ) |
| 34 | |
| 35 | // zipFI is the zip-file based implementation of FileInfo |
| 36 | type zipFI struct { |
| 37 | name string // directory-local name |
| 38 | file *zip.File // nil for a directory |
| 39 | } |
| 40 | |
| 41 | func (fi zipFI) Name() string { |
| 42 | return fi.name |
| 43 | } |
| 44 | |
| 45 | func (fi zipFI) Size() int64 { |
| 46 | if f := fi.file; f != nil { |
| 47 | return int64(f.UncompressedSize) |
| 48 | } |
| 49 | return 0 // directory |
| 50 | } |
| 51 | |
| 52 | func (fi zipFI) ModTime() time.Time { |
| 53 | if f := fi.file; f != nil { |
| 54 | return f.ModTime() |
| 55 | } |
| 56 | return time.Time{} // directory has no modified time entry |
| 57 | } |
| 58 | |
| 59 | func (fi zipFI) Mode() os.FileMode { |
| 60 | if fi.file == nil { |
| 61 | // Unix directories typically are executable, hence 555. |
| 62 | return os.ModeDir | 0555 |
| 63 | } |
| 64 | return 0444 |
| 65 | } |
| 66 | |
| 67 | func (fi zipFI) IsDir() bool { |
| 68 | return fi.file == nil |
| 69 | } |
| 70 | |
| 71 | func (fi zipFI) Sys() interface{} { |
| 72 | return nil |
| 73 | } |
| 74 | |
| 75 | // zipFS is the zip-file based implementation of FileSystem |
| 76 | type zipFS struct { |
| 77 | *zip.ReadCloser |
| 78 | list zipList |
| 79 | name string |
| 80 | } |
| 81 | |
| 82 | func (fs *zipFS) String() string { |
| 83 | return "zip(" + fs.name + ")" |
| 84 | } |
| 85 | |
| 86 | func (fs *zipFS) RootType(abspath string) vfs.RootType { |
| 87 | var t vfs.RootType |
| 88 | switch { |
| 89 | case exists(path.Join(vfs.GOROOT, abspath)): |
| 90 | t = vfs.RootTypeGoRoot |
| 91 | case isGoPath(abspath): |
| 92 | t = vfs.RootTypeGoPath |
| 93 | } |
| 94 | return t |
| 95 | } |
| 96 | |
| 97 | func isGoPath(abspath string) bool { |
| 98 | for _, p := range filepath.SplitList(build.Default.GOPATH) { |
| 99 | if exists(path.Join(p, abspath)) { |
| 100 | return true |
| 101 | } |
| 102 | } |
| 103 | return false |
| 104 | } |
| 105 | |
| 106 | func exists(path string) bool { |
| 107 | _, err := os.Stat(path) |
| 108 | return err == nil |
| 109 | } |
| 110 | |
| 111 | func (fs *zipFS) Close() error { |
| 112 | fs.list = nil |
| 113 | return fs.ReadCloser.Close() |
| 114 | } |
| 115 | |
| 116 | func zipPath(name string) (string, error) { |
| 117 | name = path.Clean(name) |
| 118 | if !path.IsAbs(name) { |
| 119 | return "", fmt.Errorf("stat: not an absolute path: %s", name) |
| 120 | } |
| 121 | return name[1:], nil // strip leading '/' |
| 122 | } |
| 123 | |
| 124 | func isRoot(abspath string) bool { |
| 125 | return path.Clean(abspath) == "/" |
| 126 | } |
| 127 | |
| 128 | func (fs *zipFS) stat(abspath string) (int, zipFI, error) { |
| 129 | if isRoot(abspath) { |
| 130 | return 0, zipFI{ |
| 131 | name: "", |
| 132 | file: nil, |
| 133 | }, nil |
| 134 | } |
| 135 | zippath, err := zipPath(abspath) |
| 136 | if err != nil { |
| 137 | return 0, zipFI{}, err |
| 138 | } |
| 139 | i, exact := fs.list.lookup(zippath) |
| 140 | if i < 0 { |
| 141 | // zippath has leading '/' stripped - print it explicitly |
| 142 | return -1, zipFI{}, &os.PathError{Path: "/" + zippath, Err: os.ErrNotExist} |
| 143 | } |
| 144 | _, name := path.Split(zippath) |
| 145 | var file *zip.File |
| 146 | if exact { |
| 147 | file = fs.list[i] // exact match found - must be a file |
| 148 | } |
| 149 | return i, zipFI{name, file}, nil |
| 150 | } |
| 151 | |
| 152 | func (fs *zipFS) Open(abspath string) (vfs.ReadSeekCloser, error) { |
| 153 | _, fi, err := fs.stat(abspath) |
| 154 | if err != nil { |
| 155 | return nil, err |
| 156 | } |
| 157 | if fi.IsDir() { |
| 158 | return nil, fmt.Errorf("Open: %s is a directory", abspath) |
| 159 | } |
| 160 | r, err := fi.file.Open() |
| 161 | if err != nil { |
| 162 | return nil, err |
| 163 | } |
| 164 | return &zipSeek{fi.file, r}, nil |
| 165 | } |
| 166 | |
| 167 | type zipSeek struct { |
| 168 | file *zip.File |
| 169 | io.ReadCloser |
| 170 | } |
| 171 | |
| 172 | func (f *zipSeek) Seek(offset int64, whence int) (int64, error) { |
| 173 | if whence == 0 && offset == 0 { |
| 174 | r, err := f.file.Open() |
| 175 | if err != nil { |
| 176 | return 0, err |
| 177 | } |
| 178 | f.Close() |
| 179 | f.ReadCloser = r |
| 180 | return 0, nil |
| 181 | } |
| 182 | return 0, fmt.Errorf("unsupported Seek in %s", f.file.Name) |
| 183 | } |
| 184 | |
| 185 | func (fs *zipFS) Lstat(abspath string) (os.FileInfo, error) { |
| 186 | _, fi, err := fs.stat(abspath) |
| 187 | return fi, err |
| 188 | } |
| 189 | |
| 190 | func (fs *zipFS) Stat(abspath string) (os.FileInfo, error) { |
| 191 | _, fi, err := fs.stat(abspath) |
| 192 | return fi, err |
| 193 | } |
| 194 | |
| 195 | func (fs *zipFS) ReadDir(abspath string) ([]os.FileInfo, error) { |
| 196 | i, fi, err := fs.stat(abspath) |
| 197 | if err != nil { |
| 198 | return nil, err |
| 199 | } |
| 200 | if !fi.IsDir() { |
| 201 | return nil, fmt.Errorf("ReadDir: %s is not a directory", abspath) |
| 202 | } |
| 203 | |
| 204 | var list []os.FileInfo |
| 205 | |
| 206 | // make dirname the prefix that file names must start with to be considered |
| 207 | // in this directory. we must special case the root directory because, per |
| 208 | // the spec of this package, zip file entries MUST NOT start with /, so we |
| 209 | // should not append /, as we would in every other case. |
| 210 | var dirname string |
| 211 | if isRoot(abspath) { |
| 212 | dirname = "" |
| 213 | } else { |
| 214 | zippath, err := zipPath(abspath) |
| 215 | if err != nil { |
| 216 | return nil, err |
| 217 | } |
| 218 | dirname = zippath + "/" |
| 219 | } |
| 220 | prevname := "" |
| 221 | for _, e := range fs.list[i:] { |
| 222 | if !strings.HasPrefix(e.Name, dirname) { |
| 223 | break // not in the same directory anymore |
| 224 | } |
| 225 | name := e.Name[len(dirname):] // local name |
| 226 | file := e |
| 227 | if i := strings.IndexRune(name, '/'); i >= 0 { |
| 228 | // We infer directories from files in subdirectories. |
| 229 | // If we have x/y, return a directory entry for x. |
| 230 | name = name[0:i] // keep local directory name only |
| 231 | file = nil |
| 232 | } |
| 233 | // If we have x/y and x/z, don't return two directory entries for x. |
| 234 | // TODO(gri): It should be possible to do this more efficiently |
| 235 | // by determining the (fs.list) range of local directory entries |
| 236 | // (via two binary searches). |
| 237 | if name != prevname { |
| 238 | list = append(list, zipFI{name, file}) |
| 239 | prevname = name |
| 240 | } |
| 241 | } |
| 242 | |
| 243 | return list, nil |
| 244 | } |
| 245 | |
| 246 | func New(rc *zip.ReadCloser, name string) vfs.FileSystem { |
| 247 | list := make(zipList, len(rc.File)) |
| 248 | copy(list, rc.File) // sort a copy of rc.File |
| 249 | sort.Sort(list) |
| 250 | return &zipFS{rc, list, name} |
| 251 | } |
| 252 | |
| 253 | type zipList []*zip.File |
| 254 | |
| 255 | // zipList implements sort.Interface |
| 256 | func (z zipList) Len() int { return len(z) } |
| 257 | func (z zipList) Less(i, j int) bool { return z[i].Name < z[j].Name } |
| 258 | func (z zipList) Swap(i, j int) { z[i], z[j] = z[j], z[i] } |
| 259 | |
| 260 | // lookup returns the smallest index of an entry with an exact match |
| 261 | // for name, or an inexact match starting with name/. If there is no |
| 262 | // such entry, the result is -1, false. |
| 263 | func (z zipList) lookup(name string) (index int, exact bool) { |
| 264 | // look for exact match first (name comes before name/ in z) |
| 265 | i := sort.Search(len(z), func(i int) bool { |
| 266 | return name <= z[i].Name |
| 267 | }) |
| 268 | if i >= len(z) { |
| 269 | return -1, false |
| 270 | } |
| 271 | // 0 <= i < len(z) |
| 272 | if z[i].Name == name { |
| 273 | return i, true |
| 274 | } |
| 275 | |
| 276 | // look for inexact match (must be in z[i:], if present) |
| 277 | z = z[i:] |
| 278 | name += "/" |
| 279 | j := sort.Search(len(z), func(i int) bool { |
| 280 | return name <= z[i].Name |
| 281 | }) |
| 282 | if j >= len(z) { |
| 283 | return -1, false |
| 284 | } |
| 285 | // 0 <= j < len(z) |
| 286 | if strings.HasPrefix(z[j].Name, name) { |
| 287 | return i + j, false |
| 288 | } |
| 289 | |
| 290 | return -1, false |
| 291 | } |
| 292 |
Members