zicla
7 years ago
12 changed files with 7494 additions and 0 deletions
@ -0,0 +1,795 @@ |
|||||
|
// 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 dav |
||||
|
|
||||
|
import ( |
||||
|
"context" |
||||
|
"encoding/xml" |
||||
|
"io" |
||||
|
"net/http" |
||||
|
"os" |
||||
|
"path" |
||||
|
"path/filepath" |
||||
|
"strings" |
||||
|
"sync" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
// 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 |
||||
|
} |
||||
@ -0,0 +1,173 @@ |
|||||
|
// 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 dav |
||||
|
|
||||
|
// The If header is covered by Section 10.4.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#HEADER_If
|
||||
|
|
||||
|
import ( |
||||
|
"strings" |
||||
|
) |
||||
|
|
||||
|
// ifHeader is a disjunction (OR) of ifLists.
|
||||
|
type ifHeader struct { |
||||
|
lists []ifList |
||||
|
} |
||||
|
|
||||
|
// ifList is a conjunction (AND) of Conditions, and an optional resource tag.
|
||||
|
type ifList struct { |
||||
|
resourceTag string |
||||
|
conditions []Condition |
||||
|
} |
||||
|
|
||||
|
// parseIfHeader parses the "If: foo bar" HTTP header. The httpHeader string
|
||||
|
// should omit the "If:" prefix and have any "\r\n"s collapsed to a " ", as is
|
||||
|
// returned by req.Header.Get("If") for a http.Request req.
|
||||
|
func parseIfHeader(httpHeader string) (h ifHeader, ok bool) { |
||||
|
s := strings.TrimSpace(httpHeader) |
||||
|
switch tokenType, _, _ := lex(s); tokenType { |
||||
|
case '(': |
||||
|
return parseNoTagLists(s) |
||||
|
case angleTokenType: |
||||
|
return parseTaggedLists(s) |
||||
|
default: |
||||
|
return ifHeader{}, false |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func parseNoTagLists(s string) (h ifHeader, ok bool) { |
||||
|
for { |
||||
|
l, remaining, ok := parseList(s) |
||||
|
if !ok { |
||||
|
return ifHeader{}, false |
||||
|
} |
||||
|
h.lists = append(h.lists, l) |
||||
|
if remaining == "" { |
||||
|
return h, true |
||||
|
} |
||||
|
s = remaining |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func parseTaggedLists(s string) (h ifHeader, ok bool) { |
||||
|
resourceTag, n := "", 0 |
||||
|
for first := true; ; first = false { |
||||
|
tokenType, tokenStr, remaining := lex(s) |
||||
|
switch tokenType { |
||||
|
case angleTokenType: |
||||
|
if !first && n == 0 { |
||||
|
return ifHeader{}, false |
||||
|
} |
||||
|
resourceTag, n = tokenStr, 0 |
||||
|
s = remaining |
||||
|
case '(': |
||||
|
n++ |
||||
|
l, remaining, ok := parseList(s) |
||||
|
if !ok { |
||||
|
return ifHeader{}, false |
||||
|
} |
||||
|
l.resourceTag = resourceTag |
||||
|
h.lists = append(h.lists, l) |
||||
|
if remaining == "" { |
||||
|
return h, true |
||||
|
} |
||||
|
s = remaining |
||||
|
default: |
||||
|
return ifHeader{}, false |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func parseList(s string) (l ifList, remaining string, ok bool) { |
||||
|
tokenType, _, s := lex(s) |
||||
|
if tokenType != '(' { |
||||
|
return ifList{}, "", false |
||||
|
} |
||||
|
for { |
||||
|
tokenType, _, remaining = lex(s) |
||||
|
if tokenType == ')' { |
||||
|
if len(l.conditions) == 0 { |
||||
|
return ifList{}, "", false |
||||
|
} |
||||
|
return l, remaining, true |
||||
|
} |
||||
|
c, remaining, ok := parseCondition(s) |
||||
|
if !ok { |
||||
|
return ifList{}, "", false |
||||
|
} |
||||
|
l.conditions = append(l.conditions, c) |
||||
|
s = remaining |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func parseCondition(s string) (c Condition, remaining string, ok bool) { |
||||
|
tokenType, tokenStr, s := lex(s) |
||||
|
if tokenType == notTokenType { |
||||
|
c.Not = true |
||||
|
tokenType, tokenStr, s = lex(s) |
||||
|
} |
||||
|
switch tokenType { |
||||
|
case strTokenType, angleTokenType: |
||||
|
c.Token = tokenStr |
||||
|
case squareTokenType: |
||||
|
c.ETag = tokenStr |
||||
|
default: |
||||
|
return Condition{}, "", false |
||||
|
} |
||||
|
return c, s, true |
||||
|
} |
||||
|
|
||||
|
// Single-rune tokens like '(' or ')' have a token type equal to their rune.
|
||||
|
// All other tokens have a negative token type.
|
||||
|
const ( |
||||
|
errTokenType = rune(-1) |
||||
|
eofTokenType = rune(-2) |
||||
|
strTokenType = rune(-3) |
||||
|
notTokenType = rune(-4) |
||||
|
angleTokenType = rune(-5) |
||||
|
squareTokenType = rune(-6) |
||||
|
) |
||||
|
|
||||
|
func lex(s string) (tokenType rune, tokenStr string, remaining string) { |
||||
|
// The net/textproto Reader that parses the HTTP header will collapse
|
||||
|
// Linear White Space that spans multiple "\r\n" lines to a single " ",
|
||||
|
// so we don't need to look for '\r' or '\n'.
|
||||
|
for len(s) > 0 && (s[0] == '\t' || s[0] == ' ') { |
||||
|
s = s[1:] |
||||
|
} |
||||
|
if len(s) == 0 { |
||||
|
return eofTokenType, "", "" |
||||
|
} |
||||
|
i := 0 |
||||
|
loop: |
||||
|
for ; i < len(s); i++ { |
||||
|
switch s[i] { |
||||
|
case '\t', ' ', '(', ')', '<', '>', '[', ']': |
||||
|
break loop |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if i != 0 { |
||||
|
tokenStr, remaining = s[:i], s[i:] |
||||
|
if tokenStr == "Not" { |
||||
|
return notTokenType, "", remaining |
||||
|
} |
||||
|
return strTokenType, tokenStr, remaining |
||||
|
} |
||||
|
|
||||
|
j := 0 |
||||
|
switch s[0] { |
||||
|
case '<': |
||||
|
j, tokenType = strings.IndexByte(s, '>'), angleTokenType |
||||
|
case '[': |
||||
|
j, tokenType = strings.IndexByte(s, ']'), squareTokenType |
||||
|
default: |
||||
|
return rune(s[0]), "", s[1:] |
||||
|
} |
||||
|
if j < 0 { |
||||
|
return errTokenType, "", "" |
||||
|
} |
||||
|
return tokenType, s[1:j], s[j+1:] |
||||
|
} |
||||
File diff suppressed because it is too large
@ -0,0 +1,692 @@ |
|||||
|
// Copyright 2009 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 xml |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"encoding" |
||||
|
"errors" |
||||
|
"fmt" |
||||
|
"reflect" |
||||
|
"strconv" |
||||
|
"strings" |
||||
|
) |
||||
|
|
||||
|
// BUG(rsc): Mapping between XML elements and data structures is inherently flawed:
|
||||
|
// an XML element is an order-dependent collection of anonymous
|
||||
|
// values, while a data structure is an order-independent collection
|
||||
|
// of named values.
|
||||
|
// See package json for a textual representation more suitable
|
||||
|
// to data structures.
|
||||
|
|
||||
|
// Unmarshal parses the XML-encoded data and stores the result in
|
||||
|
// the value pointed to by v, which must be an arbitrary struct,
|
||||
|
// slice, or string. Well-formed data that does not fit into v is
|
||||
|
// discarded.
|
||||
|
//
|
||||
|
// Because Unmarshal uses the reflect package, it can only assign
|
||||
|
// to exported (upper case) fields. Unmarshal uses a case-sensitive
|
||||
|
// comparison to match XML element names to tag values and struct
|
||||
|
// field names.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element to a struct using the following rules.
|
||||
|
// In the rules, the tag of a field refers to the value associated with the
|
||||
|
// key 'xml' in the struct field's tag (see the example above).
|
||||
|
//
|
||||
|
// * If the struct has a field of type []byte or string with tag
|
||||
|
// ",innerxml", Unmarshal accumulates the raw XML nested inside the
|
||||
|
// element in that field. The rest of the rules still apply.
|
||||
|
//
|
||||
|
// * If the struct has a field named XMLName of type xml.Name,
|
||||
|
// Unmarshal records the element name in that field.
|
||||
|
//
|
||||
|
// * If the XMLName field has an associated tag of the form
|
||||
|
// "name" or "namespace-URL name", the XML element must have
|
||||
|
// the given name (and, optionally, name space) or else Unmarshal
|
||||
|
// returns an error.
|
||||
|
//
|
||||
|
// * If the XML element has an attribute whose name matches a
|
||||
|
// struct field name with an associated tag containing ",attr" or
|
||||
|
// the explicit name in a struct field tag of the form "name,attr",
|
||||
|
// Unmarshal records the attribute value in that field.
|
||||
|
//
|
||||
|
// * If the XML element contains character data, that data is
|
||||
|
// accumulated in the first struct field that has tag ",chardata".
|
||||
|
// The struct field may have type []byte or string.
|
||||
|
// If there is no such field, the character data is discarded.
|
||||
|
//
|
||||
|
// * If the XML element contains comments, they are accumulated in
|
||||
|
// the first struct field that has tag ",comment". The struct
|
||||
|
// field may have type []byte or string. If there is no such
|
||||
|
// field, the comments are discarded.
|
||||
|
//
|
||||
|
// * If the XML element contains a sub-element whose name matches
|
||||
|
// the prefix of a tag formatted as "a" or "a>b>c", unmarshal
|
||||
|
// will descend into the XML structure looking for elements with the
|
||||
|
// given names, and will map the innermost elements to that struct
|
||||
|
// field. A tag starting with ">" is equivalent to one starting
|
||||
|
// with the field name followed by ">".
|
||||
|
//
|
||||
|
// * If the XML element contains a sub-element whose name matches
|
||||
|
// a struct field's XMLName tag and the struct field has no
|
||||
|
// explicit name tag as per the previous rule, unmarshal maps
|
||||
|
// the sub-element to that struct field.
|
||||
|
//
|
||||
|
// * If the XML element contains a sub-element whose name matches a
|
||||
|
// field without any mode flags (",attr", ",chardata", etc), Unmarshal
|
||||
|
// maps the sub-element to that struct field.
|
||||
|
//
|
||||
|
// * If the XML element contains a sub-element that hasn't matched any
|
||||
|
// of the above rules and the struct has a field with tag ",any",
|
||||
|
// unmarshal maps the sub-element to that struct field.
|
||||
|
//
|
||||
|
// * An anonymous struct field is handled as if the fields of its
|
||||
|
// value were part of the outer struct.
|
||||
|
//
|
||||
|
// * A struct field with tag "-" is never unmarshalled into.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element to a string or []byte by saving the
|
||||
|
// concatenation of that element's character data in the string or
|
||||
|
// []byte. The saved []byte is never nil.
|
||||
|
//
|
||||
|
// Unmarshal maps an attribute value to a string or []byte by saving
|
||||
|
// the value in the string or slice.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element to a slice by extending the length of
|
||||
|
// the slice and mapping the element to the newly created value.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element or attribute value to a bool by
|
||||
|
// setting it to the boolean value represented by the string.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element or attribute value to an integer or
|
||||
|
// floating-point field by setting the field to the result of
|
||||
|
// interpreting the string value in decimal. There is no check for
|
||||
|
// overflow.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element to an xml.Name by recording the
|
||||
|
// element name.
|
||||
|
//
|
||||
|
// Unmarshal maps an XML element to a pointer by setting the pointer
|
||||
|
// to a freshly allocated value and then mapping the element to that value.
|
||||
|
//
|
||||
|
func Unmarshal(data []byte, v interface{}) error { |
||||
|
return NewDecoder(bytes.NewReader(data)).Decode(v) |
||||
|
} |
||||
|
|
||||
|
// Decode works like xml.Unmarshal, except it reads the decoder
|
||||
|
// stream to find the start element.
|
||||
|
func (d *Decoder) Decode(v interface{}) error { |
||||
|
return d.DecodeElement(v, nil) |
||||
|
} |
||||
|
|
||||
|
// DecodeElement works like xml.Unmarshal except that it takes
|
||||
|
// a pointer to the start XML element to decode into v.
|
||||
|
// It is useful when a client reads some raw XML tokens itself
|
||||
|
// but also wants to defer to Unmarshal for some elements.
|
||||
|
func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error { |
||||
|
val := reflect.ValueOf(v) |
||||
|
if val.Kind() != reflect.Ptr { |
||||
|
return errors.New("non-pointer passed to Unmarshal") |
||||
|
} |
||||
|
return d.unmarshal(val.Elem(), start) |
||||
|
} |
||||
|
|
||||
|
// An UnmarshalError represents an error in the unmarshalling process.
|
||||
|
type UnmarshalError string |
||||
|
|
||||
|
func (e UnmarshalError) Error() string { return string(e) } |
||||
|
|
||||
|
// Unmarshaler is the interface implemented by objects that can unmarshal
|
||||
|
// an XML element description of themselves.
|
||||
|
//
|
||||
|
// UnmarshalXML decodes a single XML element
|
||||
|
// beginning with the given start element.
|
||||
|
// If it returns an error, the outer call to Unmarshal stops and
|
||||
|
// returns that error.
|
||||
|
// UnmarshalXML must consume exactly one XML element.
|
||||
|
// One common implementation strategy is to unmarshal into
|
||||
|
// a separate value with a layout matching the expected XML
|
||||
|
// using d.DecodeElement, and then to copy the data from
|
||||
|
// that value into the receiver.
|
||||
|
// Another common strategy is to use d.Token to process the
|
||||
|
// XML object one token at a time.
|
||||
|
// UnmarshalXML may not use d.RawToken.
|
||||
|
type Unmarshaler interface { |
||||
|
UnmarshalXML(d *Decoder, start StartElement) error |
||||
|
} |
||||
|
|
||||
|
// UnmarshalerAttr is the interface implemented by objects that can unmarshal
|
||||
|
// an XML attribute description of themselves.
|
||||
|
//
|
||||
|
// UnmarshalXMLAttr decodes a single XML attribute.
|
||||
|
// If it returns an error, the outer call to Unmarshal stops and
|
||||
|
// returns that error.
|
||||
|
// UnmarshalXMLAttr is used only for struct fields with the
|
||||
|
// "attr" option in the field tag.
|
||||
|
type UnmarshalerAttr interface { |
||||
|
UnmarshalXMLAttr(attr Attr) error |
||||
|
} |
||||
|
|
||||
|
// receiverType returns the receiver type to use in an expression like "%s.MethodName".
|
||||
|
func receiverType(val interface{}) string { |
||||
|
t := reflect.TypeOf(val) |
||||
|
if t.Name() != "" { |
||||
|
return t.String() |
||||
|
} |
||||
|
return "(" + t.String() + ")" |
||||
|
} |
||||
|
|
||||
|
// unmarshalInterface unmarshals a single XML element into val.
|
||||
|
// start is the opening tag of the element.
|
||||
|
func (p *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error { |
||||
|
// Record that decoder must stop at end tag corresponding to start.
|
||||
|
p.pushEOF() |
||||
|
|
||||
|
p.unmarshalDepth++ |
||||
|
err := val.UnmarshalXML(p, *start) |
||||
|
p.unmarshalDepth-- |
||||
|
if err != nil { |
||||
|
p.popEOF() |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
if !p.popEOF() { |
||||
|
return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local) |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// unmarshalTextInterface unmarshals a single XML element into val.
|
||||
|
// The chardata contained in the element (but not its children)
|
||||
|
// is passed to the text unmarshaler.
|
||||
|
func (p *Decoder) unmarshalTextInterface(val encoding.TextUnmarshaler, start *StartElement) error { |
||||
|
var buf []byte |
||||
|
depth := 1 |
||||
|
for depth > 0 { |
||||
|
t, err := p.Token() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
switch t := t.(type) { |
||||
|
case CharData: |
||||
|
if depth == 1 { |
||||
|
buf = append(buf, t...) |
||||
|
} |
||||
|
case StartElement: |
||||
|
depth++ |
||||
|
case EndElement: |
||||
|
depth-- |
||||
|
} |
||||
|
} |
||||
|
return val.UnmarshalText(buf) |
||||
|
} |
||||
|
|
||||
|
// unmarshalAttr unmarshals a single XML attribute into val.
|
||||
|
func (p *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error { |
||||
|
if val.Kind() == reflect.Ptr { |
||||
|
if val.IsNil() { |
||||
|
val.Set(reflect.New(val.Type().Elem())) |
||||
|
} |
||||
|
val = val.Elem() |
||||
|
} |
||||
|
|
||||
|
if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) { |
||||
|
// This is an unmarshaler with a non-pointer receiver,
|
||||
|
// so it's likely to be incorrect, but we do what we're told.
|
||||
|
return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr) |
||||
|
} |
||||
|
if val.CanAddr() { |
||||
|
pv := val.Addr() |
||||
|
if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) { |
||||
|
return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Not an UnmarshalerAttr; try encoding.TextUnmarshaler.
|
||||
|
if val.CanInterface() && val.Type().Implements(textUnmarshalerType) { |
||||
|
// This is an unmarshaler with a non-pointer receiver,
|
||||
|
// so it's likely to be incorrect, but we do what we're told.
|
||||
|
return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value)) |
||||
|
} |
||||
|
if val.CanAddr() { |
||||
|
pv := val.Addr() |
||||
|
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) { |
||||
|
return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value)) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
copyValue(val, []byte(attr.Value)) |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem() |
||||
|
unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem() |
||||
|
textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() |
||||
|
) |
||||
|
|
||||
|
// Unmarshal a single XML element into val.
|
||||
|
func (p *Decoder) unmarshal(val reflect.Value, start *StartElement) error { |
||||
|
// Find start element if we need it.
|
||||
|
if start == nil { |
||||
|
for { |
||||
|
tok, err := p.Token() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
if t, ok := tok.(StartElement); ok { |
||||
|
start = &t |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Load value from interface, but only if the result will be
|
||||
|
// usefully addressable.
|
||||
|
if val.Kind() == reflect.Interface && !val.IsNil() { |
||||
|
e := val.Elem() |
||||
|
if e.Kind() == reflect.Ptr && !e.IsNil() { |
||||
|
val = e |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if val.Kind() == reflect.Ptr { |
||||
|
if val.IsNil() { |
||||
|
val.Set(reflect.New(val.Type().Elem())) |
||||
|
} |
||||
|
val = val.Elem() |
||||
|
} |
||||
|
|
||||
|
if val.CanInterface() && val.Type().Implements(unmarshalerType) { |
||||
|
// This is an unmarshaler with a non-pointer receiver,
|
||||
|
// so it's likely to be incorrect, but we do what we're told.
|
||||
|
return p.unmarshalInterface(val.Interface().(Unmarshaler), start) |
||||
|
} |
||||
|
|
||||
|
if val.CanAddr() { |
||||
|
pv := val.Addr() |
||||
|
if pv.CanInterface() && pv.Type().Implements(unmarshalerType) { |
||||
|
return p.unmarshalInterface(pv.Interface().(Unmarshaler), start) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if val.CanInterface() && val.Type().Implements(textUnmarshalerType) { |
||||
|
return p.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler), start) |
||||
|
} |
||||
|
|
||||
|
if val.CanAddr() { |
||||
|
pv := val.Addr() |
||||
|
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) { |
||||
|
return p.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler), start) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
data []byte |
||||
|
saveData reflect.Value |
||||
|
comment []byte |
||||
|
saveComment reflect.Value |
||||
|
saveXML reflect.Value |
||||
|
saveXMLIndex int |
||||
|
saveXMLData []byte |
||||
|
saveAny reflect.Value |
||||
|
sv reflect.Value |
||||
|
tinfo *typeInfo |
||||
|
err error |
||||
|
) |
||||
|
|
||||
|
switch v := val; v.Kind() { |
||||
|
default: |
||||
|
return errors.New("unknown type " + v.Type().String()) |
||||
|
|
||||
|
case reflect.Interface: |
||||
|
// TODO: For now, simply ignore the field. In the near
|
||||
|
// future we may choose to unmarshal the start
|
||||
|
// element on it, if not nil.
|
||||
|
return p.Skip() |
||||
|
|
||||
|
case reflect.Slice: |
||||
|
typ := v.Type() |
||||
|
if typ.Elem().Kind() == reflect.Uint8 { |
||||
|
// []byte
|
||||
|
saveData = v |
||||
|
break |
||||
|
} |
||||
|
|
||||
|
// Slice of element values.
|
||||
|
// Grow slice.
|
||||
|
n := v.Len() |
||||
|
if n >= v.Cap() { |
||||
|
ncap := 2 * n |
||||
|
if ncap < 4 { |
||||
|
ncap = 4 |
||||
|
} |
||||
|
new := reflect.MakeSlice(typ, n, ncap) |
||||
|
reflect.Copy(new, v) |
||||
|
v.Set(new) |
||||
|
} |
||||
|
v.SetLen(n + 1) |
||||
|
|
||||
|
// Recur to read element into slice.
|
||||
|
if err := p.unmarshal(v.Index(n), start); err != nil { |
||||
|
v.SetLen(n) |
||||
|
return err |
||||
|
} |
||||
|
return nil |
||||
|
|
||||
|
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.String: |
||||
|
saveData = v |
||||
|
|
||||
|
case reflect.Struct: |
||||
|
typ := v.Type() |
||||
|
if typ == nameType { |
||||
|
v.Set(reflect.ValueOf(start.Name)) |
||||
|
break |
||||
|
} |
||||
|
|
||||
|
sv = v |
||||
|
tinfo, err = getTypeInfo(typ) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
// Validate and assign element name.
|
||||
|
if tinfo.xmlname != nil { |
||||
|
finfo := tinfo.xmlname |
||||
|
if finfo.name != "" && finfo.name != start.Name.Local { |
||||
|
return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">") |
||||
|
} |
||||
|
if finfo.xmlns != "" && finfo.xmlns != start.Name.Space { |
||||
|
e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have " |
||||
|
if start.Name.Space == "" { |
||||
|
e += "no name space" |
||||
|
} else { |
||||
|
e += start.Name.Space |
||||
|
} |
||||
|
return UnmarshalError(e) |
||||
|
} |
||||
|
fv := finfo.value(sv) |
||||
|
if _, ok := fv.Interface().(Name); ok { |
||||
|
fv.Set(reflect.ValueOf(start.Name)) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Assign attributes.
|
||||
|
// Also, determine whether we need to save character data or comments.
|
||||
|
for i := range tinfo.fields { |
||||
|
finfo := &tinfo.fields[i] |
||||
|
switch finfo.flags & fMode { |
||||
|
case fAttr: |
||||
|
strv := finfo.value(sv) |
||||
|
// Look for attribute.
|
||||
|
for _, a := range start.Attr { |
||||
|
if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) { |
||||
|
if err := p.unmarshalAttr(strv, a); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
case fCharData: |
||||
|
if !saveData.IsValid() { |
||||
|
saveData = finfo.value(sv) |
||||
|
} |
||||
|
|
||||
|
case fComment: |
||||
|
if !saveComment.IsValid() { |
||||
|
saveComment = finfo.value(sv) |
||||
|
} |
||||
|
|
||||
|
case fAny, fAny | fElement: |
||||
|
if !saveAny.IsValid() { |
||||
|
saveAny = finfo.value(sv) |
||||
|
} |
||||
|
|
||||
|
case fInnerXml: |
||||
|
if !saveXML.IsValid() { |
||||
|
saveXML = finfo.value(sv) |
||||
|
if p.saved == nil { |
||||
|
saveXMLIndex = 0 |
||||
|
p.saved = new(bytes.Buffer) |
||||
|
} else { |
||||
|
saveXMLIndex = p.savedOffset() |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Find end element.
|
||||
|
// Process sub-elements along the way.
|
||||
|
Loop: |
||||
|
for { |
||||
|
var savedOffset int |
||||
|
if saveXML.IsValid() { |
||||
|
savedOffset = p.savedOffset() |
||||
|
} |
||||
|
tok, err := p.Token() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
switch t := tok.(type) { |
||||
|
case StartElement: |
||||
|
consumed := false |
||||
|
if sv.IsValid() { |
||||
|
consumed, err = p.unmarshalPath(tinfo, sv, nil, &t) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
if !consumed && saveAny.IsValid() { |
||||
|
consumed = true |
||||
|
if err := p.unmarshal(saveAny, &t); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
if !consumed { |
||||
|
if err := p.Skip(); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
case EndElement: |
||||
|
if saveXML.IsValid() { |
||||
|
saveXMLData = p.saved.Bytes()[saveXMLIndex:savedOffset] |
||||
|
if saveXMLIndex == 0 { |
||||
|
p.saved = nil |
||||
|
} |
||||
|
} |
||||
|
break Loop |
||||
|
|
||||
|
case CharData: |
||||
|
if saveData.IsValid() { |
||||
|
data = append(data, t...) |
||||
|
} |
||||
|
|
||||
|
case Comment: |
||||
|
if saveComment.IsValid() { |
||||
|
comment = append(comment, t...) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) { |
||||
|
if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
saveData = reflect.Value{} |
||||
|
} |
||||
|
|
||||
|
if saveData.IsValid() && saveData.CanAddr() { |
||||
|
pv := saveData.Addr() |
||||
|
if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) { |
||||
|
if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
saveData = reflect.Value{} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if err := copyValue(saveData, data); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
switch t := saveComment; t.Kind() { |
||||
|
case reflect.String: |
||||
|
t.SetString(string(comment)) |
||||
|
case reflect.Slice: |
||||
|
t.Set(reflect.ValueOf(comment)) |
||||
|
} |
||||
|
|
||||
|
switch t := saveXML; t.Kind() { |
||||
|
case reflect.String: |
||||
|
t.SetString(string(saveXMLData)) |
||||
|
case reflect.Slice: |
||||
|
t.Set(reflect.ValueOf(saveXMLData)) |
||||
|
} |
||||
|
|
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func copyValue(dst reflect.Value, src []byte) (err error) { |
||||
|
dst0 := dst |
||||
|
|
||||
|
if dst.Kind() == reflect.Ptr { |
||||
|
if dst.IsNil() { |
||||
|
dst.Set(reflect.New(dst.Type().Elem())) |
||||
|
} |
||||
|
dst = dst.Elem() |
||||
|
} |
||||
|
|
||||
|
// Save accumulated data.
|
||||
|
switch dst.Kind() { |
||||
|
case reflect.Invalid: |
||||
|
// Probably a comment.
|
||||
|
default: |
||||
|
return errors.New("cannot unmarshal into " + dst0.Type().String()) |
||||
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
|
itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
dst.SetInt(itmp) |
||||
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
|
utmp, err := strconv.ParseUint(string(src), 10, dst.Type().Bits()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
dst.SetUint(utmp) |
||||
|
case reflect.Float32, reflect.Float64: |
||||
|
ftmp, err := strconv.ParseFloat(string(src), dst.Type().Bits()) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
dst.SetFloat(ftmp) |
||||
|
case reflect.Bool: |
||||
|
value, err := strconv.ParseBool(strings.TrimSpace(string(src))) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
dst.SetBool(value) |
||||
|
case reflect.String: |
||||
|
dst.SetString(string(src)) |
||||
|
case reflect.Slice: |
||||
|
if len(src) == 0 { |
||||
|
// non-nil to flag presence
|
||||
|
src = []byte{} |
||||
|
} |
||||
|
dst.SetBytes(src) |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// unmarshalPath walks down an XML structure looking for wanted
|
||||
|
// paths, and calls unmarshal on them.
|
||||
|
// The consumed result tells whether XML elements have been consumed
|
||||
|
// from the Decoder until start's matching end element, or if it's
|
||||
|
// still untouched because start is uninteresting for sv's fields.
|
||||
|
func (p *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) { |
||||
|
recurse := false |
||||
|
Loop: |
||||
|
for i := range tinfo.fields { |
||||
|
finfo := &tinfo.fields[i] |
||||
|
if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space { |
||||
|
continue |
||||
|
} |
||||
|
for j := range parents { |
||||
|
if parents[j] != finfo.parents[j] { |
||||
|
continue Loop |
||||
|
} |
||||
|
} |
||||
|
if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local { |
||||
|
// It's a perfect match, unmarshal the field.
|
||||
|
return true, p.unmarshal(finfo.value(sv), start) |
||||
|
} |
||||
|
if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local { |
||||
|
// It's a prefix for the field. Break and recurse
|
||||
|
// since it's not ok for one field path to be itself
|
||||
|
// the prefix for another field path.
|
||||
|
recurse = true |
||||
|
|
||||
|
// We can reuse the same slice as long as we
|
||||
|
// don't try to append to it.
|
||||
|
parents = finfo.parents[:len(parents)+1] |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
if !recurse { |
||||
|
// We have no business with this element.
|
||||
|
return false, nil |
||||
|
} |
||||
|
// The element is not a perfect match for any field, but one
|
||||
|
// or more fields have the path to this element as a parent
|
||||
|
// prefix. Recurse and attempt to match these.
|
||||
|
for { |
||||
|
var tok Token |
||||
|
tok, err = p.Token() |
||||
|
if err != nil { |
||||
|
return true, err |
||||
|
} |
||||
|
switch t := tok.(type) { |
||||
|
case StartElement: |
||||
|
consumed2, err := p.unmarshalPath(tinfo, sv, parents, &t) |
||||
|
if err != nil { |
||||
|
return true, err |
||||
|
} |
||||
|
if !consumed2 { |
||||
|
if err := p.Skip(); err != nil { |
||||
|
return true, err |
||||
|
} |
||||
|
} |
||||
|
case EndElement: |
||||
|
return true, nil |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Skip reads tokens until it has consumed the end element
|
||||
|
// matching the most recent start element already consumed.
|
||||
|
// It recurs if it encounters a start element, so it can be used to
|
||||
|
// skip nested structures.
|
||||
|
// It returns nil if it finds an end element matching the start
|
||||
|
// element; otherwise it returns an error describing the problem.
|
||||
|
func (d *Decoder) Skip() error { |
||||
|
for { |
||||
|
tok, err := d.Token() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
switch tok.(type) { |
||||
|
case StartElement: |
||||
|
if err := d.Skip(); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
case EndElement: |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,371 @@ |
|||||
|
// Copyright 2011 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 xml |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"reflect" |
||||
|
"strings" |
||||
|
"sync" |
||||
|
) |
||||
|
|
||||
|
// typeInfo holds details for the xml representation of a type.
|
||||
|
type typeInfo struct { |
||||
|
xmlname *fieldInfo |
||||
|
fields []fieldInfo |
||||
|
} |
||||
|
|
||||
|
// fieldInfo holds details for the xml representation of a single field.
|
||||
|
type fieldInfo struct { |
||||
|
idx []int |
||||
|
name string |
||||
|
xmlns string |
||||
|
flags fieldFlags |
||||
|
parents []string |
||||
|
} |
||||
|
|
||||
|
type fieldFlags int |
||||
|
|
||||
|
const ( |
||||
|
fElement fieldFlags = 1 << iota |
||||
|
fAttr |
||||
|
fCharData |
||||
|
fInnerXml |
||||
|
fComment |
||||
|
fAny |
||||
|
|
||||
|
fOmitEmpty |
||||
|
|
||||
|
fMode = fElement | fAttr | fCharData | fInnerXml | fComment | fAny |
||||
|
) |
||||
|
|
||||
|
var tinfoMap = make(map[reflect.Type]*typeInfo) |
||||
|
var tinfoLock sync.RWMutex |
||||
|
|
||||
|
var nameType = reflect.TypeOf(Name{}) |
||||
|
|
||||
|
// getTypeInfo returns the typeInfo structure with details necessary
|
||||
|
// for marshalling and unmarshalling typ.
|
||||
|
func getTypeInfo(typ reflect.Type) (*typeInfo, error) { |
||||
|
tinfoLock.RLock() |
||||
|
tinfo, ok := tinfoMap[typ] |
||||
|
tinfoLock.RUnlock() |
||||
|
if ok { |
||||
|
return tinfo, nil |
||||
|
} |
||||
|
tinfo = &typeInfo{} |
||||
|
if typ.Kind() == reflect.Struct && typ != nameType { |
||||
|
n := typ.NumField() |
||||
|
for i := 0; i < n; i++ { |
||||
|
f := typ.Field(i) |
||||
|
if f.PkgPath != "" || f.Tag.Get("xml") == "-" { |
||||
|
continue // Private field
|
||||
|
} |
||||
|
|
||||
|
// For embedded structs, embed its fields.
|
||||
|
if f.Anonymous { |
||||
|
t := f.Type |
||||
|
if t.Kind() == reflect.Ptr { |
||||
|
t = t.Elem() |
||||
|
} |
||||
|
if t.Kind() == reflect.Struct { |
||||
|
inner, err := getTypeInfo(t) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
if tinfo.xmlname == nil { |
||||
|
tinfo.xmlname = inner.xmlname |
||||
|
} |
||||
|
for _, finfo := range inner.fields { |
||||
|
finfo.idx = append([]int{i}, finfo.idx...) |
||||
|
if err := addFieldInfo(typ, tinfo, &finfo); err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} |
||||
|
continue |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
finfo, err := structFieldInfo(typ, &f) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
|
||||
|
if f.Name == "XMLName" { |
||||
|
tinfo.xmlname = finfo |
||||
|
continue |
||||
|
} |
||||
|
|
||||
|
// Add the field if it doesn't conflict with other fields.
|
||||
|
if err := addFieldInfo(typ, tinfo, finfo); err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
tinfoLock.Lock() |
||||
|
tinfoMap[typ] = tinfo |
||||
|
tinfoLock.Unlock() |
||||
|
return tinfo, nil |
||||
|
} |
||||
|
|
||||
|
// structFieldInfo builds and returns a fieldInfo for f.
|
||||
|
func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) { |
||||
|
finfo := &fieldInfo{idx: f.Index} |
||||
|
|
||||
|
// Split the tag from the xml namespace if necessary.
|
||||
|
tag := f.Tag.Get("xml") |
||||
|
if i := strings.Index(tag, " "); i >= 0 { |
||||
|
finfo.xmlns, tag = tag[:i], tag[i+1:] |
||||
|
} |
||||
|
|
||||
|
// Parse flags.
|
||||
|
tokens := strings.Split(tag, ",") |
||||
|
if len(tokens) == 1 { |
||||
|
finfo.flags = fElement |
||||
|
} else { |
||||
|
tag = tokens[0] |
||||
|
for _, flag := range tokens[1:] { |
||||
|
switch flag { |
||||
|
case "attr": |
||||
|
finfo.flags |= fAttr |
||||
|
case "chardata": |
||||
|
finfo.flags |= fCharData |
||||
|
case "innerxml": |
||||
|
finfo.flags |= fInnerXml |
||||
|
case "comment": |
||||
|
finfo.flags |= fComment |
||||
|
case "any": |
||||
|
finfo.flags |= fAny |
||||
|
case "omitempty": |
||||
|
finfo.flags |= fOmitEmpty |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Validate the flags used.
|
||||
|
valid := true |
||||
|
switch mode := finfo.flags & fMode; mode { |
||||
|
case 0: |
||||
|
finfo.flags |= fElement |
||||
|
case fAttr, fCharData, fInnerXml, fComment, fAny: |
||||
|
if f.Name == "XMLName" || tag != "" && mode != fAttr { |
||||
|
valid = false |
||||
|
} |
||||
|
default: |
||||
|
// This will also catch multiple modes in a single field.
|
||||
|
valid = false |
||||
|
} |
||||
|
if finfo.flags&fMode == fAny { |
||||
|
finfo.flags |= fElement |
||||
|
} |
||||
|
if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 { |
||||
|
valid = false |
||||
|
} |
||||
|
if !valid { |
||||
|
return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q", |
||||
|
f.Name, typ, f.Tag.Get("xml")) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Use of xmlns without a name is not allowed.
|
||||
|
if finfo.xmlns != "" && tag == "" { |
||||
|
return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q", |
||||
|
f.Name, typ, f.Tag.Get("xml")) |
||||
|
} |
||||
|
|
||||
|
if f.Name == "XMLName" { |
||||
|
// The XMLName field records the XML element name. Don't
|
||||
|
// process it as usual because its name should default to
|
||||
|
// empty rather than to the field name.
|
||||
|
finfo.name = tag |
||||
|
return finfo, nil |
||||
|
} |
||||
|
|
||||
|
if tag == "" { |
||||
|
// If the name part of the tag is completely empty, get
|
||||
|
// default from XMLName of underlying struct if feasible,
|
||||
|
// or field name otherwise.
|
||||
|
if xmlname := lookupXMLName(f.Type); xmlname != nil { |
||||
|
finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name |
||||
|
} else { |
||||
|
finfo.name = f.Name |
||||
|
} |
||||
|
return finfo, nil |
||||
|
} |
||||
|
|
||||
|
if finfo.xmlns == "" && finfo.flags&fAttr == 0 { |
||||
|
// If it's an element no namespace specified, get the default
|
||||
|
// from the XMLName of enclosing struct if possible.
|
||||
|
if xmlname := lookupXMLName(typ); xmlname != nil { |
||||
|
finfo.xmlns = xmlname.xmlns |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Prepare field name and parents.
|
||||
|
parents := strings.Split(tag, ">") |
||||
|
if parents[0] == "" { |
||||
|
parents[0] = f.Name |
||||
|
} |
||||
|
if parents[len(parents)-1] == "" { |
||||
|
return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ) |
||||
|
} |
||||
|
finfo.name = parents[len(parents)-1] |
||||
|
if len(parents) > 1 { |
||||
|
if (finfo.flags & fElement) == 0 { |
||||
|
return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ",")) |
||||
|
} |
||||
|
finfo.parents = parents[:len(parents)-1] |
||||
|
} |
||||
|
|
||||
|
// If the field type has an XMLName field, the names must match
|
||||
|
// so that the behavior of both marshalling and unmarshalling
|
||||
|
// is straightforward and unambiguous.
|
||||
|
if finfo.flags&fElement != 0 { |
||||
|
ftyp := f.Type |
||||
|
xmlname := lookupXMLName(ftyp) |
||||
|
if xmlname != nil && xmlname.name != finfo.name { |
||||
|
return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName", |
||||
|
finfo.name, typ, f.Name, xmlname.name, ftyp) |
||||
|
} |
||||
|
} |
||||
|
return finfo, nil |
||||
|
} |
||||
|
|
||||
|
// lookupXMLName returns the fieldInfo for typ's XMLName field
|
||||
|
// in case it exists and has a valid xml field tag, otherwise
|
||||
|
// it returns nil.
|
||||
|
func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) { |
||||
|
for typ.Kind() == reflect.Ptr { |
||||
|
typ = typ.Elem() |
||||
|
} |
||||
|
if typ.Kind() != reflect.Struct { |
||||
|
return nil |
||||
|
} |
||||
|
for i, n := 0, typ.NumField(); i < n; i++ { |
||||
|
f := typ.Field(i) |
||||
|
if f.Name != "XMLName" { |
||||
|
continue |
||||
|
} |
||||
|
finfo, err := structFieldInfo(typ, &f) |
||||
|
if finfo.name != "" && err == nil { |
||||
|
return finfo |
||||
|
} |
||||
|
// Also consider errors as a non-existent field tag
|
||||
|
// and let getTypeInfo itself report the error.
|
||||
|
break |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func min(a, b int) int { |
||||
|
if a <= b { |
||||
|
return a |
||||
|
} |
||||
|
return b |
||||
|
} |
||||
|
|
||||
|
// addFieldInfo adds finfo to tinfo.fields if there are no
|
||||
|
// conflicts, or if conflicts arise from previous fields that were
|
||||
|
// obtained from deeper embedded structures than finfo. In the latter
|
||||
|
// case, the conflicting entries are dropped.
|
||||
|
// A conflict occurs when the path (parent + name) to a field is
|
||||
|
// itself a prefix of another path, or when two paths match exactly.
|
||||
|
// It is okay for field paths to share a common, shorter prefix.
|
||||
|
func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error { |
||||
|
var conflicts []int |
||||
|
Loop: |
||||
|
// First, figure all conflicts. Most working code will have none.
|
||||
|
for i := range tinfo.fields { |
||||
|
oldf := &tinfo.fields[i] |
||||
|
if oldf.flags&fMode != newf.flags&fMode { |
||||
|
continue |
||||
|
} |
||||
|
if oldf.xmlns != "" && newf.xmlns != "" && oldf.xmlns != newf.xmlns { |
||||
|
continue |
||||
|
} |
||||
|
minl := min(len(newf.parents), len(oldf.parents)) |
||||
|
for p := 0; p < minl; p++ { |
||||
|
if oldf.parents[p] != newf.parents[p] { |
||||
|
continue Loop |
||||
|
} |
||||
|
} |
||||
|
if len(oldf.parents) > len(newf.parents) { |
||||
|
if oldf.parents[len(newf.parents)] == newf.name { |
||||
|
conflicts = append(conflicts, i) |
||||
|
} |
||||
|
} else if len(oldf.parents) < len(newf.parents) { |
||||
|
if newf.parents[len(oldf.parents)] == oldf.name { |
||||
|
conflicts = append(conflicts, i) |
||||
|
} |
||||
|
} else { |
||||
|
if newf.name == oldf.name { |
||||
|
conflicts = append(conflicts, i) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
// Without conflicts, add the new field and return.
|
||||
|
if conflicts == nil { |
||||
|
tinfo.fields = append(tinfo.fields, *newf) |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// If any conflict is shallower, ignore the new field.
|
||||
|
// This matches the Go field resolution on embedding.
|
||||
|
for _, i := range conflicts { |
||||
|
if len(tinfo.fields[i].idx) < len(newf.idx) { |
||||
|
return nil |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Otherwise, if any of them is at the same depth level, it's an error.
|
||||
|
for _, i := range conflicts { |
||||
|
oldf := &tinfo.fields[i] |
||||
|
if len(oldf.idx) == len(newf.idx) { |
||||
|
f1 := typ.FieldByIndex(oldf.idx) |
||||
|
f2 := typ.FieldByIndex(newf.idx) |
||||
|
return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Otherwise, the new field is shallower, and thus takes precedence,
|
||||
|
// so drop the conflicting fields from tinfo and append the new one.
|
||||
|
for c := len(conflicts) - 1; c >= 0; c-- { |
||||
|
i := conflicts[c] |
||||
|
copy(tinfo.fields[i:], tinfo.fields[i+1:]) |
||||
|
tinfo.fields = tinfo.fields[:len(tinfo.fields)-1] |
||||
|
} |
||||
|
tinfo.fields = append(tinfo.fields, *newf) |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// A TagPathError represents an error in the unmarshalling process
|
||||
|
// caused by the use of field tags with conflicting paths.
|
||||
|
type TagPathError struct { |
||||
|
Struct reflect.Type |
||||
|
Field1, Tag1 string |
||||
|
Field2, Tag2 string |
||||
|
} |
||||
|
|
||||
|
func (e *TagPathError) Error() string { |
||||
|
return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2) |
||||
|
} |
||||
|
|
||||
|
// value returns v's field value corresponding to finfo.
|
||||
|
// It's equivalent to v.FieldByIndex(finfo.idx), but initializes
|
||||
|
// and dereferences pointers as necessary.
|
||||
|
func (finfo *fieldInfo) value(v reflect.Value) reflect.Value { |
||||
|
for i, x := range finfo.idx { |
||||
|
if i > 0 { |
||||
|
t := v.Type() |
||||
|
if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct { |
||||
|
if v.IsNil() { |
||||
|
v.Set(reflect.New(v.Type().Elem())) |
||||
|
} |
||||
|
v = v.Elem() |
||||
|
} |
||||
|
} |
||||
|
v = v.Field(x) |
||||
|
} |
||||
|
return v |
||||
|
} |
||||
File diff suppressed because it is too large
@ -0,0 +1,445 @@ |
|||||
|
// 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 dav |
||||
|
|
||||
|
import ( |
||||
|
"container/heap" |
||||
|
"errors" |
||||
|
"strconv" |
||||
|
"strings" |
||||
|
"sync" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
var ( |
||||
|
// ErrConfirmationFailed is returned by a LockSystem's Confirm method.
|
||||
|
ErrConfirmationFailed = errors.New("webdav: confirmation failed") |
||||
|
// ErrForbidden is returned by a LockSystem's Unlock method.
|
||||
|
ErrForbidden = errors.New("webdav: forbidden") |
||||
|
// ErrLocked is returned by a LockSystem's Create, Refresh and Unlock methods.
|
||||
|
ErrLocked = errors.New("webdav: locked") |
||||
|
// ErrNoSuchLock is returned by a LockSystem's Refresh and Unlock methods.
|
||||
|
ErrNoSuchLock = errors.New("webdav: no such lock") |
||||
|
) |
||||
|
|
||||
|
// Condition can match a WebDAV resource, based on a token or ETag.
|
||||
|
// Exactly one of Token and ETag should be non-empty.
|
||||
|
type Condition struct { |
||||
|
Not bool |
||||
|
Token string |
||||
|
ETag string |
||||
|
} |
||||
|
|
||||
|
// LockSystem manages access to a collection of named resources. The elements
|
||||
|
// in a lock name are separated by slash ('/', U+002F) characters, regardless
|
||||
|
// of host operating system convention.
|
||||
|
type LockSystem interface { |
||||
|
// Confirm confirms that the caller can claim all of the locks specified by
|
||||
|
// the given conditions, and that holding the union of all of those locks
|
||||
|
// gives exclusive access to all of the named resources. Up to two resources
|
||||
|
// can be named. Empty names are ignored.
|
||||
|
//
|
||||
|
// Exactly one of release and err will be non-nil. If release is non-nil,
|
||||
|
// all of the requested locks are held until release is called. Calling
|
||||
|
// release does not unlock the lock, in the WebDAV UNLOCK sense, but once
|
||||
|
// Confirm has confirmed that a lock claim is valid, that lock cannot be
|
||||
|
// Confirmed again until it has been released.
|
||||
|
//
|
||||
|
// If Confirm returns ErrConfirmationFailed then the Handler will continue
|
||||
|
// to try any other set of locks presented (a WebDAV HTTP request can
|
||||
|
// present more than one set of locks). If it returns any other non-nil
|
||||
|
// error, the Handler will write a "500 Internal Server Error" HTTP status.
|
||||
|
Confirm(now time.Time, name0, name1 string, conditions ...Condition) (release func(), err error) |
||||
|
|
||||
|
// Create creates a lock with the given depth, duration, owner and root
|
||||
|
// (name). The depth will either be negative (meaning infinite) or zero.
|
||||
|
//
|
||||
|
// If Create returns ErrLocked then the Handler will write a "423 Locked"
|
||||
|
// HTTP status. If it returns any other non-nil error, the Handler will
|
||||
|
// write a "500 Internal Server Error" HTTP status.
|
||||
|
//
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
|
||||
|
// when to use each error.
|
||||
|
//
|
||||
|
// The token returned identifies the created lock. It should be an absolute
|
||||
|
// URI as defined by RFC 3986, Section 4.3. In particular, it should not
|
||||
|
// contain whitespace.
|
||||
|
Create(now time.Time, details LockDetails) (token string, err error) |
||||
|
|
||||
|
// Refresh refreshes the lock with the given token.
|
||||
|
//
|
||||
|
// If Refresh returns ErrLocked then the Handler will write a "423 Locked"
|
||||
|
// HTTP Status. If Refresh returns ErrNoSuchLock then the Handler will write
|
||||
|
// a "412 Precondition Failed" HTTP Status. If it returns any other non-nil
|
||||
|
// error, the Handler will write a "500 Internal Server Error" HTTP status.
|
||||
|
//
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
|
||||
|
// when to use each error.
|
||||
|
Refresh(now time.Time, token string, duration time.Duration) (LockDetails, error) |
||||
|
|
||||
|
// Unlock unlocks the lock with the given token.
|
||||
|
//
|
||||
|
// If Unlock returns ErrForbidden then the Handler will write a "403
|
||||
|
// Forbidden" HTTP Status. If Unlock returns ErrLocked then the Handler
|
||||
|
// will write a "423 Locked" HTTP status. If Unlock returns ErrNoSuchLock
|
||||
|
// then the Handler will write a "409 Conflict" HTTP Status. If it returns
|
||||
|
// any other non-nil error, the Handler will write a "500 Internal Server
|
||||
|
// Error" HTTP status.
|
||||
|
//
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.11.1 for
|
||||
|
// when to use each error.
|
||||
|
Unlock(now time.Time, token string) error |
||||
|
} |
||||
|
|
||||
|
// LockDetails are a lock's metadata.
|
||||
|
type LockDetails struct { |
||||
|
// Root is the root resource name being locked. For a zero-depth lock, the
|
||||
|
// root is the only resource being locked.
|
||||
|
Root string |
||||
|
// Duration is the lock timeout. A negative duration means infinite.
|
||||
|
Duration time.Duration |
||||
|
// OwnerXML is the verbatim <owner> XML given in a LOCK HTTP request.
|
||||
|
//
|
||||
|
// TODO: does the "verbatim" nature play well with XML namespaces?
|
||||
|
// Does the OwnerXML field need to have more structure? See
|
||||
|
// https://codereview.appspot.com/175140043/#msg2
|
||||
|
OwnerXML string |
||||
|
// ZeroDepth is whether the lock has zero depth. If it does not have zero
|
||||
|
// depth, it has infinite depth.
|
||||
|
ZeroDepth bool |
||||
|
} |
||||
|
|
||||
|
// NewMemLS returns a new in-memory LockSystem.
|
||||
|
func NewMemLS() LockSystem { |
||||
|
return &memLS{ |
||||
|
byName: make(map[string]*memLSNode), |
||||
|
byToken: make(map[string]*memLSNode), |
||||
|
gen: uint64(time.Now().Unix()), |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
type memLS struct { |
||||
|
mu sync.Mutex |
||||
|
byName map[string]*memLSNode |
||||
|
byToken map[string]*memLSNode |
||||
|
gen uint64 |
||||
|
// byExpiry only contains those nodes whose LockDetails have a finite
|
||||
|
// Duration and are yet to expire.
|
||||
|
byExpiry byExpiry |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) nextToken() string { |
||||
|
m.gen++ |
||||
|
return strconv.FormatUint(m.gen, 10) |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) collectExpiredNodes(now time.Time) { |
||||
|
for len(m.byExpiry) > 0 { |
||||
|
if now.Before(m.byExpiry[0].expiry) { |
||||
|
break |
||||
|
} |
||||
|
m.remove(m.byExpiry[0]) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) Confirm(now time.Time, name0, name1 string, conditions ...Condition) (func(), error) { |
||||
|
m.mu.Lock() |
||||
|
defer m.mu.Unlock() |
||||
|
m.collectExpiredNodes(now) |
||||
|
|
||||
|
var n0, n1 *memLSNode |
||||
|
if name0 != "" { |
||||
|
if n0 = m.lookup(slashClean(name0), conditions...); n0 == nil { |
||||
|
return nil, ErrConfirmationFailed |
||||
|
} |
||||
|
} |
||||
|
if name1 != "" { |
||||
|
if n1 = m.lookup(slashClean(name1), conditions...); n1 == nil { |
||||
|
return nil, ErrConfirmationFailed |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Don't hold the same node twice.
|
||||
|
if n1 == n0 { |
||||
|
n1 = nil |
||||
|
} |
||||
|
|
||||
|
if n0 != nil { |
||||
|
m.hold(n0) |
||||
|
} |
||||
|
if n1 != nil { |
||||
|
m.hold(n1) |
||||
|
} |
||||
|
return func() { |
||||
|
m.mu.Lock() |
||||
|
defer m.mu.Unlock() |
||||
|
if n1 != nil { |
||||
|
m.unhold(n1) |
||||
|
} |
||||
|
if n0 != nil { |
||||
|
m.unhold(n0) |
||||
|
} |
||||
|
}, nil |
||||
|
} |
||||
|
|
||||
|
// lookup returns the node n that locks the named resource, provided that n
|
||||
|
// matches at least one of the given conditions and that lock isn't held by
|
||||
|
// another party. Otherwise, it returns nil.
|
||||
|
//
|
||||
|
// n may be a parent of the named resource, if n is an infinite depth lock.
|
||||
|
func (m *memLS) lookup(name string, conditions ...Condition) (n *memLSNode) { |
||||
|
// TODO: support Condition.Not and Condition.ETag.
|
||||
|
for _, c := range conditions { |
||||
|
n = m.byToken[c.Token] |
||||
|
if n == nil || n.held { |
||||
|
continue |
||||
|
} |
||||
|
if name == n.details.Root { |
||||
|
return n |
||||
|
} |
||||
|
if n.details.ZeroDepth { |
||||
|
continue |
||||
|
} |
||||
|
if n.details.Root == "/" || strings.HasPrefix(name, n.details.Root+"/") { |
||||
|
return n |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) hold(n *memLSNode) { |
||||
|
if n.held { |
||||
|
panic("webdav: memLS inconsistent held state") |
||||
|
} |
||||
|
n.held = true |
||||
|
if n.details.Duration >= 0 && n.byExpiryIndex >= 0 { |
||||
|
heap.Remove(&m.byExpiry, n.byExpiryIndex) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) unhold(n *memLSNode) { |
||||
|
if !n.held { |
||||
|
panic("webdav: memLS inconsistent held state") |
||||
|
} |
||||
|
n.held = false |
||||
|
if n.details.Duration >= 0 { |
||||
|
heap.Push(&m.byExpiry, n) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) Create(now time.Time, details LockDetails) (string, error) { |
||||
|
m.mu.Lock() |
||||
|
defer m.mu.Unlock() |
||||
|
m.collectExpiredNodes(now) |
||||
|
details.Root = slashClean(details.Root) |
||||
|
|
||||
|
if !m.canCreate(details.Root, details.ZeroDepth) { |
||||
|
return "", ErrLocked |
||||
|
} |
||||
|
n := m.create(details.Root) |
||||
|
n.token = m.nextToken() |
||||
|
m.byToken[n.token] = n |
||||
|
n.details = details |
||||
|
if n.details.Duration >= 0 { |
||||
|
n.expiry = now.Add(n.details.Duration) |
||||
|
heap.Push(&m.byExpiry, n) |
||||
|
} |
||||
|
return n.token, nil |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) Refresh(now time.Time, token string, duration time.Duration) (LockDetails, error) { |
||||
|
m.mu.Lock() |
||||
|
defer m.mu.Unlock() |
||||
|
m.collectExpiredNodes(now) |
||||
|
|
||||
|
n := m.byToken[token] |
||||
|
if n == nil { |
||||
|
return LockDetails{}, ErrNoSuchLock |
||||
|
} |
||||
|
if n.held { |
||||
|
return LockDetails{}, ErrLocked |
||||
|
} |
||||
|
if n.byExpiryIndex >= 0 { |
||||
|
heap.Remove(&m.byExpiry, n.byExpiryIndex) |
||||
|
} |
||||
|
n.details.Duration = duration |
||||
|
if n.details.Duration >= 0 { |
||||
|
n.expiry = now.Add(n.details.Duration) |
||||
|
heap.Push(&m.byExpiry, n) |
||||
|
} |
||||
|
return n.details, nil |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) Unlock(now time.Time, token string) error { |
||||
|
m.mu.Lock() |
||||
|
defer m.mu.Unlock() |
||||
|
m.collectExpiredNodes(now) |
||||
|
|
||||
|
n := m.byToken[token] |
||||
|
if n == nil { |
||||
|
return ErrNoSuchLock |
||||
|
} |
||||
|
if n.held { |
||||
|
return ErrLocked |
||||
|
} |
||||
|
m.remove(n) |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) canCreate(name string, zeroDepth bool) bool { |
||||
|
return walkToRoot(name, func(name0 string, first bool) bool { |
||||
|
n := m.byName[name0] |
||||
|
if n == nil { |
||||
|
return true |
||||
|
} |
||||
|
if first { |
||||
|
if n.token != "" { |
||||
|
// The target node is already locked.
|
||||
|
return false |
||||
|
} |
||||
|
if !zeroDepth { |
||||
|
// The requested lock depth is infinite, and the fact that n exists
|
||||
|
// (n != nil) means that a descendent of the target node is locked.
|
||||
|
return false |
||||
|
} |
||||
|
} else if n.token != "" && !n.details.ZeroDepth { |
||||
|
// An ancestor of the target node is locked with infinite depth.
|
||||
|
return false |
||||
|
} |
||||
|
return true |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) create(name string) (ret *memLSNode) { |
||||
|
walkToRoot(name, func(name0 string, first bool) bool { |
||||
|
n := m.byName[name0] |
||||
|
if n == nil { |
||||
|
n = &memLSNode{ |
||||
|
details: LockDetails{ |
||||
|
Root: name0, |
||||
|
}, |
||||
|
byExpiryIndex: -1, |
||||
|
} |
||||
|
m.byName[name0] = n |
||||
|
} |
||||
|
n.refCount++ |
||||
|
if first { |
||||
|
ret = n |
||||
|
} |
||||
|
return true |
||||
|
}) |
||||
|
return ret |
||||
|
} |
||||
|
|
||||
|
func (m *memLS) remove(n *memLSNode) { |
||||
|
delete(m.byToken, n.token) |
||||
|
n.token = "" |
||||
|
walkToRoot(n.details.Root, func(name0 string, first bool) bool { |
||||
|
x := m.byName[name0] |
||||
|
x.refCount-- |
||||
|
if x.refCount == 0 { |
||||
|
delete(m.byName, name0) |
||||
|
} |
||||
|
return true |
||||
|
}) |
||||
|
if n.byExpiryIndex >= 0 { |
||||
|
heap.Remove(&m.byExpiry, n.byExpiryIndex) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func walkToRoot(name string, f func(name0 string, first bool) bool) bool { |
||||
|
for first := true; ; first = false { |
||||
|
if !f(name, first) { |
||||
|
return false |
||||
|
} |
||||
|
if name == "/" { |
||||
|
break |
||||
|
} |
||||
|
name = name[:strings.LastIndex(name, "/")] |
||||
|
if name == "" { |
||||
|
name = "/" |
||||
|
} |
||||
|
} |
||||
|
return true |
||||
|
} |
||||
|
|
||||
|
type memLSNode struct { |
||||
|
// details are the lock metadata. Even if this node's name is not explicitly locked,
|
||||
|
// details.Root will still equal the node's name.
|
||||
|
details LockDetails |
||||
|
// token is the unique identifier for this node's lock. An empty token means that
|
||||
|
// this node is not explicitly locked.
|
||||
|
token string |
||||
|
// refCount is the number of self-or-descendent nodes that are explicitly locked.
|
||||
|
refCount int |
||||
|
// expiry is when this node's lock expires.
|
||||
|
expiry time.Time |
||||
|
// byExpiryIndex is the index of this node in memLS.byExpiry. It is -1
|
||||
|
// if this node does not expire, or has expired.
|
||||
|
byExpiryIndex int |
||||
|
// held is whether this node's lock is actively held by a Confirm call.
|
||||
|
held bool |
||||
|
} |
||||
|
|
||||
|
type byExpiry []*memLSNode |
||||
|
|
||||
|
func (b *byExpiry) Len() int { |
||||
|
return len(*b) |
||||
|
} |
||||
|
|
||||
|
func (b *byExpiry) Less(i, j int) bool { |
||||
|
return (*b)[i].expiry.Before((*b)[j].expiry) |
||||
|
} |
||||
|
|
||||
|
func (b *byExpiry) Swap(i, j int) { |
||||
|
(*b)[i], (*b)[j] = (*b)[j], (*b)[i] |
||||
|
(*b)[i].byExpiryIndex = i |
||||
|
(*b)[j].byExpiryIndex = j |
||||
|
} |
||||
|
|
||||
|
func (b *byExpiry) Push(x interface{}) { |
||||
|
n := x.(*memLSNode) |
||||
|
n.byExpiryIndex = len(*b) |
||||
|
*b = append(*b, n) |
||||
|
} |
||||
|
|
||||
|
func (b *byExpiry) Pop() interface{} { |
||||
|
i := len(*b) - 1 |
||||
|
n := (*b)[i] |
||||
|
(*b)[i] = nil |
||||
|
n.byExpiryIndex = -1 |
||||
|
*b = (*b)[:i] |
||||
|
return n |
||||
|
} |
||||
|
|
||||
|
const infiniteTimeout = -1 |
||||
|
|
||||
|
// parseTimeout parses the Timeout HTTP header, as per section 10.7. If s is
|
||||
|
// empty, an infiniteTimeout is returned.
|
||||
|
func parseTimeout(s string) (time.Duration, error) { |
||||
|
if s == "" { |
||||
|
return infiniteTimeout, nil |
||||
|
} |
||||
|
if i := strings.IndexByte(s, ','); i >= 0 { |
||||
|
s = s[:i] |
||||
|
} |
||||
|
s = strings.TrimSpace(s) |
||||
|
if s == "Infinite" { |
||||
|
return infiniteTimeout, nil |
||||
|
} |
||||
|
const pre = "Second-" |
||||
|
if !strings.HasPrefix(s, pre) { |
||||
|
return 0, errInvalidTimeout |
||||
|
} |
||||
|
s = s[len(pre):] |
||||
|
if s == "" || s[0] < '0' || '9' < s[0] { |
||||
|
return 0, errInvalidTimeout |
||||
|
} |
||||
|
n, err := strconv.ParseInt(s, 10, 64) |
||||
|
if err != nil || 1<<32-1 < n { |
||||
|
return 0, errInvalidTimeout |
||||
|
} |
||||
|
return time.Duration(n) * time.Second, nil |
||||
|
} |
||||
@ -0,0 +1,469 @@ |
|||||
|
// Copyright 2015 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 dav |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"context" |
||||
|
"encoding/xml" |
||||
|
"errors" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"mime" |
||||
|
"net/http" |
||||
|
"os" |
||||
|
"path/filepath" |
||||
|
"strconv" |
||||
|
) |
||||
|
|
||||
|
// Proppatch describes a property update instruction as defined in RFC 4918.
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPPATCH
|
||||
|
type Proppatch struct { |
||||
|
// Remove specifies whether this patch removes properties. If it does not
|
||||
|
// remove them, it sets them.
|
||||
|
Remove bool |
||||
|
// Props contains the properties to be set or removed.
|
||||
|
Props []Property |
||||
|
} |
||||
|
|
||||
|
// Propstat describes a XML propstat element as defined in RFC 4918.
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
|
||||
|
type Propstat struct { |
||||
|
// Props contains the properties for which Status applies.
|
||||
|
Props []Property |
||||
|
|
||||
|
// Status defines the HTTP status code of the properties in Prop.
|
||||
|
// Allowed values include, but are not limited to the WebDAV status
|
||||
|
// code extensions for HTTP/1.1.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#status.code.extensions.to.http11
|
||||
|
Status int |
||||
|
|
||||
|
// XMLError contains the XML representation of the optional error element.
|
||||
|
// XML content within this field must not rely on any predefined
|
||||
|
// namespace declarations or prefixes. If empty, the XML error element
|
||||
|
// is omitted.
|
||||
|
XMLError string |
||||
|
|
||||
|
// ResponseDescription contains the contents of the optional
|
||||
|
// responsedescription field. If empty, the XML element is omitted.
|
||||
|
ResponseDescription string |
||||
|
} |
||||
|
|
||||
|
// makePropstats returns a slice containing those of x and y whose Props slice
|
||||
|
// is non-empty. If both are empty, it returns a slice containing an otherwise
|
||||
|
// zero Propstat whose HTTP status code is 200 OK.
|
||||
|
func makePropstats(x, y Propstat) []Propstat { |
||||
|
pstats := make([]Propstat, 0, 2) |
||||
|
if len(x.Props) != 0 { |
||||
|
pstats = append(pstats, x) |
||||
|
} |
||||
|
if len(y.Props) != 0 { |
||||
|
pstats = append(pstats, y) |
||||
|
} |
||||
|
if len(pstats) == 0 { |
||||
|
pstats = append(pstats, Propstat{ |
||||
|
Status: http.StatusOK, |
||||
|
}) |
||||
|
} |
||||
|
return pstats |
||||
|
} |
||||
|
|
||||
|
// DeadPropsHolder holds the dead properties of a resource.
|
||||
|
//
|
||||
|
// Dead properties are those properties that are explicitly defined. In
|
||||
|
// comparison, live properties, such as DAV:getcontentlength, are implicitly
|
||||
|
// defined by the underlying resource, and cannot be explicitly overridden or
|
||||
|
// removed. See the Terminology section of
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#rfc.section.3
|
||||
|
//
|
||||
|
// There is a whitelist of the names of live properties. This package handles
|
||||
|
// all live properties, and will only pass non-whitelisted names to the Patch
|
||||
|
// method of DeadPropsHolder implementations.
|
||||
|
type DeadPropsHolder interface { |
||||
|
// DeadProps returns a copy of the dead properties held.
|
||||
|
DeadProps() (map[xml.Name]Property, error) |
||||
|
|
||||
|
// Patch patches the dead properties held.
|
||||
|
//
|
||||
|
// Patching is atomic; either all or no patches succeed. It returns (nil,
|
||||
|
// non-nil) if an internal server error occurred, otherwise the Propstats
|
||||
|
// collectively contain one Property for each proposed patch Property. If
|
||||
|
// all patches succeed, Patch returns a slice of length one and a Propstat
|
||||
|
// element with a 200 OK HTTP status code. If none succeed, for reasons
|
||||
|
// other than an internal server error, no Propstat has status 200 OK.
|
||||
|
//
|
||||
|
// For more details on when various HTTP status codes apply, see
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#PROPPATCH-status
|
||||
|
Patch([]Proppatch) ([]Propstat, error) |
||||
|
} |
||||
|
|
||||
|
// liveProps contains all supported, protected DAV: properties.
|
||||
|
var liveProps = map[xml.Name]struct { |
||||
|
// findFn implements the propfind function of this property. If nil,
|
||||
|
// it indicates a hidden property.
|
||||
|
findFn func(context.Context, FileSystem, LockSystem, string, os.FileInfo) (string, error) |
||||
|
// dir is true if the property applies to directories.
|
||||
|
dir bool |
||||
|
}{ |
||||
|
{Space: "DAV:", Local: "resourcetype"}: { |
||||
|
findFn: findResourceType, |
||||
|
dir: true, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "displayname"}: { |
||||
|
findFn: findDisplayName, |
||||
|
dir: true, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "getcontentlength"}: { |
||||
|
findFn: findContentLength, |
||||
|
dir: false, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "getlastmodified"}: { |
||||
|
findFn: findLastModified, |
||||
|
// http://webdav.org/specs/rfc4918.html#PROPERTY_getlastmodified
|
||||
|
// suggests that getlastmodified should only apply to GETable
|
||||
|
// resources, and this package does not support GET on directories.
|
||||
|
//
|
||||
|
// Nonetheless, some WebDAV clients expect child directories to be
|
||||
|
// sortable by getlastmodified date, so this value is true, not false.
|
||||
|
// See golang.org/issue/15334.
|
||||
|
dir: true, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "creationdate"}: { |
||||
|
findFn: nil, |
||||
|
dir: false, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "getcontentlanguage"}: { |
||||
|
findFn: nil, |
||||
|
dir: false, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "getcontenttype"}: { |
||||
|
findFn: findContentType, |
||||
|
dir: false, |
||||
|
}, |
||||
|
{Space: "DAV:", Local: "getetag"}: { |
||||
|
findFn: findETag, |
||||
|
// findETag implements ETag as the concatenated hex values of a file's
|
||||
|
// modification time and size. This is not a reliable synchronization
|
||||
|
// mechanism for directories, so we do not advertise getetag for DAV
|
||||
|
// collections.
|
||||
|
dir: false, |
||||
|
}, |
||||
|
|
||||
|
// TODO: The lockdiscovery property requires LockSystem to list the
|
||||
|
// active locks on a resource.
|
||||
|
{Space: "DAV:", Local: "lockdiscovery"}: {}, |
||||
|
{Space: "DAV:", Local: "supportedlock"}: { |
||||
|
findFn: findSupportedLock, |
||||
|
dir: true, |
||||
|
}, |
||||
|
} |
||||
|
|
||||
|
// TODO(nigeltao) merge props and allprop?
|
||||
|
|
||||
|
// Props returns the status of the properties named pnames for resource name.
|
||||
|
//
|
||||
|
// Each Propstat has a unique status and each property name will only be part
|
||||
|
// of one Propstat element.
|
||||
|
func props(ctx context.Context, fs FileSystem, ls LockSystem, name string, pnames []xml.Name) ([]Propstat, error) { |
||||
|
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
defer f.Close() |
||||
|
fi, err := f.Stat() |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
isDir := fi.IsDir() |
||||
|
|
||||
|
var deadProps map[xml.Name]Property |
||||
|
if dph, ok := f.(DeadPropsHolder); ok { |
||||
|
deadProps, err = dph.DeadProps() |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
pstatOK := Propstat{Status: http.StatusOK} |
||||
|
pstatNotFound := Propstat{Status: http.StatusNotFound} |
||||
|
for _, pn := range pnames { |
||||
|
// If this file has dead properties, check if they contain pn.
|
||||
|
if dp, ok := deadProps[pn]; ok { |
||||
|
pstatOK.Props = append(pstatOK.Props, dp) |
||||
|
continue |
||||
|
} |
||||
|
// Otherwise, it must either be a live property or we don't know it.
|
||||
|
if prop := liveProps[pn]; prop.findFn != nil && (prop.dir || !isDir) { |
||||
|
innerXML, err := prop.findFn(ctx, fs, ls, name, fi) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
pstatOK.Props = append(pstatOK.Props, Property{ |
||||
|
XMLName: pn, |
||||
|
InnerXML: []byte(innerXML), |
||||
|
}) |
||||
|
} else { |
||||
|
pstatNotFound.Props = append(pstatNotFound.Props, Property{ |
||||
|
XMLName: pn, |
||||
|
}) |
||||
|
} |
||||
|
} |
||||
|
return makePropstats(pstatOK, pstatNotFound), nil |
||||
|
} |
||||
|
|
||||
|
// Propnames returns the property names defined for resource name.
|
||||
|
func propnames(ctx context.Context, fs FileSystem, ls LockSystem, name string) ([]xml.Name, error) { |
||||
|
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
defer f.Close() |
||||
|
fi, err := f.Stat() |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
isDir := fi.IsDir() |
||||
|
|
||||
|
var deadProps map[xml.Name]Property |
||||
|
if dph, ok := f.(DeadPropsHolder); ok { |
||||
|
deadProps, err = dph.DeadProps() |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
pnames := make([]xml.Name, 0, len(liveProps)+len(deadProps)) |
||||
|
for pn, prop := range liveProps { |
||||
|
if prop.findFn != nil && (prop.dir || !isDir) { |
||||
|
pnames = append(pnames, pn) |
||||
|
} |
||||
|
} |
||||
|
for pn := range deadProps { |
||||
|
pnames = append(pnames, pn) |
||||
|
} |
||||
|
return pnames, nil |
||||
|
} |
||||
|
|
||||
|
// Allprop returns the properties defined for resource name and the properties
|
||||
|
// named in include.
|
||||
|
//
|
||||
|
// Note that RFC 4918 defines 'allprop' to return the DAV: properties defined
|
||||
|
// within the RFC plus dead properties. Other live properties should only be
|
||||
|
// returned if they are named in 'include'.
|
||||
|
//
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
|
||||
|
func allprop(ctx context.Context, fs FileSystem, ls LockSystem, name string, include []xml.Name) ([]Propstat, error) { |
||||
|
pnames, err := propnames(ctx, fs, ls, name) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
// Add names from include if they are not already covered in pnames.
|
||||
|
nameset := make(map[xml.Name]bool) |
||||
|
for _, pn := range pnames { |
||||
|
nameset[pn] = true |
||||
|
} |
||||
|
for _, pn := range include { |
||||
|
if !nameset[pn] { |
||||
|
pnames = append(pnames, pn) |
||||
|
} |
||||
|
} |
||||
|
return props(ctx, fs, ls, name, pnames) |
||||
|
} |
||||
|
|
||||
|
// Patch patches the properties of resource name. The return values are
|
||||
|
// constrained in the same manner as DeadPropsHolder.Patch.
|
||||
|
func patch(ctx context.Context, fs FileSystem, ls LockSystem, name string, patches []Proppatch) ([]Propstat, error) { |
||||
|
conflict := false |
||||
|
loop: |
||||
|
for _, patch := range patches { |
||||
|
for _, p := range patch.Props { |
||||
|
if _, ok := liveProps[p.XMLName]; ok { |
||||
|
conflict = true |
||||
|
break loop |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
if conflict { |
||||
|
pstatForbidden := Propstat{ |
||||
|
Status: http.StatusForbidden, |
||||
|
XMLError: `<D:cannot-modify-protected-property xmlns:D="DAV:"/>`, |
||||
|
} |
||||
|
pstatFailedDep := Propstat{ |
||||
|
Status: StatusFailedDependency, |
||||
|
} |
||||
|
for _, patch := range patches { |
||||
|
for _, p := range patch.Props { |
||||
|
if _, ok := liveProps[p.XMLName]; ok { |
||||
|
pstatForbidden.Props = append(pstatForbidden.Props, Property{XMLName: p.XMLName}) |
||||
|
} else { |
||||
|
pstatFailedDep.Props = append(pstatFailedDep.Props, Property{XMLName: p.XMLName}) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return makePropstats(pstatForbidden, pstatFailedDep), nil |
||||
|
} |
||||
|
|
||||
|
f, err := fs.OpenFile(ctx, name, os.O_RDWR, 0) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
defer f.Close() |
||||
|
if dph, ok := f.(DeadPropsHolder); ok { |
||||
|
ret, err := dph.Patch(patches) |
||||
|
if err != nil { |
||||
|
return nil, err |
||||
|
} |
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat says that
|
||||
|
// "The contents of the prop XML element must only list the names of
|
||||
|
// properties to which the result in the status element applies."
|
||||
|
for _, pstat := range ret { |
||||
|
for i, p := range pstat.Props { |
||||
|
pstat.Props[i] = Property{XMLName: p.XMLName} |
||||
|
} |
||||
|
} |
||||
|
return ret, nil |
||||
|
} |
||||
|
// The file doesn't implement the optional DeadPropsHolder interface, so
|
||||
|
// all patches are forbidden.
|
||||
|
pstat := Propstat{Status: http.StatusForbidden} |
||||
|
for _, patch := range patches { |
||||
|
for _, p := range patch.Props { |
||||
|
pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName}) |
||||
|
} |
||||
|
} |
||||
|
return []Propstat{pstat}, nil |
||||
|
} |
||||
|
|
||||
|
func escapeXML(s string) string { |
||||
|
for i := 0; i < len(s); i++ { |
||||
|
// As an optimization, if s contains only ASCII letters, digits or a
|
||||
|
// few special characters, the escaped value is s itself and we don't
|
||||
|
// need to allocate a buffer and convert between string and []byte.
|
||||
|
switch c := s[i]; { |
||||
|
case c == ' ' || c == '_' || |
||||
|
('+' <= c && c <= '9') || // Digits as well as + , - . and /
|
||||
|
('A' <= c && c <= 'Z') || |
||||
|
('a' <= c && c <= 'z'): |
||||
|
continue |
||||
|
} |
||||
|
// Otherwise, go through the full escaping process.
|
||||
|
var buf bytes.Buffer |
||||
|
xml.EscapeText(&buf, []byte(s)) |
||||
|
return buf.String() |
||||
|
} |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
func findResourceType(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
if fi.IsDir() { |
||||
|
return `<D:collection xmlns:D="DAV:"/>`, nil |
||||
|
} |
||||
|
return "", nil |
||||
|
} |
||||
|
|
||||
|
func findDisplayName(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
if slashClean(name) == "/" { |
||||
|
// Hide the real name of a possibly prefixed root directory.
|
||||
|
return "", nil |
||||
|
} |
||||
|
return escapeXML(fi.Name()), nil |
||||
|
} |
||||
|
|
||||
|
func findContentLength(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
return strconv.FormatInt(fi.Size(), 10), nil |
||||
|
} |
||||
|
|
||||
|
func findLastModified(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
return fi.ModTime().UTC().Format(http.TimeFormat), nil |
||||
|
} |
||||
|
|
||||
|
// ErrNotImplemented should be returned by optional interfaces if they
|
||||
|
// want the original implementation to be used.
|
||||
|
var ErrNotImplemented = errors.New("not implemented") |
||||
|
|
||||
|
// ContentTyper is an optional interface for the os.FileInfo
|
||||
|
// objects returned by the FileSystem.
|
||||
|
//
|
||||
|
// If this interface is defined then it will be used to read the
|
||||
|
// content type from the object.
|
||||
|
//
|
||||
|
// If this interface is not defined the file will be opened and the
|
||||
|
// content type will be guessed from the initial contents of the file.
|
||||
|
type ContentTyper interface { |
||||
|
// ContentType returns the content type for the file.
|
||||
|
//
|
||||
|
// If this returns error ErrNotImplemented then the error will
|
||||
|
// be ignored and the base implementation will be used
|
||||
|
// instead.
|
||||
|
ContentType(ctx context.Context) (string, error) |
||||
|
} |
||||
|
|
||||
|
func findContentType(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
if do, ok := fi.(ContentTyper); ok { |
||||
|
ctype, err := do.ContentType(ctx) |
||||
|
if err != ErrNotImplemented { |
||||
|
return ctype, err |
||||
|
} |
||||
|
} |
||||
|
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0) |
||||
|
if err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
defer f.Close() |
||||
|
// This implementation is based on serveContent's code in the standard net/http package.
|
||||
|
ctype := mime.TypeByExtension(filepath.Ext(name)) |
||||
|
if ctype != "" { |
||||
|
return ctype, nil |
||||
|
} |
||||
|
// Read a chunk to decide between utf-8 text and binary.
|
||||
|
var buf [512]byte |
||||
|
n, err := io.ReadFull(f, buf[:]) |
||||
|
if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { |
||||
|
return "", err |
||||
|
} |
||||
|
ctype = http.DetectContentType(buf[:n]) |
||||
|
// Rewind file.
|
||||
|
_, err = f.Seek(0, os.SEEK_SET) |
||||
|
return ctype, err |
||||
|
} |
||||
|
|
||||
|
// ETager is an optional interface for the os.FileInfo objects
|
||||
|
// returned by the FileSystem.
|
||||
|
//
|
||||
|
// If this interface is defined then it will be used to read the ETag
|
||||
|
// for the object.
|
||||
|
//
|
||||
|
// If this interface is not defined an ETag will be computed using the
|
||||
|
// ModTime() and the Size() methods of the os.FileInfo object.
|
||||
|
type ETager interface { |
||||
|
// ETag returns an ETag for the file. This should be of the
|
||||
|
// form "value" or W/"value"
|
||||
|
//
|
||||
|
// If this returns error ErrNotImplemented then the error will
|
||||
|
// be ignored and the base implementation will be used
|
||||
|
// instead.
|
||||
|
ETag(ctx context.Context) (string, error) |
||||
|
} |
||||
|
|
||||
|
func findETag(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
if do, ok := fi.(ETager); ok { |
||||
|
etag, err := do.ETag(ctx) |
||||
|
if err != ErrNotImplemented { |
||||
|
return etag, err |
||||
|
} |
||||
|
} |
||||
|
// The Apache http 2.4 web server by default concatenates the
|
||||
|
// modification time and size of a file. We replicate the heuristic
|
||||
|
// with nanosecond granularity.
|
||||
|
return fmt.Sprintf(`"%x%x"`, fi.ModTime().UnixNano(), fi.Size()), nil |
||||
|
} |
||||
|
|
||||
|
func findSupportedLock(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) { |
||||
|
return `` + |
||||
|
`<D:lockentry xmlns:D="DAV:">` + |
||||
|
`<D:lockscope><D:exclusive/></D:lockscope>` + |
||||
|
`<D:locktype><D:write/></D:locktype>` + |
||||
|
`</D:lockentry>`, nil |
||||
|
} |
||||
@ -0,0 +1,706 @@ |
|||||
|
// 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 provides a WebDAV server implementation.
|
||||
|
package dav // import "golang.org/x/net/webdav"
|
||||
|
|
||||
|
import ( |
||||
|
"errors" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"net/http" |
||||
|
"net/url" |
||||
|
"os" |
||||
|
"path" |
||||
|
"strings" |
||||
|
"time" |
||||
|
) |
||||
|
|
||||
|
type Handler struct { |
||||
|
// Prefix is the URL path prefix to strip from WebDAV resource paths.
|
||||
|
Prefix string |
||||
|
// FileSystem is the virtual file system.
|
||||
|
FileSystem FileSystem |
||||
|
// LockSystem is the lock management system.
|
||||
|
LockSystem LockSystem |
||||
|
// Logger is an optional error logger. If non-nil, it will be called
|
||||
|
// for all HTTP requests.
|
||||
|
Logger func(*http.Request, error) |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) stripPrefix(p string) (string, int, error) { |
||||
|
if h.Prefix == "" { |
||||
|
return p, http.StatusOK, nil |
||||
|
} |
||||
|
if r := strings.TrimPrefix(p, h.Prefix); len(r) < len(p) { |
||||
|
return r, http.StatusOK, nil |
||||
|
} |
||||
|
return p, http.StatusNotFound, errPrefixMismatch |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { |
||||
|
status, err := http.StatusBadRequest, errUnsupportedMethod |
||||
|
if h.FileSystem == nil { |
||||
|
status, err = http.StatusInternalServerError, errNoFileSystem |
||||
|
} else if h.LockSystem == nil { |
||||
|
status, err = http.StatusInternalServerError, errNoLockSystem |
||||
|
} else { |
||||
|
switch r.Method { |
||||
|
case "OPTIONS": |
||||
|
status, err = h.handleOptions(w, r) |
||||
|
case "GET", "HEAD", "POST": |
||||
|
status, err = h.handleGetHeadPost(w, r) |
||||
|
case "DELETE": |
||||
|
status, err = h.handleDelete(w, r) |
||||
|
case "PUT": |
||||
|
status, err = h.handlePut(w, r) |
||||
|
case "MKCOL": |
||||
|
status, err = h.handleMkcol(w, r) |
||||
|
case "COPY", "MOVE": |
||||
|
status, err = h.handleCopyMove(w, r) |
||||
|
case "LOCK": |
||||
|
status, err = h.handleLock(w, r) |
||||
|
case "UNLOCK": |
||||
|
status, err = h.handleUnlock(w, r) |
||||
|
case "PROPFIND": |
||||
|
status, err = h.handlePropfind(w, r) |
||||
|
case "PROPPATCH": |
||||
|
status, err = h.handleProppatch(w, r) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if status != 0 { |
||||
|
w.WriteHeader(status) |
||||
|
if status != http.StatusNoContent { |
||||
|
w.Write([]byte(StatusText(status))) |
||||
|
} |
||||
|
} |
||||
|
if h.Logger != nil { |
||||
|
h.Logger(r, err) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) lock(now time.Time, root string) (token string, status int, err error) { |
||||
|
token, err = h.LockSystem.Create(now, LockDetails{ |
||||
|
Root: root, |
||||
|
Duration: infiniteTimeout, |
||||
|
ZeroDepth: true, |
||||
|
}) |
||||
|
if err != nil { |
||||
|
if err == ErrLocked { |
||||
|
return "", StatusLocked, err |
||||
|
} |
||||
|
return "", http.StatusInternalServerError, err |
||||
|
} |
||||
|
return token, 0, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) confirmLocks(r *http.Request, src, dst string) (release func(), status int, err error) { |
||||
|
hdr := r.Header.Get("If") |
||||
|
if hdr == "" { |
||||
|
// An empty If header means that the client hasn't previously created locks.
|
||||
|
// Even if this client doesn't care about locks, we still need to check that
|
||||
|
// the resources aren't locked by another client, so we create temporary
|
||||
|
// locks that would conflict with another client's locks. These temporary
|
||||
|
// locks are unlocked at the end of the HTTP request.
|
||||
|
now, srcToken, dstToken := time.Now(), "", "" |
||||
|
if src != "" { |
||||
|
srcToken, status, err = h.lock(now, src) |
||||
|
if err != nil { |
||||
|
return nil, status, err |
||||
|
} |
||||
|
} |
||||
|
if dst != "" { |
||||
|
dstToken, status, err = h.lock(now, dst) |
||||
|
if err != nil { |
||||
|
if srcToken != "" { |
||||
|
h.LockSystem.Unlock(now, srcToken) |
||||
|
} |
||||
|
return nil, status, err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return func() { |
||||
|
if dstToken != "" { |
||||
|
h.LockSystem.Unlock(now, dstToken) |
||||
|
} |
||||
|
if srcToken != "" { |
||||
|
h.LockSystem.Unlock(now, srcToken) |
||||
|
} |
||||
|
}, 0, nil |
||||
|
} |
||||
|
|
||||
|
ih, ok := parseIfHeader(hdr) |
||||
|
if !ok { |
||||
|
return nil, http.StatusBadRequest, errInvalidIfHeader |
||||
|
} |
||||
|
// ih is a disjunction (OR) of ifLists, so any ifList will do.
|
||||
|
for _, l := range ih.lists { |
||||
|
lsrc := l.resourceTag |
||||
|
if lsrc == "" { |
||||
|
lsrc = src |
||||
|
} else { |
||||
|
u, err := url.Parse(lsrc) |
||||
|
if err != nil { |
||||
|
continue |
||||
|
} |
||||
|
if u.Host != r.Host { |
||||
|
continue |
||||
|
} |
||||
|
lsrc, status, err = h.stripPrefix(u.Path) |
||||
|
if err != nil { |
||||
|
return nil, status, err |
||||
|
} |
||||
|
} |
||||
|
release, err = h.LockSystem.Confirm(time.Now(), lsrc, dst, l.conditions...) |
||||
|
if err == ErrConfirmationFailed { |
||||
|
continue |
||||
|
} |
||||
|
if err != nil { |
||||
|
return nil, http.StatusInternalServerError, err |
||||
|
} |
||||
|
return release, 0, nil |
||||
|
} |
||||
|
// Section 10.4.1 says that "If this header is evaluated and all state lists
|
||||
|
// fail, then the request must fail with a 412 (Precondition Failed) status."
|
||||
|
// We follow the spec even though the cond_put_corrupt_token test case from
|
||||
|
// the litmus test warns on seeing a 412 instead of a 423 (Locked).
|
||||
|
return nil, http.StatusPreconditionFailed, ErrLocked |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleOptions(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
ctx := r.Context() |
||||
|
allow := "OPTIONS, LOCK, PUT, MKCOL" |
||||
|
if fi, err := h.FileSystem.Stat(ctx, reqPath); err == nil { |
||||
|
if fi.IsDir() { |
||||
|
allow = "OPTIONS, LOCK, DELETE, PROPPATCH, COPY, MOVE, UNLOCK, PROPFIND" |
||||
|
} else { |
||||
|
allow = "OPTIONS, LOCK, GET, HEAD, POST, DELETE, PROPPATCH, COPY, MOVE, UNLOCK, PROPFIND, PUT" |
||||
|
} |
||||
|
} |
||||
|
w.Header().Set("Allow", allow) |
||||
|
// http://www.webdav.org/specs/rfc4918.html#dav.compliance.classes
|
||||
|
w.Header().Set("DAV", "1, 2") |
||||
|
// http://msdn.microsoft.com/en-au/library/cc250217.aspx
|
||||
|
w.Header().Set("MS-Author-Via", "DAV") |
||||
|
return 0, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleGetHeadPost(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
// TODO: check locks for read-only access??
|
||||
|
ctx := r.Context() |
||||
|
f, err := h.FileSystem.OpenFile(ctx, reqPath, os.O_RDONLY, 0) |
||||
|
if err != nil { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
defer f.Close() |
||||
|
fi, err := f.Stat() |
||||
|
if err != nil { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
if fi.IsDir() { |
||||
|
return http.StatusMethodNotAllowed, nil |
||||
|
} |
||||
|
etag, err := findETag(ctx, h.FileSystem, h.LockSystem, reqPath, fi) |
||||
|
if err != nil { |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
w.Header().Set("ETag", etag) |
||||
|
// Let ServeContent determine the Content-Type header.
|
||||
|
http.ServeContent(w, r, reqPath, fi.ModTime(), f) |
||||
|
return 0, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleDelete(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
release, status, err := h.confirmLocks(r, reqPath, "") |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
|
||||
|
ctx := r.Context() |
||||
|
|
||||
|
// TODO: return MultiStatus where appropriate.
|
||||
|
|
||||
|
// "godoc os RemoveAll" says that "If the path does not exist, RemoveAll
|
||||
|
// returns nil (no error)." WebDAV semantics are that it should return a
|
||||
|
// "404 Not Found". We therefore have to Stat before we RemoveAll.
|
||||
|
if _, err := h.FileSystem.Stat(ctx, reqPath); err != nil { |
||||
|
if os.IsNotExist(err) { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
return http.StatusMethodNotAllowed, err |
||||
|
} |
||||
|
if err := h.FileSystem.RemoveAll(ctx, reqPath); err != nil { |
||||
|
return http.StatusMethodNotAllowed, err |
||||
|
} |
||||
|
return http.StatusNoContent, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handlePut(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
release, status, err := h.confirmLocks(r, reqPath, "") |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
// TODO(rost): Support the If-Match, If-None-Match headers? See bradfitz'
|
||||
|
// comments in http.checkEtag.
|
||||
|
ctx := r.Context() |
||||
|
|
||||
|
f, err := h.FileSystem.OpenFile(ctx, reqPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666) |
||||
|
if err != nil { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
_, copyErr := io.Copy(f, r.Body) |
||||
|
fi, statErr := f.Stat() |
||||
|
closeErr := f.Close() |
||||
|
// TODO(rost): Returning 405 Method Not Allowed might not be appropriate.
|
||||
|
if copyErr != nil { |
||||
|
return http.StatusMethodNotAllowed, copyErr |
||||
|
} |
||||
|
if statErr != nil { |
||||
|
return http.StatusMethodNotAllowed, statErr |
||||
|
} |
||||
|
if closeErr != nil { |
||||
|
return http.StatusMethodNotAllowed, closeErr |
||||
|
} |
||||
|
etag, err := findETag(ctx, h.FileSystem, h.LockSystem, reqPath, fi) |
||||
|
if err != nil { |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
w.Header().Set("ETag", etag) |
||||
|
return http.StatusCreated, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleMkcol(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
release, status, err := h.confirmLocks(r, reqPath, "") |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
|
||||
|
ctx := r.Context() |
||||
|
|
||||
|
if r.ContentLength > 0 { |
||||
|
return http.StatusUnsupportedMediaType, nil |
||||
|
} |
||||
|
if err := h.FileSystem.Mkdir(ctx, reqPath, 0777); err != nil { |
||||
|
if os.IsNotExist(err) { |
||||
|
return http.StatusConflict, err |
||||
|
} |
||||
|
return http.StatusMethodNotAllowed, err |
||||
|
} |
||||
|
return http.StatusCreated, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleCopyMove(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
hdr := r.Header.Get("Destination") |
||||
|
if hdr == "" { |
||||
|
return http.StatusBadRequest, errInvalidDestination |
||||
|
} |
||||
|
u, err := url.Parse(hdr) |
||||
|
if err != nil { |
||||
|
return http.StatusBadRequest, errInvalidDestination |
||||
|
} |
||||
|
if u.Host != r.Host { |
||||
|
return http.StatusBadGateway, errInvalidDestination |
||||
|
} |
||||
|
|
||||
|
src, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
|
||||
|
dst, status, err := h.stripPrefix(u.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
|
||||
|
if dst == "" { |
||||
|
return http.StatusBadGateway, errInvalidDestination |
||||
|
} |
||||
|
if dst == src { |
||||
|
return http.StatusForbidden, errDestinationEqualsSource |
||||
|
} |
||||
|
|
||||
|
ctx := r.Context() |
||||
|
|
||||
|
if r.Method == "COPY" { |
||||
|
// Section 7.5.1 says that a COPY only needs to lock the destination,
|
||||
|
// not both destination and source. Strictly speaking, this is racy,
|
||||
|
// even though a COPY doesn't modify the source, if a concurrent
|
||||
|
// operation modifies the source. However, the litmus test explicitly
|
||||
|
// checks that COPYing a locked-by-another source is OK.
|
||||
|
release, status, err := h.confirmLocks(r, "", dst) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
|
||||
|
// Section 9.8.3 says that "The COPY method on a collection without a Depth
|
||||
|
// header must act as if a Depth header with value "infinity" was included".
|
||||
|
depth := infiniteDepth |
||||
|
if hdr := r.Header.Get("Depth"); hdr != "" { |
||||
|
depth = parseDepth(hdr) |
||||
|
if depth != 0 && depth != infiniteDepth { |
||||
|
// Section 9.8.3 says that "A client may submit a Depth header on a
|
||||
|
// COPY on a collection with a value of "0" or "infinity"."
|
||||
|
return http.StatusBadRequest, errInvalidDepth |
||||
|
} |
||||
|
} |
||||
|
return copyFiles(ctx, h.FileSystem, src, dst, r.Header.Get("Overwrite") != "F", depth, 0) |
||||
|
} |
||||
|
|
||||
|
release, status, err := h.confirmLocks(r, src, dst) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
|
||||
|
// Section 9.9.2 says that "The MOVE method on a collection must act as if
|
||||
|
// a "Depth: infinity" header was used on it. A client must not submit a
|
||||
|
// Depth header on a MOVE on a collection with any value but "infinity"."
|
||||
|
if hdr := r.Header.Get("Depth"); hdr != "" { |
||||
|
if parseDepth(hdr) != infiniteDepth { |
||||
|
return http.StatusBadRequest, errInvalidDepth |
||||
|
} |
||||
|
} |
||||
|
return moveFiles(ctx, h.FileSystem, src, dst, r.Header.Get("Overwrite") == "T") |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleLock(w http.ResponseWriter, r *http.Request) (retStatus int, retErr error) { |
||||
|
duration, err := parseTimeout(r.Header.Get("Timeout")) |
||||
|
if err != nil { |
||||
|
return http.StatusBadRequest, err |
||||
|
} |
||||
|
li, status, err := readLockInfo(r.Body) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
|
||||
|
ctx := r.Context() |
||||
|
token, ld, now, created := "", LockDetails{}, time.Now(), false |
||||
|
if li == (lockInfo{}) { |
||||
|
// An empty lockInfo means to refresh the lock.
|
||||
|
ih, ok := parseIfHeader(r.Header.Get("If")) |
||||
|
if !ok { |
||||
|
return http.StatusBadRequest, errInvalidIfHeader |
||||
|
} |
||||
|
if len(ih.lists) == 1 && len(ih.lists[0].conditions) == 1 { |
||||
|
token = ih.lists[0].conditions[0].Token |
||||
|
} |
||||
|
if token == "" { |
||||
|
return http.StatusBadRequest, errInvalidLockToken |
||||
|
} |
||||
|
ld, err = h.LockSystem.Refresh(now, token, duration) |
||||
|
if err != nil { |
||||
|
if err == ErrNoSuchLock { |
||||
|
return http.StatusPreconditionFailed, err |
||||
|
} |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
|
||||
|
} else { |
||||
|
// Section 9.10.3 says that "If no Depth header is submitted on a LOCK request,
|
||||
|
// then the request MUST act as if a "Depth:infinity" had been submitted."
|
||||
|
depth := infiniteDepth |
||||
|
if hdr := r.Header.Get("Depth"); hdr != "" { |
||||
|
depth = parseDepth(hdr) |
||||
|
if depth != 0 && depth != infiniteDepth { |
||||
|
// Section 9.10.3 says that "Values other than 0 or infinity must not be
|
||||
|
// used with the Depth header on a LOCK method".
|
||||
|
return http.StatusBadRequest, errInvalidDepth |
||||
|
} |
||||
|
} |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
ld = LockDetails{ |
||||
|
Root: reqPath, |
||||
|
Duration: duration, |
||||
|
OwnerXML: li.Owner.InnerXML, |
||||
|
ZeroDepth: depth == 0, |
||||
|
} |
||||
|
token, err = h.LockSystem.Create(now, ld) |
||||
|
if err != nil { |
||||
|
if err == ErrLocked { |
||||
|
return StatusLocked, err |
||||
|
} |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
defer func() { |
||||
|
if retErr != nil { |
||||
|
h.LockSystem.Unlock(now, token) |
||||
|
} |
||||
|
}() |
||||
|
|
||||
|
// Create the resource if it didn't previously exist.
|
||||
|
if _, err := h.FileSystem.Stat(ctx, reqPath); err != nil { |
||||
|
f, err := h.FileSystem.OpenFile(ctx, reqPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666) |
||||
|
if err != nil { |
||||
|
// TODO: detect missing intermediate dirs and return http.StatusConflict?
|
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
f.Close() |
||||
|
created = true |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#HEADER_Lock-Token says that the
|
||||
|
// Lock-Token value is a Coded-URL. We add angle brackets.
|
||||
|
w.Header().Set("Lock-Token", "<"+token+">") |
||||
|
} |
||||
|
|
||||
|
w.Header().Set("Content-Type", "application/xml; charset=utf-8") |
||||
|
if created { |
||||
|
// This is "w.WriteHeader(http.StatusCreated)" and not "return
|
||||
|
// http.StatusCreated, nil" because we write our own (XML) response to w
|
||||
|
// and Handler.ServeHTTP would otherwise write "Created".
|
||||
|
w.WriteHeader(http.StatusCreated) |
||||
|
} |
||||
|
writeLockInfo(w, token, ld) |
||||
|
return 0, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleUnlock(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
// http://www.webdav.org/specs/rfc4918.html#HEADER_Lock-Token says that the
|
||||
|
// Lock-Token value is a Coded-URL. We strip its angle brackets.
|
||||
|
t := r.Header.Get("Lock-Token") |
||||
|
if len(t) < 2 || t[0] != '<' || t[len(t)-1] != '>' { |
||||
|
return http.StatusBadRequest, errInvalidLockToken |
||||
|
} |
||||
|
t = t[1 : len(t)-1] |
||||
|
|
||||
|
switch err = h.LockSystem.Unlock(time.Now(), t); err { |
||||
|
case nil: |
||||
|
return http.StatusNoContent, err |
||||
|
case ErrForbidden: |
||||
|
return http.StatusForbidden, err |
||||
|
case ErrLocked: |
||||
|
return StatusLocked, err |
||||
|
case ErrNoSuchLock: |
||||
|
return http.StatusConflict, err |
||||
|
default: |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
ctx := r.Context() |
||||
|
fi, err := h.FileSystem.Stat(ctx, reqPath) |
||||
|
if err != nil { |
||||
|
if os.IsNotExist(err) { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
return http.StatusMethodNotAllowed, err |
||||
|
} |
||||
|
depth := infiniteDepth |
||||
|
if hdr := r.Header.Get("Depth"); hdr != "" { |
||||
|
depth = parseDepth(hdr) |
||||
|
if depth == invalidDepth { |
||||
|
return http.StatusBadRequest, errInvalidDepth |
||||
|
} |
||||
|
} |
||||
|
pf, status, err := readPropfind(r.Body) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
|
||||
|
mw := multistatusWriter{w: w} |
||||
|
|
||||
|
walkFn := func(reqPath string, info os.FileInfo, err error) error { |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
var pstats []Propstat |
||||
|
if pf.Propname != nil { |
||||
|
pnames, err := propnames(ctx, h.FileSystem, h.LockSystem, reqPath) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
pstat := Propstat{Status: http.StatusOK} |
||||
|
for _, xmlname := range pnames { |
||||
|
pstat.Props = append(pstat.Props, Property{XMLName: xmlname}) |
||||
|
} |
||||
|
pstats = append(pstats, pstat) |
||||
|
} else if pf.Allprop != nil { |
||||
|
pstats, err = allprop(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop) |
||||
|
} else { |
||||
|
pstats, err = props(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop) |
||||
|
} |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
href := path.Join(h.Prefix, reqPath) |
||||
|
if info.IsDir() { |
||||
|
href += "/" |
||||
|
} |
||||
|
return mw.write(makePropstatResponse(href, pstats)) |
||||
|
} |
||||
|
|
||||
|
walkErr := walkFS(ctx, h.FileSystem, depth, reqPath, fi, walkFn) |
||||
|
closeErr := mw.close() |
||||
|
if walkErr != nil { |
||||
|
return http.StatusInternalServerError, walkErr |
||||
|
} |
||||
|
if closeErr != nil { |
||||
|
return http.StatusInternalServerError, closeErr |
||||
|
} |
||||
|
return 0, nil |
||||
|
} |
||||
|
|
||||
|
func (h *Handler) handleProppatch(w http.ResponseWriter, r *http.Request) (status int, err error) { |
||||
|
reqPath, status, err := h.stripPrefix(r.URL.Path) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
release, status, err := h.confirmLocks(r, reqPath, "") |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
defer release() |
||||
|
|
||||
|
ctx := r.Context() |
||||
|
|
||||
|
if _, err := h.FileSystem.Stat(ctx, reqPath); err != nil { |
||||
|
if os.IsNotExist(err) { |
||||
|
return http.StatusNotFound, err |
||||
|
} |
||||
|
return http.StatusMethodNotAllowed, err |
||||
|
} |
||||
|
patches, status, err := readProppatch(r.Body) |
||||
|
if err != nil { |
||||
|
return status, err |
||||
|
} |
||||
|
pstats, err := patch(ctx, h.FileSystem, h.LockSystem, reqPath, patches) |
||||
|
if err != nil { |
||||
|
return http.StatusInternalServerError, err |
||||
|
} |
||||
|
mw := multistatusWriter{w: w} |
||||
|
writeErr := mw.write(makePropstatResponse(r.URL.Path, pstats)) |
||||
|
closeErr := mw.close() |
||||
|
if writeErr != nil { |
||||
|
return http.StatusInternalServerError, writeErr |
||||
|
} |
||||
|
if closeErr != nil { |
||||
|
return http.StatusInternalServerError, closeErr |
||||
|
} |
||||
|
return 0, nil |
||||
|
} |
||||
|
|
||||
|
func makePropstatResponse(href string, pstats []Propstat) *response { |
||||
|
resp := response{ |
||||
|
Href: []string{(&url.URL{Path: href}).EscapedPath()}, |
||||
|
Propstat: make([]propstat, 0, len(pstats)), |
||||
|
} |
||||
|
for _, p := range pstats { |
||||
|
var xmlErr *xmlError |
||||
|
if p.XMLError != "" { |
||||
|
xmlErr = &xmlError{InnerXML: []byte(p.XMLError)} |
||||
|
} |
||||
|
resp.Propstat = append(resp.Propstat, propstat{ |
||||
|
Status: fmt.Sprintf("HTTP/1.1 %d %s", p.Status, StatusText(p.Status)), |
||||
|
Prop: p.Props, |
||||
|
ResponseDescription: p.ResponseDescription, |
||||
|
Error: xmlErr, |
||||
|
}) |
||||
|
} |
||||
|
return &resp |
||||
|
} |
||||
|
|
||||
|
const ( |
||||
|
infiniteDepth = -1 |
||||
|
invalidDepth = -2 |
||||
|
) |
||||
|
|
||||
|
// parseDepth maps the strings "0", "1" and "infinity" to 0, 1 and
|
||||
|
// infiniteDepth. Parsing any other string returns invalidDepth.
|
||||
|
//
|
||||
|
// Different WebDAV methods have further constraints on valid depths:
|
||||
|
// - PROPFIND has no further restrictions, as per section 9.1.
|
||||
|
// - COPY accepts only "0" or "infinity", as per section 9.8.3.
|
||||
|
// - MOVE accepts only "infinity", as per section 9.9.2.
|
||||
|
// - LOCK accepts only "0" or "infinity", as per section 9.10.3.
|
||||
|
// These constraints are enforced by the handleXxx methods.
|
||||
|
func parseDepth(s string) int { |
||||
|
switch s { |
||||
|
case "0": |
||||
|
return 0 |
||||
|
case "1": |
||||
|
return 1 |
||||
|
case "infinity": |
||||
|
return infiniteDepth |
||||
|
} |
||||
|
return invalidDepth |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#status.code.extensions.to.http11
|
||||
|
const ( |
||||
|
StatusMulti = 207 |
||||
|
StatusUnprocessableEntity = 422 |
||||
|
StatusLocked = 423 |
||||
|
StatusFailedDependency = 424 |
||||
|
StatusInsufficientStorage = 507 |
||||
|
) |
||||
|
|
||||
|
func StatusText(code int) string { |
||||
|
switch code { |
||||
|
case StatusMulti: |
||||
|
return "Multi-Status" |
||||
|
case StatusUnprocessableEntity: |
||||
|
return "Unprocessable Entity" |
||||
|
case StatusLocked: |
||||
|
return "Locked" |
||||
|
case StatusFailedDependency: |
||||
|
return "Failed Dependency" |
||||
|
case StatusInsufficientStorage: |
||||
|
return "Insufficient Storage" |
||||
|
} |
||||
|
return http.StatusText(code) |
||||
|
} |
||||
|
|
||||
|
var ( |
||||
|
errDestinationEqualsSource = errors.New("webdav: destination equals source") |
||||
|
errDirectoryNotEmpty = errors.New("webdav: directory not empty") |
||||
|
errInvalidDepth = errors.New("webdav: invalid depth") |
||||
|
errInvalidDestination = errors.New("webdav: invalid destination") |
||||
|
errInvalidIfHeader = errors.New("webdav: invalid If header") |
||||
|
errInvalidLockInfo = errors.New("webdav: invalid lock info") |
||||
|
errInvalidLockToken = errors.New("webdav: invalid lock token") |
||||
|
errInvalidPropfind = errors.New("webdav: invalid propfind") |
||||
|
errInvalidProppatch = errors.New("webdav: invalid proppatch") |
||||
|
errInvalidResponse = errors.New("webdav: invalid response") |
||||
|
errInvalidTimeout = errors.New("webdav: invalid timeout") |
||||
|
errNoFileSystem = errors.New("webdav: no file system") |
||||
|
errNoLockSystem = errors.New("webdav: no lock system") |
||||
|
errNotADirectory = errors.New("webdav: not a directory") |
||||
|
errPrefixMismatch = errors.New("webdav: prefix mismatch") |
||||
|
errRecursionTooDeep = errors.New("webdav: recursion too deep") |
||||
|
errUnsupportedLockInfo = errors.New("webdav: unsupported lock info") |
||||
|
errUnsupportedMethod = errors.New("webdav: unsupported method") |
||||
|
) |
||||
@ -0,0 +1,519 @@ |
|||||
|
// 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 dav |
||||
|
|
||||
|
// The XML encoding is covered by Section 14.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#xml.element.definitions
|
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"encoding/xml" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"net/http" |
||||
|
"time" |
||||
|
|
||||
|
// As of https://go-review.googlesource.com/#/c/12772/ which was submitted
|
||||
|
// in July 2015, this package uses an internal fork of the standard
|
||||
|
// library's encoding/xml package, due to changes in the way namespaces
|
||||
|
// were encoded. Such changes were introduced in the Go 1.5 cycle, but were
|
||||
|
// rolled back in response to https://github.com/golang/go/issues/11841
|
||||
|
//
|
||||
|
// However, this package's exported API, specifically the Property and
|
||||
|
// DeadPropsHolder types, need to refer to the standard library's version
|
||||
|
// of the xml.Name type, as code that imports this package cannot refer to
|
||||
|
// the internal version.
|
||||
|
//
|
||||
|
// This file therefore imports both the internal and external versions, as
|
||||
|
// ixml and xml, and converts between them.
|
||||
|
//
|
||||
|
// In the long term, this package should use the standard library's version
|
||||
|
// only, and the internal fork deleted, once
|
||||
|
// https://github.com/golang/go/issues/13400 is resolved.
|
||||
|
ixml "tank/rest/dav/internal/xml" |
||||
|
) |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_lockinfo
|
||||
|
type lockInfo struct { |
||||
|
XMLName ixml.Name `xml:"lockinfo"` |
||||
|
Exclusive *struct{} `xml:"lockscope>exclusive"` |
||||
|
Shared *struct{} `xml:"lockscope>shared"` |
||||
|
Write *struct{} `xml:"locktype>write"` |
||||
|
Owner owner `xml:"owner"` |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_owner
|
||||
|
type owner struct { |
||||
|
InnerXML string `xml:",innerxml"` |
||||
|
} |
||||
|
|
||||
|
func readLockInfo(r io.Reader) (li lockInfo, status int, err error) { |
||||
|
c := &countingReader{r: r} |
||||
|
if err = ixml.NewDecoder(c).Decode(&li); err != nil { |
||||
|
if err == io.EOF { |
||||
|
if c.n == 0 { |
||||
|
// An empty body means to refresh the lock.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#refreshing-locks
|
||||
|
return lockInfo{}, 0, nil |
||||
|
} |
||||
|
err = errInvalidLockInfo |
||||
|
} |
||||
|
return lockInfo{}, http.StatusBadRequest, err |
||||
|
} |
||||
|
// We only support exclusive (non-shared) write locks. In practice, these are
|
||||
|
// the only types of locks that seem to matter.
|
||||
|
if li.Exclusive == nil || li.Shared != nil || li.Write == nil { |
||||
|
return lockInfo{}, http.StatusNotImplemented, errUnsupportedLockInfo |
||||
|
} |
||||
|
return li, 0, nil |
||||
|
} |
||||
|
|
||||
|
type countingReader struct { |
||||
|
n int |
||||
|
r io.Reader |
||||
|
} |
||||
|
|
||||
|
func (c *countingReader) Read(p []byte) (int, error) { |
||||
|
n, err := c.r.Read(p) |
||||
|
c.n += n |
||||
|
return n, err |
||||
|
} |
||||
|
|
||||
|
func writeLockInfo(w io.Writer, token string, ld LockDetails) (int, error) { |
||||
|
depth := "infinity" |
||||
|
if ld.ZeroDepth { |
||||
|
depth = "0" |
||||
|
} |
||||
|
timeout := ld.Duration / time.Second |
||||
|
return fmt.Fprintf(w, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+ |
||||
|
"<D:prop xmlns:D=\"DAV:\"><D:lockdiscovery><D:activelock>\n"+ |
||||
|
" <D:locktype><D:write/></D:locktype>\n"+ |
||||
|
" <D:lockscope><D:exclusive/></D:lockscope>\n"+ |
||||
|
" <D:depth>%s</D:depth>\n"+ |
||||
|
" <D:owner>%s</D:owner>\n"+ |
||||
|
" <D:timeout>Second-%d</D:timeout>\n"+ |
||||
|
" <D:locktoken><D:href>%s</D:href></D:locktoken>\n"+ |
||||
|
" <D:lockroot><D:href>%s</D:href></D:lockroot>\n"+ |
||||
|
"</D:activelock></D:lockdiscovery></D:prop>", |
||||
|
depth, ld.OwnerXML, timeout, escape(token), escape(ld.Root), |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
func escape(s string) string { |
||||
|
for i := 0; i < len(s); i++ { |
||||
|
switch s[i] { |
||||
|
case '"', '&', '\'', '<', '>': |
||||
|
b := bytes.NewBuffer(nil) |
||||
|
ixml.EscapeText(b, []byte(s)) |
||||
|
return b.String() |
||||
|
} |
||||
|
} |
||||
|
return s |
||||
|
} |
||||
|
|
||||
|
// Next returns the next token, if any, in the XML stream of d.
|
||||
|
// RFC 4918 requires to ignore comments, processing instructions
|
||||
|
// and directives.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#property_values
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#xml-extensibility
|
||||
|
func next(d *ixml.Decoder) (ixml.Token, error) { |
||||
|
for { |
||||
|
t, err := d.Token() |
||||
|
if err != nil { |
||||
|
return t, err |
||||
|
} |
||||
|
switch t.(type) { |
||||
|
case ixml.Comment, ixml.Directive, ixml.ProcInst: |
||||
|
continue |
||||
|
default: |
||||
|
return t, nil |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind)
|
||||
|
type propfindProps []xml.Name |
||||
|
|
||||
|
// UnmarshalXML appends the property names enclosed within start to pn.
|
||||
|
//
|
||||
|
// It returns an error if start does not contain any properties or if
|
||||
|
// properties contain values. Character data between properties is ignored.
|
||||
|
func (pn *propfindProps) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error { |
||||
|
for { |
||||
|
t, err := next(d) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
switch t.(type) { |
||||
|
case ixml.EndElement: |
||||
|
if len(*pn) == 0 { |
||||
|
return fmt.Errorf("%s must not be empty", start.Name.Local) |
||||
|
} |
||||
|
return nil |
||||
|
case ixml.StartElement: |
||||
|
name := t.(ixml.StartElement).Name |
||||
|
t, err = next(d) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
if _, ok := t.(ixml.EndElement); !ok { |
||||
|
return fmt.Errorf("unexpected token %T", t) |
||||
|
} |
||||
|
*pn = append(*pn, xml.Name(name)) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propfind
|
||||
|
type propfind struct { |
||||
|
XMLName ixml.Name `xml:"DAV: propfind"` |
||||
|
Allprop *struct{} `xml:"DAV: allprop"` |
||||
|
Propname *struct{} `xml:"DAV: propname"` |
||||
|
Prop propfindProps `xml:"DAV: prop"` |
||||
|
Include propfindProps `xml:"DAV: include"` |
||||
|
} |
||||
|
|
||||
|
func readPropfind(r io.Reader) (pf propfind, status int, err error) { |
||||
|
c := countingReader{r: r} |
||||
|
if err = ixml.NewDecoder(&c).Decode(&pf); err != nil { |
||||
|
if err == io.EOF { |
||||
|
if c.n == 0 { |
||||
|
// An empty body means to propfind allprop.
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
|
||||
|
return propfind{Allprop: new(struct{})}, 0, nil |
||||
|
} |
||||
|
err = errInvalidPropfind |
||||
|
} |
||||
|
return propfind{}, http.StatusBadRequest, err |
||||
|
} |
||||
|
|
||||
|
if pf.Allprop == nil && pf.Include != nil { |
||||
|
return propfind{}, http.StatusBadRequest, errInvalidPropfind |
||||
|
} |
||||
|
if pf.Allprop != nil && (pf.Prop != nil || pf.Propname != nil) { |
||||
|
return propfind{}, http.StatusBadRequest, errInvalidPropfind |
||||
|
} |
||||
|
if pf.Prop != nil && pf.Propname != nil { |
||||
|
return propfind{}, http.StatusBadRequest, errInvalidPropfind |
||||
|
} |
||||
|
if pf.Propname == nil && pf.Allprop == nil && pf.Prop == nil { |
||||
|
return propfind{}, http.StatusBadRequest, errInvalidPropfind |
||||
|
} |
||||
|
return pf, 0, nil |
||||
|
} |
||||
|
|
||||
|
// Property represents a single DAV resource property as defined in RFC 4918.
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#data.model.for.resource.properties
|
||||
|
type Property struct { |
||||
|
// XMLName is the fully qualified name that identifies this property.
|
||||
|
XMLName xml.Name |
||||
|
|
||||
|
// Lang is an optional xml:lang attribute.
|
||||
|
Lang string `xml:"xml:lang,attr,omitempty"` |
||||
|
|
||||
|
// InnerXML contains the XML representation of the property value.
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#property_values
|
||||
|
//
|
||||
|
// Property values of complex type or mixed-content must have fully
|
||||
|
// expanded XML namespaces or be self-contained with according
|
||||
|
// XML namespace declarations. They must not rely on any XML
|
||||
|
// namespace declarations within the scope of the XML document,
|
||||
|
// even including the DAV: namespace.
|
||||
|
InnerXML []byte `xml:",innerxml"` |
||||
|
} |
||||
|
|
||||
|
// ixmlProperty is the same as the Property type except it holds an ixml.Name
|
||||
|
// instead of an xml.Name.
|
||||
|
type ixmlProperty struct { |
||||
|
XMLName ixml.Name |
||||
|
Lang string `xml:"xml:lang,attr,omitempty"` |
||||
|
InnerXML []byte `xml:",innerxml"` |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_error
|
||||
|
// See multistatusWriter for the "D:" namespace prefix.
|
||||
|
type xmlError struct { |
||||
|
XMLName ixml.Name `xml:"D:error"` |
||||
|
InnerXML []byte `xml:",innerxml"` |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
|
||||
|
// See multistatusWriter for the "D:" namespace prefix.
|
||||
|
type propstat struct { |
||||
|
Prop []Property `xml:"D:prop>_ignored_"` |
||||
|
Status string `xml:"D:status"` |
||||
|
Error *xmlError `xml:"D:error"` |
||||
|
ResponseDescription string `xml:"D:responsedescription,omitempty"` |
||||
|
} |
||||
|
|
||||
|
// ixmlPropstat is the same as the propstat type except it holds an ixml.Name
|
||||
|
// instead of an xml.Name.
|
||||
|
type ixmlPropstat struct { |
||||
|
Prop []ixmlProperty `xml:"D:prop>_ignored_"` |
||||
|
Status string `xml:"D:status"` |
||||
|
Error *xmlError `xml:"D:error"` |
||||
|
ResponseDescription string `xml:"D:responsedescription,omitempty"` |
||||
|
} |
||||
|
|
||||
|
// MarshalXML prepends the "D:" namespace prefix on properties in the DAV: namespace
|
||||
|
// before encoding. See multistatusWriter.
|
||||
|
func (ps propstat) MarshalXML(e *ixml.Encoder, start ixml.StartElement) error { |
||||
|
// Convert from a propstat to an ixmlPropstat.
|
||||
|
ixmlPs := ixmlPropstat{ |
||||
|
Prop: make([]ixmlProperty, len(ps.Prop)), |
||||
|
Status: ps.Status, |
||||
|
Error: ps.Error, |
||||
|
ResponseDescription: ps.ResponseDescription, |
||||
|
} |
||||
|
for k, prop := range ps.Prop { |
||||
|
ixmlPs.Prop[k] = ixmlProperty{ |
||||
|
XMLName: ixml.Name(prop.XMLName), |
||||
|
Lang: prop.Lang, |
||||
|
InnerXML: prop.InnerXML, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for k, prop := range ixmlPs.Prop { |
||||
|
if prop.XMLName.Space == "DAV:" { |
||||
|
prop.XMLName = ixml.Name{Space: "", Local: "D:" + prop.XMLName.Local} |
||||
|
ixmlPs.Prop[k] = prop |
||||
|
} |
||||
|
} |
||||
|
// Distinct type to avoid infinite recursion of MarshalXML.
|
||||
|
type newpropstat ixmlPropstat |
||||
|
return e.EncodeElement(newpropstat(ixmlPs), start) |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
|
||||
|
// See multistatusWriter for the "D:" namespace prefix.
|
||||
|
type response struct { |
||||
|
XMLName ixml.Name `xml:"D:response"` |
||||
|
Href []string `xml:"D:href"` |
||||
|
Propstat []propstat `xml:"D:propstat"` |
||||
|
Status string `xml:"D:status,omitempty"` |
||||
|
Error *xmlError `xml:"D:error"` |
||||
|
ResponseDescription string `xml:"D:responsedescription,omitempty"` |
||||
|
} |
||||
|
|
||||
|
// MultistatusWriter marshals one or more Responses into a XML
|
||||
|
// multistatus response.
|
||||
|
// See http://www.webdav.org/specs/rfc4918.html#ELEMENT_multistatus
|
||||
|
// TODO(rsto, mpl): As a workaround, the "D:" namespace prefix, defined as
|
||||
|
// "DAV:" on this element, is prepended on the nested response, as well as on all
|
||||
|
// its nested elements. All property names in the DAV: namespace are prefixed as
|
||||
|
// well. This is because some versions of Mini-Redirector (on windows 7) ignore
|
||||
|
// elements with a default namespace (no prefixed namespace). A less intrusive fix
|
||||
|
// should be possible after golang.org/cl/11074. See https://golang.org/issue/11177
|
||||
|
type multistatusWriter struct { |
||||
|
// ResponseDescription contains the optional responsedescription
|
||||
|
// of the multistatus XML element. Only the latest content before
|
||||
|
// close will be emitted. Empty response descriptions are not
|
||||
|
// written.
|
||||
|
responseDescription string |
||||
|
|
||||
|
w http.ResponseWriter |
||||
|
enc *ixml.Encoder |
||||
|
} |
||||
|
|
||||
|
// Write validates and emits a DAV response as part of a multistatus response
|
||||
|
// element.
|
||||
|
//
|
||||
|
// It sets the HTTP status code of its underlying http.ResponseWriter to 207
|
||||
|
// (Multi-Status) and populates the Content-Type header. If r is the
|
||||
|
// first, valid response to be written, Write prepends the XML representation
|
||||
|
// of r with a multistatus tag. Callers must call close after the last response
|
||||
|
// has been written.
|
||||
|
func (w *multistatusWriter) write(r *response) error { |
||||
|
switch len(r.Href) { |
||||
|
case 0: |
||||
|
return errInvalidResponse |
||||
|
case 1: |
||||
|
if len(r.Propstat) > 0 != (r.Status == "") { |
||||
|
return errInvalidResponse |
||||
|
} |
||||
|
default: |
||||
|
if len(r.Propstat) > 0 || r.Status == "" { |
||||
|
return errInvalidResponse |
||||
|
} |
||||
|
} |
||||
|
err := w.writeHeader() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
return w.enc.Encode(r) |
||||
|
} |
||||
|
|
||||
|
// writeHeader writes a XML multistatus start element on w's underlying
|
||||
|
// http.ResponseWriter and returns the result of the write operation.
|
||||
|
// After the first write attempt, writeHeader becomes a no-op.
|
||||
|
func (w *multistatusWriter) writeHeader() error { |
||||
|
if w.enc != nil { |
||||
|
return nil |
||||
|
} |
||||
|
w.w.Header().Add("Content-Type", "text/xml; charset=utf-8") |
||||
|
w.w.WriteHeader(StatusMulti) |
||||
|
_, err := fmt.Fprintf(w.w, `<?xml version="1.0" encoding="UTF-8"?>`) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
w.enc = ixml.NewEncoder(w.w) |
||||
|
return w.enc.EncodeToken(ixml.StartElement{ |
||||
|
Name: ixml.Name{ |
||||
|
Space: "DAV:", |
||||
|
Local: "multistatus", |
||||
|
}, |
||||
|
Attr: []ixml.Attr{{ |
||||
|
Name: ixml.Name{Space: "xmlns", Local: "D"}, |
||||
|
Value: "DAV:", |
||||
|
}}, |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
// Close completes the marshalling of the multistatus response. It returns
|
||||
|
// an error if the multistatus response could not be completed. If both the
|
||||
|
// return value and field enc of w are nil, then no multistatus response has
|
||||
|
// been written.
|
||||
|
func (w *multistatusWriter) close() error { |
||||
|
if w.enc == nil { |
||||
|
return nil |
||||
|
} |
||||
|
var end []ixml.Token |
||||
|
if w.responseDescription != "" { |
||||
|
name := ixml.Name{Space: "DAV:", Local: "responsedescription"} |
||||
|
end = append(end, |
||||
|
ixml.StartElement{Name: name}, |
||||
|
ixml.CharData(w.responseDescription), |
||||
|
ixml.EndElement{Name: name}, |
||||
|
) |
||||
|
} |
||||
|
end = append(end, ixml.EndElement{ |
||||
|
Name: ixml.Name{Space: "DAV:", Local: "multistatus"}, |
||||
|
}) |
||||
|
for _, t := range end { |
||||
|
err := w.enc.EncodeToken(t) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
return w.enc.Flush() |
||||
|
} |
||||
|
|
||||
|
var xmlLangName = ixml.Name{Space: "http://www.w3.org/XML/1998/namespace", Local: "lang"} |
||||
|
|
||||
|
func xmlLang(s ixml.StartElement, d string) string { |
||||
|
for _, attr := range s.Attr { |
||||
|
if attr.Name == xmlLangName { |
||||
|
return attr.Value |
||||
|
} |
||||
|
} |
||||
|
return d |
||||
|
} |
||||
|
|
||||
|
type xmlValue []byte |
||||
|
|
||||
|
func (v *xmlValue) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error { |
||||
|
// The XML value of a property can be arbitrary, mixed-content XML.
|
||||
|
// To make sure that the unmarshalled value contains all required
|
||||
|
// namespaces, we encode all the property value XML tokens into a
|
||||
|
// buffer. This forces the encoder to redeclare any used namespaces.
|
||||
|
var b bytes.Buffer |
||||
|
e := ixml.NewEncoder(&b) |
||||
|
for { |
||||
|
t, err := next(d) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
if e, ok := t.(ixml.EndElement); ok && e.Name == start.Name { |
||||
|
break |
||||
|
} |
||||
|
if err = e.EncodeToken(t); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
} |
||||
|
err := e.Flush() |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
*v = b.Bytes() |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for proppatch)
|
||||
|
type proppatchProps []Property |
||||
|
|
||||
|
// UnmarshalXML appends the property names and values enclosed within start
|
||||
|
// to ps.
|
||||
|
//
|
||||
|
// An xml:lang attribute that is defined either on the DAV:prop or property
|
||||
|
// name XML element is propagated to the property's Lang field.
|
||||
|
//
|
||||
|
// UnmarshalXML returns an error if start does not contain any properties or if
|
||||
|
// property values contain syntactically incorrect XML.
|
||||
|
func (ps *proppatchProps) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error { |
||||
|
lang := xmlLang(start, "") |
||||
|
for { |
||||
|
t, err := next(d) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
switch elem := t.(type) { |
||||
|
case ixml.EndElement: |
||||
|
if len(*ps) == 0 { |
||||
|
return fmt.Errorf("%s must not be empty", start.Name.Local) |
||||
|
} |
||||
|
return nil |
||||
|
case ixml.StartElement: |
||||
|
p := Property{ |
||||
|
XMLName: xml.Name(t.(ixml.StartElement).Name), |
||||
|
Lang: xmlLang(t.(ixml.StartElement), lang), |
||||
|
} |
||||
|
err = d.DecodeElement(((*xmlValue)(&p.InnerXML)), &elem) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
*ps = append(*ps, p) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_set
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_remove
|
||||
|
type setRemove struct { |
||||
|
XMLName ixml.Name |
||||
|
Lang string `xml:"xml:lang,attr,omitempty"` |
||||
|
Prop proppatchProps `xml:"DAV: prop"` |
||||
|
} |
||||
|
|
||||
|
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propertyupdate
|
||||
|
type propertyupdate struct { |
||||
|
XMLName ixml.Name `xml:"DAV: propertyupdate"` |
||||
|
Lang string `xml:"xml:lang,attr,omitempty"` |
||||
|
SetRemove []setRemove `xml:",any"` |
||||
|
} |
||||
|
|
||||
|
func readProppatch(r io.Reader) (patches []Proppatch, status int, err error) { |
||||
|
var pu propertyupdate |
||||
|
if err = ixml.NewDecoder(r).Decode(&pu); err != nil { |
||||
|
return nil, http.StatusBadRequest, err |
||||
|
} |
||||
|
for _, op := range pu.SetRemove { |
||||
|
remove := false |
||||
|
switch op.XMLName { |
||||
|
case ixml.Name{Space: "DAV:", Local: "set"}: |
||||
|
// No-op.
|
||||
|
case ixml.Name{Space: "DAV:", Local: "remove"}: |
||||
|
for _, p := range op.Prop { |
||||
|
if len(p.InnerXML) > 0 { |
||||
|
return nil, http.StatusBadRequest, errInvalidProppatch |
||||
|
} |
||||
|
} |
||||
|
remove = true |
||||
|
default: |
||||
|
return nil, http.StatusBadRequest, errInvalidProppatch |
||||
|
} |
||||
|
patches = append(patches, Proppatch{Remove: remove, Props: op.Prop}) |
||||
|
} |
||||
|
return patches, 0, nil |
||||
|
} |
||||
@ -0,0 +1,100 @@ |
|||||
|
package rest |
||||
|
|
||||
|
import ( |
||||
|
"golang.org/x/net/webdav" |
||||
|
"net/http" |
||||
|
"regexp" |
||||
|
) |
||||
|
|
||||
|
/** |
||||
|
* |
||||
|
* WebDav协议文档 |
||||
|
* https://tools.ietf.org/html/rfc4918
|
||||
|
* |
||||
|
*/ |
||||
|
type WebdavController struct { |
||||
|
BaseController |
||||
|
uploadTokenDao *UploadTokenDao |
||||
|
downloadTokenDao *DownloadTokenDao |
||||
|
matterDao *MatterDao |
||||
|
matterService *MatterService |
||||
|
imageCacheDao *ImageCacheDao |
||||
|
imageCacheService *ImageCacheService |
||||
|
} |
||||
|
|
||||
|
//初始化方法
|
||||
|
func (this *WebdavController) Init() { |
||||
|
this.BaseController.Init() |
||||
|
|
||||
|
//手动装填本实例的Bean.
|
||||
|
b := CONTEXT.GetBean(this.uploadTokenDao) |
||||
|
if c, ok := b.(*UploadTokenDao); ok { |
||||
|
this.uploadTokenDao = c |
||||
|
} |
||||
|
|
||||
|
b = CONTEXT.GetBean(this.downloadTokenDao) |
||||
|
if c, ok := b.(*DownloadTokenDao); ok { |
||||
|
this.downloadTokenDao = c |
||||
|
} |
||||
|
|
||||
|
b = CONTEXT.GetBean(this.matterDao) |
||||
|
if c, ok := b.(*MatterDao); ok { |
||||
|
this.matterDao = c |
||||
|
} |
||||
|
|
||||
|
b = CONTEXT.GetBean(this.matterService) |
||||
|
if c, ok := b.(*MatterService); ok { |
||||
|
this.matterService = c |
||||
|
} |
||||
|
|
||||
|
b = CONTEXT.GetBean(this.imageCacheDao) |
||||
|
if c, ok := b.(*ImageCacheDao); ok { |
||||
|
this.imageCacheDao = c |
||||
|
} |
||||
|
|
||||
|
b = CONTEXT.GetBean(this.imageCacheService) |
||||
|
if c, ok := b.(*ImageCacheService); ok { |
||||
|
this.imageCacheService = c |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
//注册自己的路由。
|
||||
|
func (this *WebdavController) RegisterRoutes() map[string]func(writer http.ResponseWriter, request *http.Request) { |
||||
|
|
||||
|
routeMap := make(map[string]func(writer http.ResponseWriter, request *http.Request)) |
||||
|
|
||||
|
return routeMap |
||||
|
} |
||||
|
|
||||
|
//处理一些特殊的接口，比如参数包含在路径中,一般情况下，controller不将参数放在url路径中
|
||||
|
func (this *WebdavController) HandleRoutes(writer http.ResponseWriter, request *http.Request) (func(writer http.ResponseWriter, request *http.Request), bool) { |
||||
|
|
||||
|
path := request.URL.Path |
||||
|
|
||||
|
//匹配 /api/webdav{subPath}
|
||||
|
reg := regexp.MustCompile(`^/api/webdav(.*)$`) |
||||
|
strs := reg.FindStringSubmatch(path) |
||||
|
if len(strs) == 2 { |
||||
|
var f = func(writer http.ResponseWriter, request *http.Request) { |
||||
|
this.Index(writer, request, strs[1]) |
||||
|
} |
||||
|
return f, true |
||||
|
} |
||||
|
|
||||
|
return nil, false |
||||
|
} |
||||
|
|
||||
|
//完成系统安装
|
||||
|
func (this *WebdavController) Index(writer http.ResponseWriter, request *http.Request, subPath string) { |
||||
|
|
||||
|
this.logger.Info("请求访问来了：%s %s", request.RequestURI, subPath) |
||||
|
|
||||
|
handler := &webdav.Handler{ |
||||
|
FileSystem: webdav.Dir("/Users/fusu/d/group/golang/src/tank/tmp/webdav"), |
||||
|
LockSystem: webdav.NewMemLS(), |
||||
|
} |
||||
|
|
||||
|
|
||||
|
handler.ServeHTTP(writer, request) |
||||
|
|
||||
|
} |
||||
Loading…
Reference in new issue