vendor/github.com/spf13/afero/basepath.go

   1 package afero
   2
   3 import (
   4         "os"
   5         "path/filepath"
   6         "runtime"
   7         "strings"
   8         "time"
   9 )
  10
  11 var _ Lstater = (*BasePathFs)(nil)
  12
  13 // The BasePathFs restricts all operations to a given path within an Fs.
  14 // The given file name to the operations on this Fs will be prepended with
  15 // the base path before calling the base Fs.
  16 // Any file name (after filepath.Clean()) outside this base path will be
  17 // treated as non existing file.
  18 //
  19 // Note that it does not clean the error messages on return, so you may
  20 // reveal the real path on errors.
  21 type BasePathFs struct {
  22         source Fs
  23         path   string
  24 }
  25
  26 type BasePathFile struct {
  27         File
  28         path string
  29 }
  30
  31 func (f *BasePathFile) Name() string {
  32         sourcename := f.File.Name()
  33         return strings.TrimPrefix(sourcename, filepath.Clean(f.path))
  34 }
  35
  36 func NewBasePathFs(source Fs, path string) Fs {
  37         return &BasePathFs{source: source, path: path}
  38 }
  39
  40 // on a file outside the base path it returns the given file name and an error,
  41 // else the given file with the base path prepended
  42 func (b *BasePathFs) RealPath(name string) (path string, err error) {
  43         if err := validateBasePathName(name); err != nil {
  44                 return name, err
  45         }
  46
  47         bpath := filepath.Clean(b.path)
  48         path = filepath.Clean(filepath.Join(bpath, name))
  49         if !strings.HasPrefix(path, bpath) {
  50                 return name, os.ErrNotExist
  51         }
  52
  53         return path, nil
  54 }
  55
  56 func validateBasePathName(name string) error {
  57         if runtime.GOOS != "windows" {
  58                 // Not much to do here;
  59                 // the virtual file paths all look absolute on *nix.
  60                 return nil
  61         }
  62
  63         // On Windows a common mistake would be to provide an absolute OS path
  64         // We could strip out the base part, but that would not be very portable.
  65         if filepath.IsAbs(name) {
  66                 return os.ErrNotExist
  67         }
  68
  69         return nil
  70 }
  71
  72 func (b *BasePathFs) Chtimes(name string, atime, mtime time.Time) (err error) {
  73         if name, err = b.RealPath(name); err != nil {
  74                 return &os.PathError{Op: "chtimes", Path: name, Err: err}
  75         }
  76         return b.source.Chtimes(name, atime, mtime)
  77 }
  78
  79 func (b *BasePathFs) Chmod(name string, mode os.FileMode) (err error) {
  80         if name, err = b.RealPath(name); err != nil {
  81                 return &os.PathError{Op: "chmod", Path: name, Err: err}
  82         }
  83         return b.source.Chmod(name, mode)
  84 }
  85
  86 func (b *BasePathFs) Name() string {
  87         return "BasePathFs"
  88 }
  89
  90 func (b *BasePathFs) Stat(name string) (fi os.FileInfo, err error) {
  91         if name, err = b.RealPath(name); err != nil {
  92                 return nil, &os.PathError{Op: "stat", Path: name, Err: err}
  93         }
  94         return b.source.Stat(name)
  95 }
  96
  97 func (b *BasePathFs) Rename(oldname, newname string) (err error) {
  98         if oldname, err = b.RealPath(oldname); err != nil {
  99                 return &os.PathError{Op: "rename", Path: oldname, Err: err}
 100         }
 101         if newname, err = b.RealPath(newname); err != nil {
 102                 return &os.PathError{Op: "rename", Path: newname, Err: err}
 103         }
 104         return b.source.Rename(oldname, newname)
 105 }
 106
 107 func (b *BasePathFs) RemoveAll(name string) (err error) {
 108         if name, err = b.RealPath(name); err != nil {
 109                 return &os.PathError{Op: "remove_all", Path: name, Err: err}
 110         }
 111         return b.source.RemoveAll(name)
 112 }
 113
 114 func (b *BasePathFs) Remove(name string) (err error) {
 115         if name, err = b.RealPath(name); err != nil {
 116                 return &os.PathError{Op: "remove", Path: name, Err: err}
 117         }
 118         return b.source.Remove(name)
 119 }
 120
 121 func (b *BasePathFs) OpenFile(name string, flag int, mode os.FileMode) (f File, err error) {
 122         if name, err = b.RealPath(name); err != nil {
 123                 return nil, &os.PathError{Op: "openfile", Path: name, Err: err}
 124         }
 125         sourcef, err := b.source.OpenFile(name, flag, mode)
 126         if err != nil {
 127                 return nil, err
 128         }
 129         return &BasePathFile{sourcef, b.path}, nil
 130 }
 131
 132 func (b *BasePathFs) Open(name string) (f File, err error) {
 133         if name, err = b.RealPath(name); err != nil {
 134                 return nil, &os.PathError{Op: "open", Path: name, Err: err}
 135         }
 136         sourcef, err := b.source.Open(name)
 137         if err != nil {
 138                 return nil, err
 139         }
 140         return &BasePathFile{File: sourcef, path: b.path}, nil
 141 }
 142
 143 func (b *BasePathFs) Mkdir(name string, mode os.FileMode) (err error) {
 144         if name, err = b.RealPath(name); err != nil {
 145                 return &os.PathError{Op: "mkdir", Path: name, Err: err}
 146         }
 147         return b.source.Mkdir(name, mode)
 148 }
 149
 150 func (b *BasePathFs) MkdirAll(name string, mode os.FileMode) (err error) {
 151         if name, err = b.RealPath(name); err != nil {
 152                 return &os.PathError{Op: "mkdir", Path: name, Err: err}
 153         }
 154         return b.source.MkdirAll(name, mode)
 155 }
 156
 157 func (b *BasePathFs) Create(name string) (f File, err error) {
 158         if name, err = b.RealPath(name); err != nil {
 159                 return nil, &os.PathError{Op: "create", Path: name, Err: err}
 160         }
 161         sourcef, err := b.source.Create(name)
 162         if err != nil {
 163                 return nil, err
 164         }
 165         return &BasePathFile{File: sourcef, path: b.path}, nil
 166 }
 167
 168 func (b *BasePathFs) LstatIfPossible(name string) (os.FileInfo, bool, error) {
 169         name, err := b.RealPath(name)
 170         if err != nil {
 171                 return nil, false, &os.PathError{Op: "lstat", Path: name, Err: err}
 172         }
 173         if lstater, ok := b.source.(Lstater); ok {
 174                 return lstater.LstatIfPossible(name)
 175         }
 176         fi, err := b.source.Stat(name)
 177         return fi, false, err
 178 }
 179
 180 // vim: ts=4 sw=4 noexpandtab nolist syn=go