summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/net/webdav/file.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/net/webdav/file.go')
-rw-r--r--vendor/golang.org/x/net/webdav/file.go796
1 files changed, 0 insertions, 796 deletions
diff --git a/vendor/golang.org/x/net/webdav/file.go b/vendor/golang.org/x/net/webdav/file.go
deleted file mode 100644
index 748118d..0000000
--- a/vendor/golang.org/x/net/webdav/file.go
+++ /dev/null
@@ -1,796 +0,0 @@
-// Copyright 2014 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 webdav
-
-import (
- "encoding/xml"
- "io"
- "net/http"
- "os"
- "path"
- "path/filepath"
- "strings"
- "sync"
- "time"
-
- "golang.org/x/net/context"
-)
-
-// slashClean is equivalent to but slightly more efficient than
-// path.Clean("/" + name).
-func slashClean(name string) string {
- if name == "" || name[0] != '/' {
- name = "/" + name
- }
- return path.Clean(name)
-}
-
-// A FileSystem implements access to a collection of named files. The elements
-// in a file path are separated by slash ('/', U+002F) characters, regardless
-// of host operating system convention.
-//
-// Each method has the same semantics as the os package's function of the same
-// name.
-//
-// Note that the os.Rename documentation says that "OS-specific restrictions
-// might apply". In particular, whether or not renaming a file or directory
-// overwriting another existing file or directory is an error is OS-dependent.
-type FileSystem interface {
- Mkdir(ctx context.Context, name string, perm os.FileMode) error
- OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error)
- RemoveAll(ctx context.Context, name string) error
- Rename(ctx context.Context, oldName, newName string) error
- Stat(ctx context.Context, name string) (os.FileInfo, error)
-}
-
-// A File is returned by a FileSystem's OpenFile method and can be served by a
-// Handler.
-//
-// A File may optionally implement the DeadPropsHolder interface, if it can
-// load and save dead properties.
-type File interface {
- http.File
- io.Writer
-}
-
-// A Dir implements FileSystem using the native file system restricted to a
-// specific directory tree.
-//
-// While the FileSystem.OpenFile method takes '/'-separated paths, a Dir's
-// string value is a filename on the native file system, not a URL, so it is
-// separated by filepath.Separator, which isn't necessarily '/'.
-//
-// An empty Dir is treated as ".".
-type Dir string
-
-func (d Dir) resolve(name string) string {
- // This implementation is based on Dir.Open's code in the standard net/http package.
- if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 ||
- strings.Contains(name, "\x00") {
- return ""
- }
- dir := string(d)
- if dir == "" {
- dir = "."
- }
- return filepath.Join(dir, filepath.FromSlash(slashClean(name)))
-}
-
-func (d Dir) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- if name = d.resolve(name); name == "" {
- return os.ErrNotExist
- }
- return os.Mkdir(name, perm)
-}
-
-func (d Dir) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
- if name = d.resolve(name); name == "" {
- return nil, os.ErrNotExist
- }
- f, err := os.OpenFile(name, flag, perm)
- if err != nil {
- return nil, err
- }
- return f, nil
-}
-
-func (d Dir) RemoveAll(ctx context.Context, name string) error {
- if name = d.resolve(name); name == "" {
- return os.ErrNotExist
- }
- if name == filepath.Clean(string(d)) {
- // Prohibit removing the virtual root directory.
- return os.ErrInvalid
- }
- return os.RemoveAll(name)
-}
-
-func (d Dir) Rename(ctx context.Context, oldName, newName string) error {
- if oldName = d.resolve(oldName); oldName == "" {
- return os.ErrNotExist
- }
- if newName = d.resolve(newName); newName == "" {
- return os.ErrNotExist
- }
- if root := filepath.Clean(string(d)); root == oldName || root == newName {
- // Prohibit renaming from or to the virtual root directory.
- return os.ErrInvalid
- }
- return os.Rename(oldName, newName)
-}
-
-func (d Dir) Stat(ctx context.Context, name string) (os.FileInfo, error) {
- if name = d.resolve(name); name == "" {
- return nil, os.ErrNotExist
- }
- return os.Stat(name)
-}
-
-// NewMemFS returns a new in-memory FileSystem implementation.
-func NewMemFS() FileSystem {
- return &memFS{
- root: memFSNode{
- children: make(map[string]*memFSNode),
- mode: 0660 | os.ModeDir,
- modTime: time.Now(),
- },
- }
-}
-
-// A memFS implements FileSystem, storing all metadata and actual file data
-// in-memory. No limits on filesystem size are used, so it is not recommended
-// this be used where the clients are untrusted.
-//
-// Concurrent access is permitted. The tree structure is protected by a mutex,
-// and each node's contents and metadata are protected by a per-node mutex.
-//
-// TODO: Enforce file permissions.
-type memFS struct {
- mu sync.Mutex
- root memFSNode
-}
-
-// TODO: clean up and rationalize the walk/find code.
-
-// walk walks the directory tree for the fullname, calling f at each step. If f
-// returns an error, the walk will be aborted and return that same error.
-//
-// dir is the directory at that step, frag is the name fragment, and final is
-// whether it is the final step. For example, walking "/foo/bar/x" will result
-// in 3 calls to f:
-// - "/", "foo", false
-// - "/foo/", "bar", false
-// - "/foo/bar/", "x", true
-// The frag argument will be empty only if dir is the root node and the walk
-// ends at that root node.
-func (fs *memFS) walk(op, fullname string, f func(dir *memFSNode, frag string, final bool) error) error {
- original := fullname
- fullname = slashClean(fullname)
-
- // Strip any leading "/"s to make fullname a relative path, as the walk
- // starts at fs.root.
- if fullname[0] == '/' {
- fullname = fullname[1:]
- }
- dir := &fs.root
-
- for {
- frag, remaining := fullname, ""
- i := strings.IndexRune(fullname, '/')
- final := i < 0
- if !final {
- frag, remaining = fullname[:i], fullname[i+1:]
- }
- if frag == "" && dir != &fs.root {
- panic("webdav: empty path fragment for a clean path")
- }
- if err := f(dir, frag, final); err != nil {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: err,
- }
- }
- if final {
- break
- }
- child := dir.children[frag]
- if child == nil {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: os.ErrNotExist,
- }
- }
- if !child.mode.IsDir() {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: os.ErrInvalid,
- }
- }
- dir, fullname = child, remaining
- }
- return nil
-}
-
-// find returns the parent of the named node and the relative name fragment
-// from the parent to the child. For example, if finding "/foo/bar/baz" then
-// parent will be the node for "/foo/bar" and frag will be "baz".
-//
-// If the fullname names the root node, then parent, frag and err will be zero.
-//
-// find returns an error if the parent does not already exist or the parent
-// isn't a directory, but it will not return an error per se if the child does
-// not already exist. The error returned is either nil or an *os.PathError
-// whose Op is op.
-func (fs *memFS) find(op, fullname string) (parent *memFSNode, frag string, err error) {
- err = fs.walk(op, fullname, func(parent0 *memFSNode, frag0 string, final bool) error {
- if !final {
- return nil
- }
- if frag0 != "" {
- parent, frag = parent0, frag0
- }
- return nil
- })
- return parent, frag, err
-}
-
-func (fs *memFS) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("mkdir", name)
- if err != nil {
- return err
- }
- if dir == nil {
- // We can't create the root.
- return os.ErrInvalid
- }
- if _, ok := dir.children[frag]; ok {
- return os.ErrExist
- }
- dir.children[frag] = &memFSNode{
- children: make(map[string]*memFSNode),
- mode: perm.Perm() | os.ModeDir,
- modTime: time.Now(),
- }
- return nil
-}
-
-func (fs *memFS) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("open", name)
- if err != nil {
- return nil, err
- }
- var n *memFSNode
- if dir == nil {
- // We're opening the root.
- if flag&(os.O_WRONLY|os.O_RDWR) != 0 {
- return nil, os.ErrPermission
- }
- n, frag = &fs.root, "/"
-
- } else {
- n = dir.children[frag]
- if flag&(os.O_SYNC|os.O_APPEND) != 0 {
- // memFile doesn't support these flags yet.
- return nil, os.ErrInvalid
- }
- if flag&os.O_CREATE != 0 {
- if flag&os.O_EXCL != 0 && n != nil {
- return nil, os.ErrExist
- }
- if n == nil {
- n = &memFSNode{
- mode: perm.Perm(),
- }
- dir.children[frag] = n
- }
- }
- if n == nil {
- return nil, os.ErrNotExist
- }
- if flag&(os.O_WRONLY|os.O_RDWR) != 0 && flag&os.O_TRUNC != 0 {
- n.mu.Lock()
- n.data = nil
- n.mu.Unlock()
- }
- }
-
- children := make([]os.FileInfo, 0, len(n.children))
- for cName, c := range n.children {
- children = append(children, c.stat(cName))
- }
- return &memFile{
- n: n,
- nameSnapshot: frag,
- childrenSnapshot: children,
- }, nil
-}
-
-func (fs *memFS) RemoveAll(ctx context.Context, name string) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("remove", name)
- if err != nil {
- return err
- }
- if dir == nil {
- // We can't remove the root.
- return os.ErrInvalid
- }
- delete(dir.children, frag)
- return nil
-}
-
-func (fs *memFS) Rename(ctx context.Context, oldName, newName string) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- oldName = slashClean(oldName)
- newName = slashClean(newName)
- if oldName == newName {
- return nil
- }
- if strings.HasPrefix(newName, oldName+"/") {
- // We can't rename oldName to be a sub-directory of itself.
- return os.ErrInvalid
- }
-
- oDir, oFrag, err := fs.find("rename", oldName)
- if err != nil {
- return err
- }
- if oDir == nil {
- // We can't rename from the root.
- return os.ErrInvalid
- }
-
- nDir, nFrag, err := fs.find("rename", newName)
- if err != nil {
- return err
- }
- if nDir == nil {
- // We can't rename to the root.
- return os.ErrInvalid
- }
-
- oNode, ok := oDir.children[oFrag]
- if !ok {
- return os.ErrNotExist
- }
- if oNode.children != nil {
- if nNode, ok := nDir.children[nFrag]; ok {
- if nNode.children == nil {
- return errNotADirectory
- }
- if len(nNode.children) != 0 {
- return errDirectoryNotEmpty
- }
- }
- }
- delete(oDir.children, oFrag)
- nDir.children[nFrag] = oNode
- return nil
-}
-
-func (fs *memFS) Stat(ctx context.Context, name string) (os.FileInfo, error) {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("stat", name)
- if err != nil {
- return nil, err
- }
- if dir == nil {
- // We're stat'ting the root.
- return fs.root.stat("/"), nil
- }
- if n, ok := dir.children[frag]; ok {
- return n.stat(path.Base(name)), nil
- }
- return nil, os.ErrNotExist
-}
-
-// A memFSNode represents a single entry in the in-memory filesystem and also
-// implements os.FileInfo.
-type memFSNode struct {
- // children is protected by memFS.mu.
- children map[string]*memFSNode
-
- mu sync.Mutex
- data []byte
- mode os.FileMode
- modTime time.Time
- deadProps map[xml.Name]Property
-}
-
-func (n *memFSNode) stat(name string) *memFileInfo {
- n.mu.Lock()
- defer n.mu.Unlock()
- return &memFileInfo{
- name: name,
- size: int64(len(n.data)),
- mode: n.mode,
- modTime: n.modTime,
- }
-}
-
-func (n *memFSNode) DeadProps() (map[xml.Name]Property, error) {
- n.mu.Lock()
- defer n.mu.Unlock()
- if len(n.deadProps) == 0 {
- return nil, nil
- }
- ret := make(map[xml.Name]Property, len(n.deadProps))
- for k, v := range n.deadProps {
- ret[k] = v
- }
- return ret, nil
-}
-
-func (n *memFSNode) Patch(patches []Proppatch) ([]Propstat, error) {
- n.mu.Lock()
- defer n.mu.Unlock()
- pstat := Propstat{Status: http.StatusOK}
- for _, patch := range patches {
- for _, p := range patch.Props {
- pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName})
- if patch.Remove {
- delete(n.deadProps, p.XMLName)
- continue
- }
- if n.deadProps == nil {
- n.deadProps = map[xml.Name]Property{}
- }
- n.deadProps[p.XMLName] = p
- }
- }
- return []Propstat{pstat}, nil
-}
-
-type memFileInfo struct {
- name string
- size int64
- mode os.FileMode
- modTime time.Time
-}
-
-func (f *memFileInfo) Name() string { return f.name }
-func (f *memFileInfo) Size() int64 { return f.size }
-func (f *memFileInfo) Mode() os.FileMode { return f.mode }
-func (f *memFileInfo) ModTime() time.Time { return f.modTime }
-func (f *memFileInfo) IsDir() bool { return f.mode.IsDir() }
-func (f *memFileInfo) Sys() interface{} { return nil }
-
-// A memFile is a File implementation for a memFSNode. It is a per-file (not
-// per-node) read/write position, and a snapshot of the memFS' tree structure
-// (a node's name and children) for that node.
-type memFile struct {
- n *memFSNode
- nameSnapshot string
- childrenSnapshot []os.FileInfo
- // pos is protected by n.mu.
- pos int
-}
-
-// A *memFile implements the optional DeadPropsHolder interface.
-var _ DeadPropsHolder = (*memFile)(nil)
-
-func (f *memFile) DeadProps() (map[xml.Name]Property, error) { return f.n.DeadProps() }
-func (f *memFile) Patch(patches []Proppatch) ([]Propstat, error) { return f.n.Patch(patches) }
-
-func (f *memFile) Close() error {
- return nil
-}
-
-func (f *memFile) Read(p []byte) (int, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- if f.n.mode.IsDir() {
- return 0, os.ErrInvalid
- }
- if f.pos >= len(f.n.data) {
- return 0, io.EOF
- }
- n := copy(p, f.n.data[f.pos:])
- f.pos += n
- return n, nil
-}
-
-func (f *memFile) Readdir(count int) ([]os.FileInfo, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- if !f.n.mode.IsDir() {
- return nil, os.ErrInvalid
- }
- old := f.pos
- if old >= len(f.childrenSnapshot) {
- // The os.File Readdir docs say that at the end of a directory,
- // the error is io.EOF if count > 0 and nil if count <= 0.
- if count > 0 {
- return nil, io.EOF
- }
- return nil, nil
- }
- if count > 0 {
- f.pos += count
- if f.pos > len(f.childrenSnapshot) {
- f.pos = len(f.childrenSnapshot)
- }
- } else {
- f.pos = len(f.childrenSnapshot)
- old = 0
- }
- return f.childrenSnapshot[old:f.pos], nil
-}
-
-func (f *memFile) Seek(offset int64, whence int) (int64, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- npos := f.pos
- // TODO: How to handle offsets greater than the size of system int?
- switch whence {
- case os.SEEK_SET:
- npos = int(offset)
- case os.SEEK_CUR:
- npos += int(offset)
- case os.SEEK_END:
- npos = len(f.n.data) + int(offset)
- default:
- npos = -1
- }
- if npos < 0 {
- return 0, os.ErrInvalid
- }
- f.pos = npos
- return int64(f.pos), nil
-}
-
-func (f *memFile) Stat() (os.FileInfo, error) {
- return f.n.stat(f.nameSnapshot), nil
-}
-
-func (f *memFile) Write(p []byte) (int, error) {
- lenp := len(p)
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
-
- if f.n.mode.IsDir() {
- return 0, os.ErrInvalid
- }
- if f.pos < len(f.n.data) {
- n := copy(f.n.data[f.pos:], p)
- f.pos += n
- p = p[n:]
- } else if f.pos > len(f.n.data) {
- // Write permits the creation of holes, if we've seek'ed past the
- // existing end of file.
- if f.pos <= cap(f.n.data) {
- oldLen := len(f.n.data)
- f.n.data = f.n.data[:f.pos]
- hole := f.n.data[oldLen:]
- for i := range hole {
- hole[i] = 0
- }
- } else {
- d := make([]byte, f.pos, f.pos+len(p))
- copy(d, f.n.data)
- f.n.data = d
- }
- }
-
- if len(p) > 0 {
- // We should only get here if f.pos == len(f.n.data).
- f.n.data = append(f.n.data, p...)
- f.pos = len(f.n.data)
- }
- f.n.modTime = time.Now()
- return lenp, nil
-}
-
-// moveFiles moves files and/or directories from src to dst.
-//
-// See section 9.9.4 for when various HTTP status codes apply.
-func moveFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool) (status int, err error) {
- created := false
- if _, err := fs.Stat(ctx, dst); err != nil {
- if !os.IsNotExist(err) {
- return http.StatusForbidden, err
- }
- created = true
- } else if overwrite {
- // Section 9.9.3 says that "If a resource exists at the destination
- // and the Overwrite header is "T", then prior to performing the move,
- // the server must perform a DELETE with "Depth: infinity" on the
- // destination resource.
- if err := fs.RemoveAll(ctx, dst); err != nil {
- return http.StatusForbidden, err
- }
- } else {
- return http.StatusPreconditionFailed, os.ErrExist
- }
- if err := fs.Rename(ctx, src, dst); err != nil {
- return http.StatusForbidden, err
- }
- if created {
- return http.StatusCreated, nil
- }
- return http.StatusNoContent, nil
-}
-
-func copyProps(dst, src File) error {
- d, ok := dst.(DeadPropsHolder)
- if !ok {
- return nil
- }
- s, ok := src.(DeadPropsHolder)
- if !ok {
- return nil
- }
- m, err := s.DeadProps()
- if err != nil {
- return err
- }
- props := make([]Property, 0, len(m))
- for _, prop := range m {
- props = append(props, prop)
- }
- _, err = d.Patch([]Proppatch{{Props: props}})
- return err
-}
-
-// copyFiles copies files and/or directories from src to dst.
-//
-// See section 9.8.5 for when various HTTP status codes apply.
-func copyFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool, depth int, recursion int) (status int, err error) {
- if recursion == 1000 {
- return http.StatusInternalServerError, errRecursionTooDeep
- }
- recursion++
-
- // TODO: section 9.8.3 says that "Note that an infinite-depth COPY of /A/
- // into /A/B/ could lead to infinite recursion if not handled correctly."
-
- srcFile, err := fs.OpenFile(ctx, src, os.O_RDONLY, 0)
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusNotFound, err
- }
- return http.StatusInternalServerError, err
- }
- defer srcFile.Close()
- srcStat, err := srcFile.Stat()
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusNotFound, err
- }
- return http.StatusInternalServerError, err
- }
- srcPerm := srcStat.Mode() & os.ModePerm
-
- created := false
- if _, err := fs.Stat(ctx, dst); err != nil {
- if os.IsNotExist(err) {
- created = true
- } else {
- return http.StatusForbidden, err
- }
- } else {
- if !overwrite {
- return http.StatusPreconditionFailed, os.ErrExist
- }
- if err := fs.RemoveAll(ctx, dst); err != nil && !os.IsNotExist(err) {
- return http.StatusForbidden, err
- }
- }
-
- if srcStat.IsDir() {
- if err := fs.Mkdir(ctx, dst, srcPerm); err != nil {
- return http.StatusForbidden, err
- }
- if depth == infiniteDepth {
- children, err := srcFile.Readdir(-1)
- if err != nil {
- return http.StatusForbidden, err
- }
- for _, c := range children {
- name := c.Name()
- s := path.Join(src, name)
- d := path.Join(dst, name)
- cStatus, cErr := copyFiles(ctx, fs, s, d, overwrite, depth, recursion)
- if cErr != nil {
- // TODO: MultiStatus.
- return cStatus, cErr
- }
- }
- }
-
- } else {
- dstFile, err := fs.OpenFile(ctx, dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, srcPerm)
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusConflict, err
- }
- return http.StatusForbidden, err
-
- }
- _, copyErr := io.Copy(dstFile, srcFile)
- propsErr := copyProps(dstFile, srcFile)
- closeErr := dstFile.Close()
- if copyErr != nil {
- return http.StatusInternalServerError, copyErr
- }
- if propsErr != nil {
- return http.StatusInternalServerError, propsErr
- }
- if closeErr != nil {
- return http.StatusInternalServerError, closeErr
- }
- }
-
- if created {
- return http.StatusCreated, nil
- }
- return http.StatusNoContent, nil
-}
-
-// walkFS traverses filesystem fs starting at name up to depth levels.
-//
-// Allowed values for depth are 0, 1 or infiniteDepth. For each visited node,
-// walkFS calls walkFn. If a visited file system node is a directory and
-// walkFn returns filepath.SkipDir, walkFS will skip traversal of this node.
-func walkFS(ctx context.Context, fs FileSystem, depth int, name string, info os.FileInfo, walkFn filepath.WalkFunc) error {
- // This implementation is based on Walk's code in the standard path/filepath package.
- err := walkFn(name, info, nil)
- if err != nil {
- if info.IsDir() && err == filepath.SkipDir {
- return nil
- }
- return err
- }
- if !info.IsDir() || depth == 0 {
- return nil
- }
- if depth == 1 {
- depth = 0
- }
-
- // Read directory names.
- f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
- if err != nil {
- return walkFn(name, info, err)
- }
- fileInfos, err := f.Readdir(0)
- f.Close()
- if err != nil {
- return walkFn(name, info, err)
- }
-
- for _, fileInfo := range fileInfos {
- filename := path.Join(name, fileInfo.Name())
- fileInfo, err := fs.Stat(ctx, filename)
- if err != nil {
- if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
- return err
- }
- } else {
- err = walkFS(ctx, fs, depth, filename, fileInfo, walkFn)
- if err != nil {
- if !fileInfo.IsDir() || err != filepath.SkipDir {
- return err
- }
- }
- }
- }
- return nil
-}