mirror of
https://github.com/1f349/go-webdav.git
synced 2024-12-22 16:24:14 +00:00
Imported from golang.org/x/net/webdav, removed encoding/xml fork
This commit is contained in:
parent
d0fe0f28b6
commit
c79a50adf2
43
LICENSE
43
LICENSE
@ -1,29 +1,28 @@
|
||||
BSD 3-Clause License
|
||||
|
||||
Copyright (c) 2017, emersion
|
||||
All rights reserved.
|
||||
Copyright (c) 2009 The Go Authors. All rights reserved.
|
||||
Copyright (c) 2017 emersion
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the copyright holder nor the names of its
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Google Inc. nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
@ -1,2 +1,7 @@
|
||||
# go-webdav
|
||||
A Go library for WebDAV
|
||||
|
||||
A Go library for WebDAV.
|
||||
|
||||
## License
|
||||
|
||||
BSD
|
||||
|
796
file.go
Normal file
796
file.go
Normal file
@ -0,0 +1,796 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// slashClean is equivalent to but slightly more efficient than
|
||||
// path.Clean("/" + name).
|
||||
func slashClean(name string) string {
|
||||
if name == "" || name[0] != '/' {
|
||||
name = "/" + name
|
||||
}
|
||||
return path.Clean(name)
|
||||
}
|
||||
|
||||
// A FileSystem implements access to a collection of named files. The elements
|
||||
// in a file path are separated by slash ('/', U+002F) characters, regardless
|
||||
// of host operating system convention.
|
||||
//
|
||||
// Each method has the same semantics as the os package's function of the same
|
||||
// name.
|
||||
//
|
||||
// Note that the os.Rename documentation says that "OS-specific restrictions
|
||||
// might apply". In particular, whether or not renaming a file or directory
|
||||
// overwriting another existing file or directory is an error is OS-dependent.
|
||||
type FileSystem interface {
|
||||
Mkdir(ctx context.Context, name string, perm os.FileMode) error
|
||||
OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error)
|
||||
RemoveAll(ctx context.Context, name string) error
|
||||
Rename(ctx context.Context, oldName, newName string) error
|
||||
Stat(ctx context.Context, name string) (os.FileInfo, error)
|
||||
}
|
||||
|
||||
// A File is returned by a FileSystem's OpenFile method and can be served by a
|
||||
// Handler.
|
||||
//
|
||||
// A File may optionally implement the DeadPropsHolder interface, if it can
|
||||
// load and save dead properties.
|
||||
type File interface {
|
||||
http.File
|
||||
io.Writer
|
||||
}
|
||||
|
||||
// A Dir implements FileSystem using the native file system restricted to a
|
||||
// specific directory tree.
|
||||
//
|
||||
// While the FileSystem.OpenFile method takes '/'-separated paths, a Dir's
|
||||
// string value is a filename on the native file system, not a URL, so it is
|
||||
// separated by filepath.Separator, which isn't necessarily '/'.
|
||||
//
|
||||
// An empty Dir is treated as ".".
|
||||
type Dir string
|
||||
|
||||
func (d Dir) resolve(name string) string {
|
||||
// This implementation is based on Dir.Open's code in the standard net/http package.
|
||||
if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 ||
|
||||
strings.Contains(name, "\x00") {
|
||||
return ""
|
||||
}
|
||||
dir := string(d)
|
||||
if dir == "" {
|
||||
dir = "."
|
||||
}
|
||||
return filepath.Join(dir, filepath.FromSlash(slashClean(name)))
|
||||
}
|
||||
|
||||
func (d Dir) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
|
||||
if name = d.resolve(name); name == "" {
|
||||
return os.ErrNotExist
|
||||
}
|
||||
return os.Mkdir(name, perm)
|
||||
}
|
||||
|
||||
func (d Dir) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
|
||||
if name = d.resolve(name); name == "" {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
f, err := os.OpenFile(name, flag, perm)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return f, nil
|
||||
}
|
||||
|
||||
func (d Dir) RemoveAll(ctx context.Context, name string) error {
|
||||
if name = d.resolve(name); name == "" {
|
||||
return os.ErrNotExist
|
||||
}
|
||||
if name == filepath.Clean(string(d)) {
|
||||
// Prohibit removing the virtual root directory.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
return os.RemoveAll(name)
|
||||
}
|
||||
|
||||
func (d Dir) Rename(ctx context.Context, oldName, newName string) error {
|
||||
if oldName = d.resolve(oldName); oldName == "" {
|
||||
return os.ErrNotExist
|
||||
}
|
||||
if newName = d.resolve(newName); newName == "" {
|
||||
return os.ErrNotExist
|
||||
}
|
||||
if root := filepath.Clean(string(d)); root == oldName || root == newName {
|
||||
// Prohibit renaming from or to the virtual root directory.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
return os.Rename(oldName, newName)
|
||||
}
|
||||
|
||||
func (d Dir) Stat(ctx context.Context, name string) (os.FileInfo, error) {
|
||||
if name = d.resolve(name); name == "" {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
return os.Stat(name)
|
||||
}
|
||||
|
||||
// NewMemFS returns a new in-memory FileSystem implementation.
|
||||
func NewMemFS() FileSystem {
|
||||
return &memFS{
|
||||
root: memFSNode{
|
||||
children: make(map[string]*memFSNode),
|
||||
mode: 0660 | os.ModeDir,
|
||||
modTime: time.Now(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// A memFS implements FileSystem, storing all metadata and actual file data
|
||||
// in-memory. No limits on filesystem size are used, so it is not recommended
|
||||
// this be used where the clients are untrusted.
|
||||
//
|
||||
// Concurrent access is permitted. The tree structure is protected by a mutex,
|
||||
// and each node's contents and metadata are protected by a per-node mutex.
|
||||
//
|
||||
// TODO: Enforce file permissions.
|
||||
type memFS struct {
|
||||
mu sync.Mutex
|
||||
root memFSNode
|
||||
}
|
||||
|
||||
// TODO: clean up and rationalize the walk/find code.
|
||||
|
||||
// walk walks the directory tree for the fullname, calling f at each step. If f
|
||||
// returns an error, the walk will be aborted and return that same error.
|
||||
//
|
||||
// dir is the directory at that step, frag is the name fragment, and final is
|
||||
// whether it is the final step. For example, walking "/foo/bar/x" will result
|
||||
// in 3 calls to f:
|
||||
// - "/", "foo", false
|
||||
// - "/foo/", "bar", false
|
||||
// - "/foo/bar/", "x", true
|
||||
// The frag argument will be empty only if dir is the root node and the walk
|
||||
// ends at that root node.
|
||||
func (fs *memFS) walk(op, fullname string, f func(dir *memFSNode, frag string, final bool) error) error {
|
||||
original := fullname
|
||||
fullname = slashClean(fullname)
|
||||
|
||||
// Strip any leading "/"s to make fullname a relative path, as the walk
|
||||
// starts at fs.root.
|
||||
if fullname[0] == '/' {
|
||||
fullname = fullname[1:]
|
||||
}
|
||||
dir := &fs.root
|
||||
|
||||
for {
|
||||
frag, remaining := fullname, ""
|
||||
i := strings.IndexRune(fullname, '/')
|
||||
final := i < 0
|
||||
if !final {
|
||||
frag, remaining = fullname[:i], fullname[i+1:]
|
||||
}
|
||||
if frag == "" && dir != &fs.root {
|
||||
panic("webdav: empty path fragment for a clean path")
|
||||
}
|
||||
if err := f(dir, frag, final); err != nil {
|
||||
return &os.PathError{
|
||||
Op: op,
|
||||
Path: original,
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
if final {
|
||||
break
|
||||
}
|
||||
child := dir.children[frag]
|
||||
if child == nil {
|
||||
return &os.PathError{
|
||||
Op: op,
|
||||
Path: original,
|
||||
Err: os.ErrNotExist,
|
||||
}
|
||||
}
|
||||
if !child.mode.IsDir() {
|
||||
return &os.PathError{
|
||||
Op: op,
|
||||
Path: original,
|
||||
Err: os.ErrInvalid,
|
||||
}
|
||||
}
|
||||
dir, fullname = child, remaining
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// find returns the parent of the named node and the relative name fragment
|
||||
// from the parent to the child. For example, if finding "/foo/bar/baz" then
|
||||
// parent will be the node for "/foo/bar" and frag will be "baz".
|
||||
//
|
||||
// If the fullname names the root node, then parent, frag and err will be zero.
|
||||
//
|
||||
// find returns an error if the parent does not already exist or the parent
|
||||
// isn't a directory, but it will not return an error per se if the child does
|
||||
// not already exist. The error returned is either nil or an *os.PathError
|
||||
// whose Op is op.
|
||||
func (fs *memFS) find(op, fullname string) (parent *memFSNode, frag string, err error) {
|
||||
err = fs.walk(op, fullname, func(parent0 *memFSNode, frag0 string, final bool) error {
|
||||
if !final {
|
||||
return nil
|
||||
}
|
||||
if frag0 != "" {
|
||||
parent, frag = parent0, frag0
|
||||
}
|
||||
return nil
|
||||
})
|
||||
return parent, frag, err
|
||||
}
|
||||
|
||||
func (fs *memFS) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
|
||||
fs.mu.Lock()
|
||||
defer fs.mu.Unlock()
|
||||
|
||||
dir, frag, err := fs.find("mkdir", name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if dir == nil {
|
||||
// We can't create the root.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
if _, ok := dir.children[frag]; ok {
|
||||
return os.ErrExist
|
||||
}
|
||||
dir.children[frag] = &memFSNode{
|
||||
children: make(map[string]*memFSNode),
|
||||
mode: perm.Perm() | os.ModeDir,
|
||||
modTime: time.Now(),
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (fs *memFS) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
|
||||
fs.mu.Lock()
|
||||
defer fs.mu.Unlock()
|
||||
|
||||
dir, frag, err := fs.find("open", name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var n *memFSNode
|
||||
if dir == nil {
|
||||
// We're opening the root.
|
||||
if flag&(os.O_WRONLY|os.O_RDWR) != 0 {
|
||||
return nil, os.ErrPermission
|
||||
}
|
||||
n, frag = &fs.root, "/"
|
||||
|
||||
} else {
|
||||
n = dir.children[frag]
|
||||
if flag&(os.O_SYNC|os.O_APPEND) != 0 {
|
||||
// memFile doesn't support these flags yet.
|
||||
return nil, os.ErrInvalid
|
||||
}
|
||||
if flag&os.O_CREATE != 0 {
|
||||
if flag&os.O_EXCL != 0 && n != nil {
|
||||
return nil, os.ErrExist
|
||||
}
|
||||
if n == nil {
|
||||
n = &memFSNode{
|
||||
mode: perm.Perm(),
|
||||
}
|
||||
dir.children[frag] = n
|
||||
}
|
||||
}
|
||||
if n == nil {
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
if flag&(os.O_WRONLY|os.O_RDWR) != 0 && flag&os.O_TRUNC != 0 {
|
||||
n.mu.Lock()
|
||||
n.data = nil
|
||||
n.mu.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
children := make([]os.FileInfo, 0, len(n.children))
|
||||
for cName, c := range n.children {
|
||||
children = append(children, c.stat(cName))
|
||||
}
|
||||
return &memFile{
|
||||
n: n,
|
||||
nameSnapshot: frag,
|
||||
childrenSnapshot: children,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (fs *memFS) RemoveAll(ctx context.Context, name string) error {
|
||||
fs.mu.Lock()
|
||||
defer fs.mu.Unlock()
|
||||
|
||||
dir, frag, err := fs.find("remove", name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if dir == nil {
|
||||
// We can't remove the root.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
delete(dir.children, frag)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (fs *memFS) Rename(ctx context.Context, oldName, newName string) error {
|
||||
fs.mu.Lock()
|
||||
defer fs.mu.Unlock()
|
||||
|
||||
oldName = slashClean(oldName)
|
||||
newName = slashClean(newName)
|
||||
if oldName == newName {
|
||||
return nil
|
||||
}
|
||||
if strings.HasPrefix(newName, oldName+"/") {
|
||||
// We can't rename oldName to be a sub-directory of itself.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
|
||||
oDir, oFrag, err := fs.find("rename", oldName)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if oDir == nil {
|
||||
// We can't rename from the root.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
|
||||
nDir, nFrag, err := fs.find("rename", newName)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if nDir == nil {
|
||||
// We can't rename to the root.
|
||||
return os.ErrInvalid
|
||||
}
|
||||
|
||||
oNode, ok := oDir.children[oFrag]
|
||||
if !ok {
|
||||
return os.ErrNotExist
|
||||
}
|
||||
if oNode.children != nil {
|
||||
if nNode, ok := nDir.children[nFrag]; ok {
|
||||
if nNode.children == nil {
|
||||
return errNotADirectory
|
||||
}
|
||||
if len(nNode.children) != 0 {
|
||||
return errDirectoryNotEmpty
|
||||
}
|
||||
}
|
||||
}
|
||||
delete(oDir.children, oFrag)
|
||||
nDir.children[nFrag] = oNode
|
||||
return nil
|
||||
}
|
||||
|
||||
func (fs *memFS) Stat(ctx context.Context, name string) (os.FileInfo, error) {
|
||||
fs.mu.Lock()
|
||||
defer fs.mu.Unlock()
|
||||
|
||||
dir, frag, err := fs.find("stat", name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if dir == nil {
|
||||
// We're stat'ting the root.
|
||||
return fs.root.stat("/"), nil
|
||||
}
|
||||
if n, ok := dir.children[frag]; ok {
|
||||
return n.stat(path.Base(name)), nil
|
||||
}
|
||||
return nil, os.ErrNotExist
|
||||
}
|
||||
|
||||
// A memFSNode represents a single entry in the in-memory filesystem and also
|
||||
// implements os.FileInfo.
|
||||
type memFSNode struct {
|
||||
// children is protected by memFS.mu.
|
||||
children map[string]*memFSNode
|
||||
|
||||
mu sync.Mutex
|
||||
data []byte
|
||||
mode os.FileMode
|
||||
modTime time.Time
|
||||
deadProps map[xml.Name]Property
|
||||
}
|
||||
|
||||
func (n *memFSNode) stat(name string) *memFileInfo {
|
||||
n.mu.Lock()
|
||||
defer n.mu.Unlock()
|
||||
return &memFileInfo{
|
||||
name: name,
|
||||
size: int64(len(n.data)),
|
||||
mode: n.mode,
|
||||
modTime: n.modTime,
|
||||
}
|
||||
}
|
||||
|
||||
func (n *memFSNode) DeadProps() (map[xml.Name]Property, error) {
|
||||
n.mu.Lock()
|
||||
defer n.mu.Unlock()
|
||||
if len(n.deadProps) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
ret := make(map[xml.Name]Property, len(n.deadProps))
|
||||
for k, v := range n.deadProps {
|
||||
ret[k] = v
|
||||
}
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (n *memFSNode) Patch(patches []Proppatch) ([]Propstat, error) {
|
||||
n.mu.Lock()
|
||||
defer n.mu.Unlock()
|
||||
pstat := Propstat{Status: http.StatusOK}
|
||||
for _, patch := range patches {
|
||||
for _, p := range patch.Props {
|
||||
pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName})
|
||||
if patch.Remove {
|
||||
delete(n.deadProps, p.XMLName)
|
||||
continue
|
||||
}
|
||||
if n.deadProps == nil {
|
||||
n.deadProps = map[xml.Name]Property{}
|
||||
}
|
||||
n.deadProps[p.XMLName] = p
|
||||
}
|
||||
}
|
||||
return []Propstat{pstat}, nil
|
||||
}
|
||||
|
||||
type memFileInfo struct {
|
||||
name string
|
||||
size int64
|
||||
mode os.FileMode
|
||||
modTime time.Time
|
||||
}
|
||||
|
||||
func (f *memFileInfo) Name() string { return f.name }
|
||||
func (f *memFileInfo) Size() int64 { return f.size }
|
||||
func (f *memFileInfo) Mode() os.FileMode { return f.mode }
|
||||
func (f *memFileInfo) ModTime() time.Time { return f.modTime }
|
||||
func (f *memFileInfo) IsDir() bool { return f.mode.IsDir() }
|
||||
func (f *memFileInfo) Sys() interface{} { return nil }
|
||||
|
||||
// A memFile is a File implementation for a memFSNode. It is a per-file (not
|
||||
// per-node) read/write position, and a snapshot of the memFS' tree structure
|
||||
// (a node's name and children) for that node.
|
||||
type memFile struct {
|
||||
n *memFSNode
|
||||
nameSnapshot string
|
||||
childrenSnapshot []os.FileInfo
|
||||
// pos is protected by n.mu.
|
||||
pos int
|
||||
}
|
||||
|
||||
// A *memFile implements the optional DeadPropsHolder interface.
|
||||
var _ DeadPropsHolder = (*memFile)(nil)
|
||||
|
||||
func (f *memFile) DeadProps() (map[xml.Name]Property, error) { return f.n.DeadProps() }
|
||||
func (f *memFile) Patch(patches []Proppatch) ([]Propstat, error) { return f.n.Patch(patches) }
|
||||
|
||||
func (f *memFile) Close() error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func (f *memFile) Read(p []byte) (int, error) {
|
||||
f.n.mu.Lock()
|
||||
defer f.n.mu.Unlock()
|
||||
if f.n.mode.IsDir() {
|
||||
return 0, os.ErrInvalid
|
||||
}
|
||||
if f.pos >= len(f.n.data) {
|
||||
return 0, io.EOF
|
||||
}
|
||||
n := copy(p, f.n.data[f.pos:])
|
||||
f.pos += n
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func (f *memFile) Readdir(count int) ([]os.FileInfo, error) {
|
||||
f.n.mu.Lock()
|
||||
defer f.n.mu.Unlock()
|
||||
if !f.n.mode.IsDir() {
|
||||
return nil, os.ErrInvalid
|
||||
}
|
||||
old := f.pos
|
||||
if old >= len(f.childrenSnapshot) {
|
||||
// The os.File Readdir docs say that at the end of a directory,
|
||||
// the error is io.EOF if count > 0 and nil if count <= 0.
|
||||
if count > 0 {
|
||||
return nil, io.EOF
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
if count > 0 {
|
||||
f.pos += count
|
||||
if f.pos > len(f.childrenSnapshot) {
|
||||
f.pos = len(f.childrenSnapshot)
|
||||
}
|
||||
} else {
|
||||
f.pos = len(f.childrenSnapshot)
|
||||
old = 0
|
||||
}
|
||||
return f.childrenSnapshot[old:f.pos], nil
|
||||
}
|
||||
|
||||
func (f *memFile) Seek(offset int64, whence int) (int64, error) {
|
||||
f.n.mu.Lock()
|
||||
defer f.n.mu.Unlock()
|
||||
npos := f.pos
|
||||
// TODO: How to handle offsets greater than the size of system int?
|
||||
switch whence {
|
||||
case os.SEEK_SET:
|
||||
npos = int(offset)
|
||||
case os.SEEK_CUR:
|
||||
npos += int(offset)
|
||||
case os.SEEK_END:
|
||||
npos = len(f.n.data) + int(offset)
|
||||
default:
|
||||
npos = -1
|
||||
}
|
||||
if npos < 0 {
|
||||
return 0, os.ErrInvalid
|
||||
}
|
||||
f.pos = npos
|
||||
return int64(f.pos), nil
|
||||
}
|
||||
|
||||
func (f *memFile) Stat() (os.FileInfo, error) {
|
||||
return f.n.stat(f.nameSnapshot), nil
|
||||
}
|
||||
|
||||
func (f *memFile) Write(p []byte) (int, error) {
|
||||
lenp := len(p)
|
||||
f.n.mu.Lock()
|
||||
defer f.n.mu.Unlock()
|
||||
|
||||
if f.n.mode.IsDir() {
|
||||
return 0, os.ErrInvalid
|
||||
}
|
||||
if f.pos < len(f.n.data) {
|
||||
n := copy(f.n.data[f.pos:], p)
|
||||
f.pos += n
|
||||
p = p[n:]
|
||||
} else if f.pos > len(f.n.data) {
|
||||
// Write permits the creation of holes, if we've seek'ed past the
|
||||
// existing end of file.
|
||||
if f.pos <= cap(f.n.data) {
|
||||
oldLen := len(f.n.data)
|
||||
f.n.data = f.n.data[:f.pos]
|
||||
hole := f.n.data[oldLen:]
|
||||
for i := range hole {
|
||||
hole[i] = 0
|
||||
}
|
||||
} else {
|
||||
d := make([]byte, f.pos, f.pos+len(p))
|
||||
copy(d, f.n.data)
|
||||
f.n.data = d
|
||||
}
|
||||
}
|
||||
|
||||
if len(p) > 0 {
|
||||
// We should only get here if f.pos == len(f.n.data).
|
||||
f.n.data = append(f.n.data, p...)
|
||||
f.pos = len(f.n.data)
|
||||
}
|
||||
f.n.modTime = time.Now()
|
||||
return lenp, nil
|
||||
}
|
||||
|
||||
// moveFiles moves files and/or directories from src to dst.
|
||||
//
|
||||
// See section 9.9.4 for when various HTTP status codes apply.
|
||||
func moveFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool) (status int, err error) {
|
||||
created := false
|
||||
if _, err := fs.Stat(ctx, dst); err != nil {
|
||||
if !os.IsNotExist(err) {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
created = true
|
||||
} else if overwrite {
|
||||
// Section 9.9.3 says that "If a resource exists at the destination
|
||||
// and the Overwrite header is "T", then prior to performing the move,
|
||||
// the server must perform a DELETE with "Depth: infinity" on the
|
||||
// destination resource.
|
||||
if err := fs.RemoveAll(ctx, dst); err != nil {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
} else {
|
||||
return http.StatusPreconditionFailed, os.ErrExist
|
||||
}
|
||||
if err := fs.Rename(ctx, src, dst); err != nil {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
if created {
|
||||
return http.StatusCreated, nil
|
||||
}
|
||||
return http.StatusNoContent, nil
|
||||
}
|
||||
|
||||
func copyProps(dst, src File) error {
|
||||
d, ok := dst.(DeadPropsHolder)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
s, ok := src.(DeadPropsHolder)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
m, err := s.DeadProps()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
props := make([]Property, 0, len(m))
|
||||
for _, prop := range m {
|
||||
props = append(props, prop)
|
||||
}
|
||||
_, err = d.Patch([]Proppatch{{Props: props}})
|
||||
return err
|
||||
}
|
||||
|
||||
// copyFiles copies files and/or directories from src to dst.
|
||||
//
|
||||
// See section 9.8.5 for when various HTTP status codes apply.
|
||||
func copyFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool, depth int, recursion int) (status int, err error) {
|
||||
if recursion == 1000 {
|
||||
return http.StatusInternalServerError, errRecursionTooDeep
|
||||
}
|
||||
recursion++
|
||||
|
||||
// TODO: section 9.8.3 says that "Note that an infinite-depth COPY of /A/
|
||||
// into /A/B/ could lead to infinite recursion if not handled correctly."
|
||||
|
||||
srcFile, err := fs.OpenFile(ctx, src, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
defer srcFile.Close()
|
||||
srcStat, err := srcFile.Stat()
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
srcPerm := srcStat.Mode() & os.ModePerm
|
||||
|
||||
created := false
|
||||
if _, err := fs.Stat(ctx, dst); err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
created = true
|
||||
} else {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
} else {
|
||||
if !overwrite {
|
||||
return http.StatusPreconditionFailed, os.ErrExist
|
||||
}
|
||||
if err := fs.RemoveAll(ctx, dst); err != nil && !os.IsNotExist(err) {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
}
|
||||
|
||||
if srcStat.IsDir() {
|
||||
if err := fs.Mkdir(ctx, dst, srcPerm); err != nil {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
if depth == infiniteDepth {
|
||||
children, err := srcFile.Readdir(-1)
|
||||
if err != nil {
|
||||
return http.StatusForbidden, err
|
||||
}
|
||||
for _, c := range children {
|
||||
name := c.Name()
|
||||
s := path.Join(src, name)
|
||||
d := path.Join(dst, name)
|
||||
cStatus, cErr := copyFiles(ctx, fs, s, d, overwrite, depth, recursion)
|
||||
if cErr != nil {
|
||||
// TODO: MultiStatus.
|
||||
return cStatus, cErr
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
dstFile, err := fs.OpenFile(ctx, dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, srcPerm)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return http.StatusConflict, err
|
||||
}
|
||||
return http.StatusForbidden, err
|
||||
|
||||
}
|
||||
_, copyErr := io.Copy(dstFile, srcFile)
|
||||
propsErr := copyProps(dstFile, srcFile)
|
||||
closeErr := dstFile.Close()
|
||||
if copyErr != nil {
|
||||
return http.StatusInternalServerError, copyErr
|
||||
}
|
||||
if propsErr != nil {
|
||||
return http.StatusInternalServerError, propsErr
|
||||
}
|
||||
if closeErr != nil {
|
||||
return http.StatusInternalServerError, closeErr
|
||||
}
|
||||
}
|
||||
|
||||
if created {
|
||||
return http.StatusCreated, nil
|
||||
}
|
||||
return http.StatusNoContent, nil
|
||||
}
|
||||
|
||||
// walkFS traverses filesystem fs starting at name up to depth levels.
|
||||
//
|
||||
// Allowed values for depth are 0, 1 or infiniteDepth. For each visited node,
|
||||
// walkFS calls walkFn. If a visited file system node is a directory and
|
||||
// walkFn returns filepath.SkipDir, walkFS will skip traversal of this node.
|
||||
func walkFS(ctx context.Context, fs FileSystem, depth int, name string, info os.FileInfo, walkFn filepath.WalkFunc) error {
|
||||
// This implementation is based on Walk's code in the standard path/filepath package.
|
||||
err := walkFn(name, info, nil)
|
||||
if err != nil {
|
||||
if info.IsDir() && err == filepath.SkipDir {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
if !info.IsDir() || depth == 0 {
|
||||
return nil
|
||||
}
|
||||
if depth == 1 {
|
||||
depth = 0
|
||||
}
|
||||
|
||||
// Read directory names.
|
||||
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return walkFn(name, info, err)
|
||||
}
|
||||
fileInfos, err := f.Readdir(0)
|
||||
f.Close()
|
||||
if err != nil {
|
||||
return walkFn(name, info, err)
|
||||
}
|
||||
|
||||
for _, fileInfo := range fileInfos {
|
||||
filename := path.Join(name, fileInfo.Name())
|
||||
fileInfo, err := fs.Stat(ctx, filename)
|
||||
if err != nil {
|
||||
if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
err = walkFS(ctx, fs, depth, filename, fileInfo, walkFn)
|
||||
if err != nil {
|
||||
if !fileInfo.IsDir() || err != filepath.SkipDir {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
17
file_go1.6.go
Normal file
17
file_go1.6.go
Normal file
@ -0,0 +1,17 @@
|
||||
// Copyright 2016 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.
|
||||
|
||||
// +build !go1.7
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
func getContext(r *http.Request) context.Context {
|
||||
return context.Background()
|
||||
}
|
16
file_go1.7.go
Normal file
16
file_go1.7.go
Normal file
@ -0,0 +1,16 @@
|
||||
// Copyright 2016 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.
|
||||
|
||||
// +build go1.7
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"context"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
func getContext(r *http.Request) context.Context {
|
||||
return r.Context()
|
||||
}
|
1184
file_test.go
Normal file
1184
file_test.go
Normal file
File diff suppressed because it is too large
Load Diff
173
if.go
Normal file
173
if.go
Normal file
@ -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 webdav
|
||||
|
||||
// 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:]
|
||||
}
|
322
if_test.go
Normal file
322
if_test.go
Normal file
@ -0,0 +1,322 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestParseIfHeader(t *testing.T) {
|
||||
// The "section x.y.z" test cases come from section x.y.z of the spec at
|
||||
// http://www.webdav.org/specs/rfc4918.html
|
||||
testCases := []struct {
|
||||
desc string
|
||||
input string
|
||||
want ifHeader
|
||||
}{{
|
||||
"bad: empty",
|
||||
``,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no parens",
|
||||
`foobar`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: empty list #1",
|
||||
`()`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: empty list #2",
|
||||
`(a) (b c) () (d)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no list after resource #1",
|
||||
`<foo>`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no list after resource #2",
|
||||
`<foo> <bar> (a)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no list after resource #3",
|
||||
`<foo> (a) (b) <bar>`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no-tag-list followed by tagged-list",
|
||||
`(a) (b) <foo> (c)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished list",
|
||||
`(a`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished ETag",
|
||||
`([b`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished Notted list",
|
||||
`(Not a`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: double Not",
|
||||
`(Not Not a)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"good: one list with a Token",
|
||||
`(a)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `a`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: one list with an ETag",
|
||||
`([a])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
ETag: `a`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: one list with three Nots",
|
||||
`(Not a Not b Not [d])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `a`,
|
||||
}, {
|
||||
Not: true,
|
||||
Token: `b`,
|
||||
}, {
|
||||
Not: true,
|
||||
ETag: `d`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: two lists",
|
||||
`(a) (b)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `a`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Token: `b`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: two Notted lists",
|
||||
`(Not a) (Not b)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `a`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `b`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.1",
|
||||
`<http://www.example.com/users/f/fielding/index.html>
|
||||
(<urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://www.example.com/users/f/fielding/index.html`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #1",
|
||||
`(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #2",
|
||||
`<http://example.com/locked/>
|
||||
(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://example.com/locked/`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #3",
|
||||
`<http://example.com/locked/member>
|
||||
(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://example.com/locked/member`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 9.9.6",
|
||||
`(<urn:uuid:fe184f2e-6eec-41d0-c765-01adc56e6bb4>)
|
||||
(<urn:uuid:e454f3f3-acdc-452a-56c7-00a5c91e4b77>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:fe184f2e-6eec-41d0-c765-01adc56e6bb4`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:e454f3f3-acdc-452a-56c7-00a5c91e4b77`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 9.10.8",
|
||||
`(<urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.6",
|
||||
`(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
["I am an ETag"])
|
||||
(["I am another ETag"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
ETag: `"I am an ETag"`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
ETag: `"I am another ETag"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.7",
|
||||
`(Not <urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
<urn:uuid:58f202ac-22cf-11d1-b12d-002035b29092>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
Token: `urn:uuid:58f202ac-22cf-11d1-b12d-002035b29092`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.8",
|
||||
`(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>)
|
||||
(Not <DAV:no-lock>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `DAV:no-lock`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.9",
|
||||
`</resource1>
|
||||
(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
[W/"A weak ETag"]) (["strong ETag"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/resource1`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
ETag: `W/"A weak ETag"`,
|
||||
}},
|
||||
}, {
|
||||
resourceTag: `/resource1`,
|
||||
conditions: []Condition{{
|
||||
ETag: `"strong ETag"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.10",
|
||||
`<http://www.example.com/specs/>
|
||||
(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://www.example.com/specs/`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.11 #1",
|
||||
`</specs/rfc2518.doc> (["4217"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/specs/rfc2518.doc`,
|
||||
conditions: []Condition{{
|
||||
ETag: `"4217"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.11 #2",
|
||||
`</specs/rfc2518.doc> (Not ["4217"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/specs/rfc2518.doc`,
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
ETag: `"4217"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
got, ok := parseIfHeader(strings.Replace(tc.input, "\n", "", -1))
|
||||
if gotEmpty := reflect.DeepEqual(got, ifHeader{}); gotEmpty == ok {
|
||||
t.Errorf("%s: should be different: empty header == %t, ok == %t", tc.desc, gotEmpty, ok)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(got, tc.want) {
|
||||
t.Errorf("%s:\ngot %v\nwant %v", tc.desc, got, tc.want)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
94
litmus_test_server.go
Normal file
94
litmus_test_server.go
Normal file
@ -0,0 +1,94 @@
|
||||
// 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.
|
||||
|
||||
// +build ignore
|
||||
|
||||
/*
|
||||
This program is a server for the WebDAV 'litmus' compliance test at
|
||||
http://www.webdav.org/neon/litmus/
|
||||
To run the test:
|
||||
|
||||
go run litmus_test_server.go
|
||||
|
||||
and separately, from the downloaded litmus-xxx directory:
|
||||
|
||||
make URL=http://localhost:9999/ check
|
||||
*/
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"net/url"
|
||||
|
||||
"golang.org/x/net/webdav"
|
||||
)
|
||||
|
||||
var port = flag.Int("port", 9999, "server port")
|
||||
|
||||
func main() {
|
||||
flag.Parse()
|
||||
log.SetFlags(0)
|
||||
h := &webdav.Handler{
|
||||
FileSystem: webdav.NewMemFS(),
|
||||
LockSystem: webdav.NewMemLS(),
|
||||
Logger: func(r *http.Request, err error) {
|
||||
litmus := r.Header.Get("X-Litmus")
|
||||
if len(litmus) > 19 {
|
||||
litmus = litmus[:16] + "..."
|
||||
}
|
||||
|
||||
switch r.Method {
|
||||
case "COPY", "MOVE":
|
||||
dst := ""
|
||||
if u, err := url.Parse(r.Header.Get("Destination")); err == nil {
|
||||
dst = u.Path
|
||||
}
|
||||
o := r.Header.Get("Overwrite")
|
||||
log.Printf("%-20s%-10s%-30s%-30so=%-2s%v", litmus, r.Method, r.URL.Path, dst, o, err)
|
||||
default:
|
||||
log.Printf("%-20s%-10s%-30s%v", litmus, r.Method, r.URL.Path, err)
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
// The next line would normally be:
|
||||
// http.Handle("/", h)
|
||||
// but we wrap that HTTP handler h to cater for a special case.
|
||||
//
|
||||
// The propfind_invalid2 litmus test case expects an empty namespace prefix
|
||||
// declaration to be an error. The FAQ in the webdav litmus test says:
|
||||
//
|
||||
// "What does the "propfind_invalid2" test check for?...
|
||||
//
|
||||
// If a request was sent with an XML body which included an empty namespace
|
||||
// prefix declaration (xmlns:ns1=""), then the server must reject that with
|
||||
// a "400 Bad Request" response, as it is invalid according to the XML
|
||||
// Namespace specification."
|
||||
//
|
||||
// On the other hand, the Go standard library's encoding/xml package
|
||||
// accepts an empty xmlns namespace, as per the discussion at
|
||||
// https://github.com/golang/go/issues/8068
|
||||
//
|
||||
// Empty namespaces seem disallowed in the second (2006) edition of the XML
|
||||
// standard, but allowed in a later edition. The grammar differs between
|
||||
// http://www.w3.org/TR/2006/REC-xml-names-20060816/#ns-decl and
|
||||
// http://www.w3.org/TR/REC-xml-names/#dt-prefix
|
||||
//
|
||||
// Thus, we assume that the propfind_invalid2 test is obsolete, and
|
||||
// hard-code the 400 Bad Request response that the test expects.
|
||||
http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Header.Get("X-Litmus") == "props: 3 (propfind_invalid2)" {
|
||||
http.Error(w, "400 Bad Request", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
h.ServeHTTP(w, r)
|
||||
}))
|
||||
|
||||
addr := fmt.Sprintf(":%d", *port)
|
||||
log.Printf("Serving %v", addr)
|
||||
log.Fatal(http.ListenAndServe(addr, nil))
|
||||
}
|
445
lock.go
Normal file
445
lock.go
Normal file
@ -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 webdav
|
||||
|
||||
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
|
||||
}
|
731
lock_test.go
Normal file
731
lock_test.go
Normal file
@ -0,0 +1,731 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math/rand"
|
||||
"path"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestWalkToRoot(t *testing.T) {
|
||||
testCases := []struct {
|
||||
name string
|
||||
want []string
|
||||
}{{
|
||||
"/a/b/c/d",
|
||||
[]string{
|
||||
"/a/b/c/d",
|
||||
"/a/b/c",
|
||||
"/a/b",
|
||||
"/a",
|
||||
"/",
|
||||
},
|
||||
}, {
|
||||
"/a",
|
||||
[]string{
|
||||
"/a",
|
||||
"/",
|
||||
},
|
||||
}, {
|
||||
"/",
|
||||
[]string{
|
||||
"/",
|
||||
},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
var got []string
|
||||
if !walkToRoot(tc.name, func(name0 string, first bool) bool {
|
||||
if first != (len(got) == 0) {
|
||||
t.Errorf("name=%q: first=%t but len(got)==%d", tc.name, first, len(got))
|
||||
return false
|
||||
}
|
||||
got = append(got, name0)
|
||||
return true
|
||||
}) {
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(got, tc.want) {
|
||||
t.Errorf("name=%q:\ngot %q\nwant %q", tc.name, got, tc.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var lockTestDurations = []time.Duration{
|
||||
infiniteTimeout, // infiniteTimeout means to never expire.
|
||||
0, // A zero duration means to expire immediately.
|
||||
100 * time.Hour, // A very large duration will not expire in these tests.
|
||||
}
|
||||
|
||||
// lockTestNames are the names of a set of mutually compatible locks. For each
|
||||
// name fragment:
|
||||
// - _ means no explicit lock.
|
||||
// - i means a infinite-depth lock,
|
||||
// - z means a zero-depth lock,
|
||||
var lockTestNames = []string{
|
||||
"/_/_/_/_/z",
|
||||
"/_/_/i",
|
||||
"/_/z",
|
||||
"/_/z/i",
|
||||
"/_/z/z",
|
||||
"/_/z/_/i",
|
||||
"/_/z/_/z",
|
||||
"/i",
|
||||
"/z",
|
||||
"/z/_/i",
|
||||
"/z/_/z",
|
||||
}
|
||||
|
||||
func lockTestZeroDepth(name string) bool {
|
||||
switch name[len(name)-1] {
|
||||
case 'i':
|
||||
return false
|
||||
case 'z':
|
||||
return true
|
||||
}
|
||||
panic(fmt.Sprintf("lock name %q did not end with 'i' or 'z'", name))
|
||||
}
|
||||
|
||||
func TestMemLSCanCreate(t *testing.T) {
|
||||
now := time.Unix(0, 0)
|
||||
m := NewMemLS().(*memLS)
|
||||
|
||||
for _, name := range lockTestNames {
|
||||
_, err := m.Create(now, LockDetails{
|
||||
Root: name,
|
||||
Duration: infiniteTimeout,
|
||||
ZeroDepth: lockTestZeroDepth(name),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("creating lock for %q: %v", name, err)
|
||||
}
|
||||
}
|
||||
|
||||
wantCanCreate := func(name string, zeroDepth bool) bool {
|
||||
for _, n := range lockTestNames {
|
||||
switch {
|
||||
case n == name:
|
||||
// An existing lock has the same name as the proposed lock.
|
||||
return false
|
||||
case strings.HasPrefix(n, name):
|
||||
// An existing lock would be a child of the proposed lock,
|
||||
// which conflicts if the proposed lock has infinite depth.
|
||||
if !zeroDepth {
|
||||
return false
|
||||
}
|
||||
case strings.HasPrefix(name, n):
|
||||
// An existing lock would be an ancestor of the proposed lock,
|
||||
// which conflicts if the ancestor has infinite depth.
|
||||
if n[len(n)-1] == 'i' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
var check func(int, string)
|
||||
check = func(recursion int, name string) {
|
||||
for _, zeroDepth := range []bool{false, true} {
|
||||
got := m.canCreate(name, zeroDepth)
|
||||
want := wantCanCreate(name, zeroDepth)
|
||||
if got != want {
|
||||
t.Errorf("canCreate name=%q zeroDepth=%t: got %t, want %t", name, zeroDepth, got, want)
|
||||
}
|
||||
}
|
||||
if recursion == 6 {
|
||||
return
|
||||
}
|
||||
if name != "/" {
|
||||
name += "/"
|
||||
}
|
||||
for _, c := range "_iz" {
|
||||
check(recursion+1, name+string(c))
|
||||
}
|
||||
}
|
||||
check(0, "/")
|
||||
}
|
||||
|
||||
func TestMemLSLookup(t *testing.T) {
|
||||
now := time.Unix(0, 0)
|
||||
m := NewMemLS().(*memLS)
|
||||
|
||||
badToken := m.nextToken()
|
||||
t.Logf("badToken=%q", badToken)
|
||||
|
||||
for _, name := range lockTestNames {
|
||||
token, err := m.Create(now, LockDetails{
|
||||
Root: name,
|
||||
Duration: infiniteTimeout,
|
||||
ZeroDepth: lockTestZeroDepth(name),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("creating lock for %q: %v", name, err)
|
||||
}
|
||||
t.Logf("%-15q -> node=%p token=%q", name, m.byName[name], token)
|
||||
}
|
||||
|
||||
baseNames := append([]string{"/a", "/b/c"}, lockTestNames...)
|
||||
for _, baseName := range baseNames {
|
||||
for _, suffix := range []string{"", "/0", "/1/2/3"} {
|
||||
name := baseName + suffix
|
||||
|
||||
goodToken := ""
|
||||
base := m.byName[baseName]
|
||||
if base != nil && (suffix == "" || !lockTestZeroDepth(baseName)) {
|
||||
goodToken = base.token
|
||||
}
|
||||
|
||||
for _, token := range []string{badToken, goodToken} {
|
||||
if token == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
got := m.lookup(name, Condition{Token: token})
|
||||
want := base
|
||||
if token == badToken {
|
||||
want = nil
|
||||
}
|
||||
if got != want {
|
||||
t.Errorf("name=%-20qtoken=%q (bad=%t): got %p, want %p",
|
||||
name, token, token == badToken, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemLSConfirm(t *testing.T) {
|
||||
now := time.Unix(0, 0)
|
||||
m := NewMemLS().(*memLS)
|
||||
alice, err := m.Create(now, LockDetails{
|
||||
Root: "/alice",
|
||||
Duration: infiniteTimeout,
|
||||
ZeroDepth: false,
|
||||
})
|
||||
tweedle, err := m.Create(now, LockDetails{
|
||||
Root: "/tweedle",
|
||||
Duration: infiniteTimeout,
|
||||
ZeroDepth: false,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Create: %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Create: inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
// Test a mismatch between name and condition.
|
||||
_, err = m.Confirm(now, "/tweedle/dee", "", Condition{Token: alice})
|
||||
if err != ErrConfirmationFailed {
|
||||
t.Fatalf("Confirm (mismatch): got %v, want ErrConfirmationFailed", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Confirm (mismatch): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
// Test two names (that fall under the same lock) in the one Confirm call.
|
||||
release, err := m.Confirm(now, "/tweedle/dee", "/tweedle/dum", Condition{Token: tweedle})
|
||||
if err != nil {
|
||||
t.Fatalf("Confirm (twins): %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Confirm (twins): inconsistent state: %v", err)
|
||||
}
|
||||
release()
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("release (twins): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
// Test the same two names in overlapping Confirm / release calls.
|
||||
releaseDee, err := m.Confirm(now, "/tweedle/dee", "", Condition{Token: tweedle})
|
||||
if err != nil {
|
||||
t.Fatalf("Confirm (sequence #0): %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Confirm (sequence #0): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
_, err = m.Confirm(now, "/tweedle/dum", "", Condition{Token: tweedle})
|
||||
if err != ErrConfirmationFailed {
|
||||
t.Fatalf("Confirm (sequence #1): got %v, want ErrConfirmationFailed", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Confirm (sequence #1): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
releaseDee()
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("release (sequence #2): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
releaseDum, err := m.Confirm(now, "/tweedle/dum", "", Condition{Token: tweedle})
|
||||
if err != nil {
|
||||
t.Fatalf("Confirm (sequence #3): %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Confirm (sequence #3): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
// Test that you can't unlock a held lock.
|
||||
err = m.Unlock(now, tweedle)
|
||||
if err != ErrLocked {
|
||||
t.Fatalf("Unlock (sequence #4): got %v, want ErrLocked", err)
|
||||
}
|
||||
|
||||
releaseDum()
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("release (sequence #5): inconsistent state: %v", err)
|
||||
}
|
||||
|
||||
err = m.Unlock(now, tweedle)
|
||||
if err != nil {
|
||||
t.Fatalf("Unlock (sequence #6): %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Unlock (sequence #6): inconsistent state: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemLSNonCanonicalRoot(t *testing.T) {
|
||||
now := time.Unix(0, 0)
|
||||
m := NewMemLS().(*memLS)
|
||||
token, err := m.Create(now, LockDetails{
|
||||
Root: "/foo/./bar//",
|
||||
Duration: 1 * time.Second,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("Create: %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Create: inconsistent state: %v", err)
|
||||
}
|
||||
if err := m.Unlock(now, token); err != nil {
|
||||
t.Fatalf("Unlock: %v", err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("Unlock: inconsistent state: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemLSExpiry(t *testing.T) {
|
||||
m := NewMemLS().(*memLS)
|
||||
testCases := []string{
|
||||
"setNow 0",
|
||||
"create /a.5",
|
||||
"want /a.5",
|
||||
"create /c.6",
|
||||
"want /a.5 /c.6",
|
||||
"create /a/b.7",
|
||||
"want /a.5 /a/b.7 /c.6",
|
||||
"setNow 4",
|
||||
"want /a.5 /a/b.7 /c.6",
|
||||
"setNow 5",
|
||||
"want /a/b.7 /c.6",
|
||||
"setNow 6",
|
||||
"want /a/b.7",
|
||||
"setNow 7",
|
||||
"want ",
|
||||
"setNow 8",
|
||||
"want ",
|
||||
"create /a.12",
|
||||
"create /b.13",
|
||||
"create /c.15",
|
||||
"create /a/d.16",
|
||||
"want /a.12 /a/d.16 /b.13 /c.15",
|
||||
"refresh /a.14",
|
||||
"want /a.14 /a/d.16 /b.13 /c.15",
|
||||
"setNow 12",
|
||||
"want /a.14 /a/d.16 /b.13 /c.15",
|
||||
"setNow 13",
|
||||
"want /a.14 /a/d.16 /c.15",
|
||||
"setNow 14",
|
||||
"want /a/d.16 /c.15",
|
||||
"refresh /a/d.20",
|
||||
"refresh /c.20",
|
||||
"want /a/d.20 /c.20",
|
||||
"setNow 20",
|
||||
"want ",
|
||||
}
|
||||
|
||||
tokens := map[string]string{}
|
||||
zTime := time.Unix(0, 0)
|
||||
now := zTime
|
||||
for i, tc := range testCases {
|
||||
j := strings.IndexByte(tc, ' ')
|
||||
if j < 0 {
|
||||
t.Fatalf("test case #%d %q: invalid command", i, tc)
|
||||
}
|
||||
op, arg := tc[:j], tc[j+1:]
|
||||
switch op {
|
||||
default:
|
||||
t.Fatalf("test case #%d %q: invalid operation %q", i, tc, op)
|
||||
|
||||
case "create", "refresh":
|
||||
parts := strings.Split(arg, ".")
|
||||
if len(parts) != 2 {
|
||||
t.Fatalf("test case #%d %q: invalid create", i, tc)
|
||||
}
|
||||
root := parts[0]
|
||||
d, err := strconv.Atoi(parts[1])
|
||||
if err != nil {
|
||||
t.Fatalf("test case #%d %q: invalid duration", i, tc)
|
||||
}
|
||||
dur := time.Unix(0, 0).Add(time.Duration(d) * time.Second).Sub(now)
|
||||
|
||||
switch op {
|
||||
case "create":
|
||||
token, err := m.Create(now, LockDetails{
|
||||
Root: root,
|
||||
Duration: dur,
|
||||
ZeroDepth: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("test case #%d %q: Create: %v", i, tc, err)
|
||||
}
|
||||
tokens[root] = token
|
||||
|
||||
case "refresh":
|
||||
token := tokens[root]
|
||||
if token == "" {
|
||||
t.Fatalf("test case #%d %q: no token for %q", i, tc, root)
|
||||
}
|
||||
got, err := m.Refresh(now, token, dur)
|
||||
if err != nil {
|
||||
t.Fatalf("test case #%d %q: Refresh: %v", i, tc, err)
|
||||
}
|
||||
want := LockDetails{
|
||||
Root: root,
|
||||
Duration: dur,
|
||||
ZeroDepth: true,
|
||||
}
|
||||
if got != want {
|
||||
t.Fatalf("test case #%d %q:\ngot %v\nwant %v", i, tc, got, want)
|
||||
}
|
||||
}
|
||||
|
||||
case "setNow":
|
||||
d, err := strconv.Atoi(arg)
|
||||
if err != nil {
|
||||
t.Fatalf("test case #%d %q: invalid duration", i, tc)
|
||||
}
|
||||
now = time.Unix(0, 0).Add(time.Duration(d) * time.Second)
|
||||
|
||||
case "want":
|
||||
m.mu.Lock()
|
||||
m.collectExpiredNodes(now)
|
||||
got := make([]string, 0, len(m.byToken))
|
||||
for _, n := range m.byToken {
|
||||
got = append(got, fmt.Sprintf("%s.%d",
|
||||
n.details.Root, n.expiry.Sub(zTime)/time.Second))
|
||||
}
|
||||
m.mu.Unlock()
|
||||
sort.Strings(got)
|
||||
want := []string{}
|
||||
if arg != "" {
|
||||
want = strings.Split(arg, " ")
|
||||
}
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("test case #%d %q:\ngot %q\nwant %q", i, tc, got, want)
|
||||
}
|
||||
}
|
||||
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("test case #%d %q: inconsistent state: %v", i, tc, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMemLS(t *testing.T) {
|
||||
now := time.Unix(0, 0)
|
||||
m := NewMemLS().(*memLS)
|
||||
rng := rand.New(rand.NewSource(0))
|
||||
tokens := map[string]string{}
|
||||
nConfirm, nCreate, nRefresh, nUnlock := 0, 0, 0, 0
|
||||
const N = 2000
|
||||
|
||||
for i := 0; i < N; i++ {
|
||||
name := lockTestNames[rng.Intn(len(lockTestNames))]
|
||||
duration := lockTestDurations[rng.Intn(len(lockTestDurations))]
|
||||
confirmed, unlocked := false, false
|
||||
|
||||
// If the name was already locked, we randomly confirm/release, refresh
|
||||
// or unlock it. Otherwise, we create a lock.
|
||||
token := tokens[name]
|
||||
if token != "" {
|
||||
switch rng.Intn(3) {
|
||||
case 0:
|
||||
confirmed = true
|
||||
nConfirm++
|
||||
release, err := m.Confirm(now, name, "", Condition{Token: token})
|
||||
if err != nil {
|
||||
t.Fatalf("iteration #%d: Confirm %q: %v", i, name, err)
|
||||
}
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("iteration #%d: inconsistent state: %v", i, err)
|
||||
}
|
||||
release()
|
||||
|
||||
case 1:
|
||||
nRefresh++
|
||||
if _, err := m.Refresh(now, token, duration); err != nil {
|
||||
t.Fatalf("iteration #%d: Refresh %q: %v", i, name, err)
|
||||
}
|
||||
|
||||
case 2:
|
||||
unlocked = true
|
||||
nUnlock++
|
||||
if err := m.Unlock(now, token); err != nil {
|
||||
t.Fatalf("iteration #%d: Unlock %q: %v", i, name, err)
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
nCreate++
|
||||
var err error
|
||||
token, err = m.Create(now, LockDetails{
|
||||
Root: name,
|
||||
Duration: duration,
|
||||
ZeroDepth: lockTestZeroDepth(name),
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("iteration #%d: Create %q: %v", i, name, err)
|
||||
}
|
||||
}
|
||||
|
||||
if !confirmed {
|
||||
if duration == 0 || unlocked {
|
||||
// A zero-duration lock should expire immediately and is
|
||||
// effectively equivalent to being unlocked.
|
||||
tokens[name] = ""
|
||||
} else {
|
||||
tokens[name] = token
|
||||
}
|
||||
}
|
||||
|
||||
if err := m.consistent(); err != nil {
|
||||
t.Fatalf("iteration #%d: inconsistent state: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
if nConfirm < N/10 {
|
||||
t.Fatalf("too few Confirm calls: got %d, want >= %d", nConfirm, N/10)
|
||||
}
|
||||
if nCreate < N/10 {
|
||||
t.Fatalf("too few Create calls: got %d, want >= %d", nCreate, N/10)
|
||||
}
|
||||
if nRefresh < N/10 {
|
||||
t.Fatalf("too few Refresh calls: got %d, want >= %d", nRefresh, N/10)
|
||||
}
|
||||
if nUnlock < N/10 {
|
||||
t.Fatalf("too few Unlock calls: got %d, want >= %d", nUnlock, N/10)
|
||||
}
|
||||
}
|
||||
|
||||
func (m *memLS) consistent() error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
|
||||
// If m.byName is non-empty, then it must contain an entry for the root "/",
|
||||
// and its refCount should equal the number of locked nodes.
|
||||
if len(m.byName) > 0 {
|
||||
n := m.byName["/"]
|
||||
if n == nil {
|
||||
return fmt.Errorf(`non-empty m.byName does not contain the root "/"`)
|
||||
}
|
||||
if n.refCount != len(m.byToken) {
|
||||
return fmt.Errorf("root node refCount=%d, differs from len(m.byToken)=%d", n.refCount, len(m.byToken))
|
||||
}
|
||||
}
|
||||
|
||||
for name, n := range m.byName {
|
||||
// The map keys should be consistent with the node's copy of the key.
|
||||
if n.details.Root != name {
|
||||
return fmt.Errorf("node name %q != byName map key %q", n.details.Root, name)
|
||||
}
|
||||
|
||||
// A name must be clean, and start with a "/".
|
||||
if len(name) == 0 || name[0] != '/' {
|
||||
return fmt.Errorf(`node name %q does not start with "/"`, name)
|
||||
}
|
||||
if name != path.Clean(name) {
|
||||
return fmt.Errorf(`node name %q is not clean`, name)
|
||||
}
|
||||
|
||||
// A node's refCount should be positive.
|
||||
if n.refCount <= 0 {
|
||||
return fmt.Errorf("non-positive refCount for node at name %q", name)
|
||||
}
|
||||
|
||||
// A node's refCount should be the number of self-or-descendents that
|
||||
// are locked (i.e. have a non-empty token).
|
||||
var list []string
|
||||
for name0, n0 := range m.byName {
|
||||
// All of lockTestNames' name fragments are one byte long: '_', 'i' or 'z',
|
||||
// so strings.HasPrefix is equivalent to self-or-descendent name match.
|
||||
// We don't have to worry about "/foo/bar" being a false positive match
|
||||
// for "/foo/b".
|
||||
if strings.HasPrefix(name0, name) && n0.token != "" {
|
||||
list = append(list, name0)
|
||||
}
|
||||
}
|
||||
if n.refCount != len(list) {
|
||||
sort.Strings(list)
|
||||
return fmt.Errorf("node at name %q has refCount %d but locked self-or-descendents are %q (len=%d)",
|
||||
name, n.refCount, list, len(list))
|
||||
}
|
||||
|
||||
// A node n is in m.byToken if it has a non-empty token.
|
||||
if n.token != "" {
|
||||
if _, ok := m.byToken[n.token]; !ok {
|
||||
return fmt.Errorf("node at name %q has token %q but not in m.byToken", name, n.token)
|
||||
}
|
||||
}
|
||||
|
||||
// A node n is in m.byExpiry if it has a non-negative byExpiryIndex.
|
||||
if n.byExpiryIndex >= 0 {
|
||||
if n.byExpiryIndex >= len(m.byExpiry) {
|
||||
return fmt.Errorf("node at name %q has byExpiryIndex %d but m.byExpiry has length %d", name, n.byExpiryIndex, len(m.byExpiry))
|
||||
}
|
||||
if n != m.byExpiry[n.byExpiryIndex] {
|
||||
return fmt.Errorf("node at name %q has byExpiryIndex %d but that indexes a different node", name, n.byExpiryIndex)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for token, n := range m.byToken {
|
||||
// The map keys should be consistent with the node's copy of the key.
|
||||
if n.token != token {
|
||||
return fmt.Errorf("node token %q != byToken map key %q", n.token, token)
|
||||
}
|
||||
|
||||
// Every node in m.byToken is in m.byName.
|
||||
if _, ok := m.byName[n.details.Root]; !ok {
|
||||
return fmt.Errorf("node at name %q in m.byToken but not in m.byName", n.details.Root)
|
||||
}
|
||||
}
|
||||
|
||||
for i, n := range m.byExpiry {
|
||||
// The slice indices should be consistent with the node's copy of the index.
|
||||
if n.byExpiryIndex != i {
|
||||
return fmt.Errorf("node byExpiryIndex %d != byExpiry slice index %d", n.byExpiryIndex, i)
|
||||
}
|
||||
|
||||
// Every node in m.byExpiry is in m.byName.
|
||||
if _, ok := m.byName[n.details.Root]; !ok {
|
||||
return fmt.Errorf("node at name %q in m.byExpiry but not in m.byName", n.details.Root)
|
||||
}
|
||||
|
||||
// No node in m.byExpiry should be held.
|
||||
if n.held {
|
||||
return fmt.Errorf("node at name %q in m.byExpiry is held", n.details.Root)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func TestParseTimeout(t *testing.T) {
|
||||
testCases := []struct {
|
||||
s string
|
||||
want time.Duration
|
||||
wantErr error
|
||||
}{{
|
||||
"",
|
||||
infiniteTimeout,
|
||||
nil,
|
||||
}, {
|
||||
"Infinite",
|
||||
infiniteTimeout,
|
||||
nil,
|
||||
}, {
|
||||
"Infinitesimal",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"infinite",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second-0",
|
||||
0 * time.Second,
|
||||
nil,
|
||||
}, {
|
||||
"Second-123",
|
||||
123 * time.Second,
|
||||
nil,
|
||||
}, {
|
||||
" Second-456 ",
|
||||
456 * time.Second,
|
||||
nil,
|
||||
}, {
|
||||
"Second-4100000000",
|
||||
4100000000 * time.Second,
|
||||
nil,
|
||||
}, {
|
||||
"junk",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second-",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second--1",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second--123",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second-+123",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second-0x123",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"second-123",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
"Second-4294967295",
|
||||
4294967295 * time.Second,
|
||||
nil,
|
||||
}, {
|
||||
// Section 10.7 says that "The timeout value for TimeType "Second"
|
||||
// must not be greater than 2^32-1."
|
||||
"Second-4294967296",
|
||||
0,
|
||||
errInvalidTimeout,
|
||||
}, {
|
||||
// This test case comes from section 9.10.9 of the spec. It says,
|
||||
//
|
||||
// "In this request, the client has specified that it desires an
|
||||
// infinite-length lock, if available, otherwise a timeout of 4.1
|
||||
// billion seconds, if available."
|
||||
//
|
||||
// The Go WebDAV package always supports infinite length locks,
|
||||
// and ignores the fallback after the comma.
|
||||
"Infinite, Second-4100000000",
|
||||
infiniteTimeout,
|
||||
nil,
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
got, gotErr := parseTimeout(tc.s)
|
||||
if got != tc.want || gotErr != tc.wantErr {
|
||||
t.Errorf("parsing %q:\ngot %v, %v\nwant %v, %v", tc.s, got, gotErr, tc.want, tc.wantErr)
|
||||
}
|
||||
}
|
||||
}
|
418
prop.go
Normal file
418
prop.go
Normal file
@ -0,0 +1,418 @@
|
||||
// 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 webdav
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// 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().Format(http.TimeFormat), nil
|
||||
}
|
||||
|
||||
func findContentType(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
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
|
||||
}
|
||||
|
||||
func findETag(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
// 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
|
||||
}
|
613
prop_test.go
Normal file
613
prop_test.go
Normal file
@ -0,0 +1,613 @@
|
||||
// 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 webdav
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"reflect"
|
||||
"sort"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
func TestMemPS(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
// calcProps calculates the getlastmodified and getetag DAV: property
|
||||
// values in pstats for resource name in file-system fs.
|
||||
calcProps := func(name string, fs FileSystem, ls LockSystem, pstats []Propstat) error {
|
||||
fi, err := fs.Stat(ctx, name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, pst := range pstats {
|
||||
for i, p := range pst.Props {
|
||||
switch p.XMLName {
|
||||
case xml.Name{Space: "DAV:", Local: "getlastmodified"}:
|
||||
p.InnerXML = []byte(fi.ModTime().Format(http.TimeFormat))
|
||||
pst.Props[i] = p
|
||||
case xml.Name{Space: "DAV:", Local: "getetag"}:
|
||||
if fi.IsDir() {
|
||||
continue
|
||||
}
|
||||
etag, err := findETag(ctx, fs, ls, name, fi)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.InnerXML = []byte(etag)
|
||||
pst.Props[i] = p
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const (
|
||||
lockEntry = `` +
|
||||
`<D:lockentry xmlns:D="DAV:">` +
|
||||
`<D:lockscope><D:exclusive/></D:lockscope>` +
|
||||
`<D:locktype><D:write/></D:locktype>` +
|
||||
`</D:lockentry>`
|
||||
statForbiddenError = `<D:cannot-modify-protected-property xmlns:D="DAV:"/>`
|
||||
)
|
||||
|
||||
type propOp struct {
|
||||
op string
|
||||
name string
|
||||
pnames []xml.Name
|
||||
patches []Proppatch
|
||||
wantPnames []xml.Name
|
||||
wantPropstats []Propstat
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
desc string
|
||||
noDeadProps bool
|
||||
buildfs []string
|
||||
propOp []propOp
|
||||
}{{
|
||||
desc: "propname",
|
||||
buildfs: []string{"mkdir /dir", "touch /file"},
|
||||
propOp: []propOp{{
|
||||
op: "propname",
|
||||
name: "/dir",
|
||||
wantPnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "DAV:", Local: "displayname"},
|
||||
{Space: "DAV:", Local: "supportedlock"},
|
||||
{Space: "DAV:", Local: "getlastmodified"},
|
||||
},
|
||||
}, {
|
||||
op: "propname",
|
||||
name: "/file",
|
||||
wantPnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "DAV:", Local: "displayname"},
|
||||
{Space: "DAV:", Local: "getcontentlength"},
|
||||
{Space: "DAV:", Local: "getlastmodified"},
|
||||
{Space: "DAV:", Local: "getcontenttype"},
|
||||
{Space: "DAV:", Local: "getetag"},
|
||||
{Space: "DAV:", Local: "supportedlock"},
|
||||
},
|
||||
}},
|
||||
}, {
|
||||
desc: "allprop dir and file",
|
||||
buildfs: []string{"mkdir /dir", "write /file foobarbaz"},
|
||||
propOp: []propOp{{
|
||||
op: "allprop",
|
||||
name: "/dir",
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(`<D:collection xmlns:D="DAV:"/>`),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("dir"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getlastmodified"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "supportedlock"},
|
||||
InnerXML: []byte(lockEntry),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "allprop",
|
||||
name: "/file",
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(""),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("file"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontentlength"},
|
||||
InnerXML: []byte("9"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getlastmodified"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontenttype"},
|
||||
InnerXML: []byte("text/plain; charset=utf-8"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "supportedlock"},
|
||||
InnerXML: []byte(lockEntry),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "allprop",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{
|
||||
{"DAV:", "resourcetype"},
|
||||
{"foo", "bar"},
|
||||
},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(""),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("file"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontentlength"},
|
||||
InnerXML: []byte("9"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getlastmodified"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontenttype"},
|
||||
InnerXML: []byte("text/plain; charset=utf-8"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "supportedlock"},
|
||||
InnerXML: []byte(lockEntry),
|
||||
}}}, {
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}}},
|
||||
},
|
||||
}},
|
||||
}, {
|
||||
desc: "propfind DAV:resourcetype",
|
||||
buildfs: []string{"mkdir /dir", "touch /file"},
|
||||
propOp: []propOp{{
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{"DAV:", "resourcetype"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(`<D:collection xmlns:D="DAV:"/>`),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{{"DAV:", "resourcetype"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(""),
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "propfind unsupported DAV properties",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{"DAV:", "getcontentlanguage"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontentlanguage"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{"DAV:", "creationdate"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "creationdate"},
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "propfind getetag for files but not for directories",
|
||||
buildfs: []string{"mkdir /dir", "touch /file"},
|
||||
propOp: []propOp{{
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{"DAV:", "getetag"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{{"DAV:", "getetag"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch property on no-dead-properties file system",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
noDeadProps: true,
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusForbidden,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusForbidden,
|
||||
XMLError: statForbiddenError,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch dead property",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{Space: "foo", Local: "bar"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch dead property with failed dependency",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}},
|
||||
}, {
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("xxx"),
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusForbidden,
|
||||
XMLError: statForbiddenError,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
}},
|
||||
}, {
|
||||
Status: StatusFailedDependency,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{Space: "foo", Local: "bar"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch remove dead property",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "spam", Local: "ham"},
|
||||
InnerXML: []byte("eggs"),
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "spam", Local: "ham"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{
|
||||
{Space: "foo", Local: "bar"},
|
||||
{Space: "spam", Local: "ham"},
|
||||
},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "spam", Local: "ham"},
|
||||
InnerXML: []byte("eggs"),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Remove: true,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{
|
||||
{Space: "foo", Local: "bar"},
|
||||
{Space: "spam", Local: "ham"},
|
||||
},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}, {
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "spam", Local: "ham"},
|
||||
InnerXML: []byte("eggs"),
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "propname with dead property",
|
||||
buildfs: []string{"touch /file"},
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/file",
|
||||
patches: []Proppatch{{
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
InnerXML: []byte("baz"),
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propname",
|
||||
name: "/file",
|
||||
wantPnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "DAV:", Local: "displayname"},
|
||||
{Space: "DAV:", Local: "getcontentlength"},
|
||||
{Space: "DAV:", Local: "getlastmodified"},
|
||||
{Space: "DAV:", Local: "getcontenttype"},
|
||||
{Space: "DAV:", Local: "getetag"},
|
||||
{Space: "DAV:", Local: "supportedlock"},
|
||||
{Space: "foo", Local: "bar"},
|
||||
},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch remove unknown dead property",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "proppatch",
|
||||
name: "/dir",
|
||||
patches: []Proppatch{{
|
||||
Remove: true,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "bad: propfind unknown property",
|
||||
buildfs: []string{"mkdir /dir"},
|
||||
propOp: []propOp{{
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{"foo:", "bar"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "foo:", Local: "bar"},
|
||||
}},
|
||||
}},
|
||||
}},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
fs, err := buildTestFS(tc.buildfs)
|
||||
if err != nil {
|
||||
t.Fatalf("%s: cannot create test filesystem: %v", tc.desc, err)
|
||||
}
|
||||
if tc.noDeadProps {
|
||||
fs = noDeadPropsFS{fs}
|
||||
}
|
||||
ls := NewMemLS()
|
||||
for _, op := range tc.propOp {
|
||||
desc := fmt.Sprintf("%s: %s %s", tc.desc, op.op, op.name)
|
||||
if err = calcProps(op.name, fs, ls, op.wantPropstats); err != nil {
|
||||
t.Fatalf("%s: calcProps: %v", desc, err)
|
||||
}
|
||||
|
||||
// Call property system.
|
||||
var propstats []Propstat
|
||||
switch op.op {
|
||||
case "propname":
|
||||
pnames, err := propnames(ctx, fs, ls, op.name)
|
||||
if err != nil {
|
||||
t.Errorf("%s: got error %v, want nil", desc, err)
|
||||
continue
|
||||
}
|
||||
sort.Sort(byXMLName(pnames))
|
||||
sort.Sort(byXMLName(op.wantPnames))
|
||||
if !reflect.DeepEqual(pnames, op.wantPnames) {
|
||||
t.Errorf("%s: pnames\ngot %q\nwant %q", desc, pnames, op.wantPnames)
|
||||
}
|
||||
continue
|
||||
case "allprop":
|
||||
propstats, err = allprop(ctx, fs, ls, op.name, op.pnames)
|
||||
case "propfind":
|
||||
propstats, err = props(ctx, fs, ls, op.name, op.pnames)
|
||||
case "proppatch":
|
||||
propstats, err = patch(ctx, fs, ls, op.name, op.patches)
|
||||
default:
|
||||
t.Fatalf("%s: %s not implemented", desc, op.op)
|
||||
}
|
||||
if err != nil {
|
||||
t.Errorf("%s: got error %v, want nil", desc, err)
|
||||
continue
|
||||
}
|
||||
// Compare return values from allprop, propfind or proppatch.
|
||||
for _, pst := range propstats {
|
||||
sort.Sort(byPropname(pst.Props))
|
||||
}
|
||||
for _, pst := range op.wantPropstats {
|
||||
sort.Sort(byPropname(pst.Props))
|
||||
}
|
||||
sort.Sort(byStatus(propstats))
|
||||
sort.Sort(byStatus(op.wantPropstats))
|
||||
if !reflect.DeepEqual(propstats, op.wantPropstats) {
|
||||
t.Errorf("%s: propstat\ngot %q\nwant %q", desc, propstats, op.wantPropstats)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func cmpXMLName(a, b xml.Name) bool {
|
||||
if a.Space != b.Space {
|
||||
return a.Space < b.Space
|
||||
}
|
||||
return a.Local < b.Local
|
||||
}
|
||||
|
||||
type byXMLName []xml.Name
|
||||
|
||||
func (b byXMLName) Len() int { return len(b) }
|
||||
func (b byXMLName) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
|
||||
func (b byXMLName) Less(i, j int) bool { return cmpXMLName(b[i], b[j]) }
|
||||
|
||||
type byPropname []Property
|
||||
|
||||
func (b byPropname) Len() int { return len(b) }
|
||||
func (b byPropname) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
|
||||
func (b byPropname) Less(i, j int) bool { return cmpXMLName(b[i].XMLName, b[j].XMLName) }
|
||||
|
||||
type byStatus []Propstat
|
||||
|
||||
func (b byStatus) Len() int { return len(b) }
|
||||
func (b byStatus) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
|
||||
func (b byStatus) Less(i, j int) bool { return b[i].Status < b[j].Status }
|
||||
|
||||
type noDeadPropsFS struct {
|
||||
FileSystem
|
||||
}
|
||||
|
||||
func (fs noDeadPropsFS) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
|
||||
f, err := fs.FileSystem.OpenFile(ctx, name, flag, perm)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return noDeadPropsFile{f}, nil
|
||||
}
|
||||
|
||||
// noDeadPropsFile wraps a File but strips any optional DeadPropsHolder methods
|
||||
// provided by the underlying File implementation.
|
||||
type noDeadPropsFile struct {
|
||||
f File
|
||||
}
|
||||
|
||||
func (f noDeadPropsFile) Close() error { return f.f.Close() }
|
||||
func (f noDeadPropsFile) Read(p []byte) (int, error) { return f.f.Read(p) }
|
||||
func (f noDeadPropsFile) Readdir(count int) ([]os.FileInfo, error) { return f.f.Readdir(count) }
|
||||
func (f noDeadPropsFile) Seek(off int64, whence int) (int64, error) { return f.f.Seek(off, whence) }
|
||||
func (f noDeadPropsFile) Stat() (os.FileInfo, error) { return f.f.Stat() }
|
||||
func (f noDeadPropsFile) Write(p []byte) (int, error) { return f.f.Write(p) }
|
702
webdav.go
Normal file
702
webdav.go
Normal file
@ -0,0 +1,702 @@
|
||||
// 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 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 := getContext(r)
|
||||
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 := getContext(r)
|
||||
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 := getContext(r)
|
||||
|
||||
// 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 := getContext(r)
|
||||
|
||||
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 := getContext(r)
|
||||
|
||||
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 := getContext(r)
|
||||
|
||||
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 := getContext(r)
|
||||
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 := getContext(r)
|
||||
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
|
||||
}
|
||||
return mw.write(makePropstatResponse(path.Join(h.Prefix, reqPath), 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 := getContext(r)
|
||||
|
||||
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")
|
||||
)
|
344
webdav_test.go
Normal file
344
webdav_test.go
Normal file
@ -0,0 +1,344 @@
|
||||
// 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 webdav
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"golang.org/x/net/context"
|
||||
)
|
||||
|
||||
// TODO: add tests to check XML responses with the expected prefix path
|
||||
func TestPrefix(t *testing.T) {
|
||||
const dst, blah = "Destination", "blah blah blah"
|
||||
|
||||
// createLockBody comes from the example in Section 9.10.7.
|
||||
const createLockBody = `<?xml version="1.0" encoding="utf-8" ?>
|
||||
<D:lockinfo xmlns:D='DAV:'>
|
||||
<D:lockscope><D:exclusive/></D:lockscope>
|
||||
<D:locktype><D:write/></D:locktype>
|
||||
<D:owner>
|
||||
<D:href>http://example.org/~ejw/contact.html</D:href>
|
||||
</D:owner>
|
||||
</D:lockinfo>
|
||||
`
|
||||
|
||||
do := func(method, urlStr string, body string, wantStatusCode int, headers ...string) (http.Header, error) {
|
||||
var bodyReader io.Reader
|
||||
if body != "" {
|
||||
bodyReader = strings.NewReader(body)
|
||||
}
|
||||
req, err := http.NewRequest(method, urlStr, bodyReader)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for len(headers) >= 2 {
|
||||
req.Header.Add(headers[0], headers[1])
|
||||
headers = headers[2:]
|
||||
}
|
||||
res, err := http.DefaultTransport.RoundTrip(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer res.Body.Close()
|
||||
if res.StatusCode != wantStatusCode {
|
||||
return nil, fmt.Errorf("got status code %d, want %d", res.StatusCode, wantStatusCode)
|
||||
}
|
||||
return res.Header, nil
|
||||
}
|
||||
|
||||
prefixes := []string{
|
||||
"/",
|
||||
"/a/",
|
||||
"/a/b/",
|
||||
"/a/b/c/",
|
||||
}
|
||||
ctx := context.Background()
|
||||
for _, prefix := range prefixes {
|
||||
fs := NewMemFS()
|
||||
h := &Handler{
|
||||
FileSystem: fs,
|
||||
LockSystem: NewMemLS(),
|
||||
}
|
||||
mux := http.NewServeMux()
|
||||
if prefix != "/" {
|
||||
h.Prefix = prefix
|
||||
}
|
||||
mux.Handle(prefix, h)
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
// The script is:
|
||||
// MKCOL /a
|
||||
// MKCOL /a/b
|
||||
// PUT /a/b/c
|
||||
// COPY /a/b/c /a/b/d
|
||||
// MKCOL /a/b/e
|
||||
// MOVE /a/b/d /a/b/e/f
|
||||
// LOCK /a/b/e/g
|
||||
// PUT /a/b/e/g
|
||||
// which should yield the (possibly stripped) filenames /a/b/c,
|
||||
// /a/b/e/f and /a/b/e/g, plus their parent directories.
|
||||
|
||||
wantA := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusMovedPermanently,
|
||||
"/a/b/": http.StatusNotFound,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a", "", wantA); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantB := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusMovedPermanently,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a/b", "", wantB); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a/b: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantC := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusMovedPermanently,
|
||||
}[prefix]
|
||||
if _, err := do("PUT", srv.URL+"/a/b/c", blah, wantC); err != nil {
|
||||
t.Errorf("prefix=%-9q PUT /a/b/c: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantD := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusMovedPermanently,
|
||||
}[prefix]
|
||||
if _, err := do("COPY", srv.URL+"/a/b/c", "", wantD, dst, srv.URL+"/a/b/d"); err != nil {
|
||||
t.Errorf("prefix=%-9q COPY /a/b/c /a/b/d: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantE := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a/b/e", "", wantE); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a/b/e: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantF := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MOVE", srv.URL+"/a/b/d", "", wantF, dst, srv.URL+"/a/b/e/f"); err != nil {
|
||||
t.Errorf("prefix=%-9q MOVE /a/b/d /a/b/e/f: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
var lockToken string
|
||||
wantG := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if h, err := do("LOCK", srv.URL+"/a/b/e/g", createLockBody, wantG); err != nil {
|
||||
t.Errorf("prefix=%-9q LOCK /a/b/e/g: %v", prefix, err)
|
||||
continue
|
||||
} else {
|
||||
lockToken = h.Get("Lock-Token")
|
||||
}
|
||||
|
||||
ifHeader := fmt.Sprintf("<%s/a/b/e/g> (%s)", srv.URL, lockToken)
|
||||
wantH := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("PUT", srv.URL+"/a/b/e/g", blah, wantH, "If", ifHeader); err != nil {
|
||||
t.Errorf("prefix=%-9q PUT /a/b/e/g: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
got, err := find(ctx, nil, fs, "/")
|
||||
if err != nil {
|
||||
t.Errorf("prefix=%-9q find: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
sort.Strings(got)
|
||||
want := map[string][]string{
|
||||
"/": {"/", "/a", "/a/b", "/a/b/c", "/a/b/e", "/a/b/e/f", "/a/b/e/g"},
|
||||
"/a/": {"/", "/b", "/b/c", "/b/e", "/b/e/f", "/b/e/g"},
|
||||
"/a/b/": {"/", "/c", "/e", "/e/f", "/e/g"},
|
||||
"/a/b/c/": {"/"},
|
||||
}[prefix]
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("prefix=%-9q find:\ngot %v\nwant %v", prefix, got, want)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEscapeXML(t *testing.T) {
|
||||
// These test cases aren't exhaustive, and there is more than one way to
|
||||
// escape e.g. a quot (as """ or """) or an apos. We presume that
|
||||
// the encoding/xml package tests xml.EscapeText more thoroughly. This test
|
||||
// here is just a sanity check for this package's escapeXML function, and
|
||||
// its attempt to provide a fast path (and avoid a bytes.Buffer allocation)
|
||||
// when escaping filenames is obviously a no-op.
|
||||
testCases := map[string]string{
|
||||
"": "",
|
||||
" ": " ",
|
||||
"&": "&",
|
||||
"*": "*",
|
||||
"+": "+",
|
||||
",": ",",
|
||||
"-": "-",
|
||||
".": ".",
|
||||
"/": "/",
|
||||
"0": "0",
|
||||
"9": "9",
|
||||
":": ":",
|
||||
"<": "<",
|
||||
">": ">",
|
||||
"A": "A",
|
||||
"_": "_",
|
||||
"a": "a",
|
||||
"~": "~",
|
||||
"\u0201": "\u0201",
|
||||
"&": "&amp;",
|
||||
"foo&<b/ar>baz": "foo&<b/ar>baz",
|
||||
}
|
||||
|
||||
for in, want := range testCases {
|
||||
if got := escapeXML(in); got != want {
|
||||
t.Errorf("in=%q: got %q, want %q", in, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFilenameEscape(t *testing.T) {
|
||||
hrefRe := regexp.MustCompile(`<href xmlns="DAV:">([^<]*)</href>`)
|
||||
displayNameRe := regexp.MustCompile(`<D:displayname>([^<]*)</D:displayname>`)
|
||||
do := func(method, urlStr string) (string, string, error) {
|
||||
req, err := http.NewRequest(method, urlStr, nil)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
res, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
defer res.Body.Close()
|
||||
|
||||
b, err := ioutil.ReadAll(res.Body)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
hrefMatch := hrefRe.FindStringSubmatch(string(b))
|
||||
if len(hrefMatch) != 2 {
|
||||
return "", "", errors.New("D:href not found")
|
||||
}
|
||||
displayNameMatch := displayNameRe.FindStringSubmatch(string(b))
|
||||
if len(displayNameMatch) != 2 {
|
||||
return "", "", errors.New("D:displayname not found")
|
||||
}
|
||||
|
||||
return hrefMatch[1], displayNameMatch[1], nil
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
name, wantHref, wantDisplayName string
|
||||
}{{
|
||||
name: `/foo%bar`,
|
||||
wantHref: `/foo%25bar`,
|
||||
wantDisplayName: `foo%bar`,
|
||||
}, {
|
||||
name: `/こんにちわ世界`,
|
||||
wantHref: `/%E3%81%93%E3%82%93%E3%81%AB%E3%81%A1%E3%82%8F%E4%B8%96%E7%95%8C`,
|
||||
wantDisplayName: `こんにちわ世界`,
|
||||
}, {
|
||||
name: `/Program Files/`,
|
||||
wantHref: `/Program%20Files`,
|
||||
wantDisplayName: `Program Files`,
|
||||
}, {
|
||||
name: `/go+lang`,
|
||||
wantHref: `/go+lang`,
|
||||
wantDisplayName: `go+lang`,
|
||||
}, {
|
||||
name: `/go&lang`,
|
||||
wantHref: `/go&lang`,
|
||||
wantDisplayName: `go&lang`,
|
||||
}, {
|
||||
name: `/go<lang`,
|
||||
wantHref: `/go%3Clang`,
|
||||
wantDisplayName: `go<lang`,
|
||||
}}
|
||||
ctx := context.Background()
|
||||
fs := NewMemFS()
|
||||
for _, tc := range testCases {
|
||||
if strings.HasSuffix(tc.name, "/") {
|
||||
if err := fs.Mkdir(ctx, tc.name, 0755); err != nil {
|
||||
t.Fatalf("name=%q: Mkdir: %v", tc.name, err)
|
||||
}
|
||||
} else {
|
||||
f, err := fs.OpenFile(ctx, tc.name, os.O_CREATE, 0644)
|
||||
if err != nil {
|
||||
t.Fatalf("name=%q: OpenFile: %v", tc.name, err)
|
||||
}
|
||||
f.Close()
|
||||
}
|
||||
}
|
||||
|
||||
srv := httptest.NewServer(&Handler{
|
||||
FileSystem: fs,
|
||||
LockSystem: NewMemLS(),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
u, err := url.Parse(srv.URL)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
u.Path = tc.name
|
||||
gotHref, gotDisplayName, err := do("PROPFIND", u.String())
|
||||
if err != nil {
|
||||
t.Errorf("name=%q: PROPFIND: %v", tc.name, err)
|
||||
continue
|
||||
}
|
||||
if gotHref != tc.wantHref {
|
||||
t.Errorf("name=%q: got href %q, want %q", tc.name, gotHref, tc.wantHref)
|
||||
}
|
||||
if gotDisplayName != tc.wantDisplayName {
|
||||
t.Errorf("name=%q: got dispayname %q, want %q", tc.name, gotDisplayName, tc.wantDisplayName)
|
||||
}
|
||||
}
|
||||
}
|
483
xml.go
Normal file
483
xml.go
Normal file
@ -0,0 +1,483 @@
|
||||
// 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
|
||||
|
||||
// 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"
|
||||
)
|
||||
|
||||
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_lockinfo
|
||||
type lockInfo struct {
|
||||
XMLName xml.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 = xml.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)
|
||||
xml.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 *xml.Decoder) (xml.Token, error) {
|
||||
for {
|
||||
t, err := d.Token()
|
||||
if err != nil {
|
||||
return t, err
|
||||
}
|
||||
switch t.(type) {
|
||||
case xml.Comment, xml.Directive, xml.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 *xml.Decoder, start xml.StartElement) error {
|
||||
for {
|
||||
t, err := next(d)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch t.(type) {
|
||||
case xml.EndElement:
|
||||
if len(*pn) == 0 {
|
||||
return fmt.Errorf("%s must not be empty", start.Name.Local)
|
||||
}
|
||||
return nil
|
||||
case xml.StartElement:
|
||||
name := t.(xml.StartElement).Name
|
||||
t, err = next(d)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, ok := t.(xml.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 xml.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 = xml.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"`
|
||||
}
|
||||
|
||||
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_error
|
||||
// See multistatusWriter for the "D:" namespace prefix.
|
||||
type xmlError struct {
|
||||
XMLName xml.Name `xml:"DAV: 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:"DAV: prop>_ignored_"`
|
||||
Status string `xml:"DAV: status"`
|
||||
Error *xmlError `xml:"DAV: error"`
|
||||
ResponseDescription string `xml:"DAV: responsedescription,omitempty"`
|
||||
}
|
||||
|
||||
// MarshalXML prepends the "D:" namespace prefix on properties in the DAV: namespace
|
||||
// before encoding. See multistatusWriter.
|
||||
func (ps propstat) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
// Convert from a propstat to an propstat.
|
||||
xmlPs := propstat{
|
||||
Prop: make([]Property, len(ps.Prop)),
|
||||
Status: ps.Status,
|
||||
Error: ps.Error,
|
||||
ResponseDescription: ps.ResponseDescription,
|
||||
}
|
||||
for k, prop := range ps.Prop {
|
||||
xmlPs.Prop[k] = Property{
|
||||
XMLName: xml.Name(prop.XMLName),
|
||||
Lang: prop.Lang,
|
||||
InnerXML: prop.InnerXML,
|
||||
}
|
||||
}
|
||||
|
||||
for k, prop := range xmlPs.Prop {
|
||||
if prop.XMLName.Space == "DAV:" {
|
||||
prop.XMLName = xml.Name{Space: "", Local: "D:" + prop.XMLName.Local}
|
||||
xmlPs.Prop[k] = prop
|
||||
}
|
||||
}
|
||||
// Distinct type to avoid infinite recursion of MarshalXML.
|
||||
type newpropstat propstat
|
||||
return e.EncodeElement(newpropstat(xmlPs), start)
|
||||
}
|
||||
|
||||
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
|
||||
// See multistatusWriter for the "D:" namespace prefix.
|
||||
type response struct {
|
||||
XMLName xml.Name `xml:"DAV: response"`
|
||||
Href []string `xml:"DAV: href"`
|
||||
Propstat []propstat `xml:"DAV: propstat"`
|
||||
Status string `xml:"DAV: status,omitempty"`
|
||||
Error *xmlError `xml:"DAV: error"`
|
||||
ResponseDescription string `xml:"DAV: 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 *xml.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.Header)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
w.enc = xml.NewEncoder(w.w)
|
||||
return w.enc.EncodeToken(xml.StartElement{
|
||||
Name: xml.Name{
|
||||
Space: "DAV:",
|
||||
Local: "multistatus",
|
||||
},
|
||||
Attr: []xml.Attr{{
|
||||
Name: xml.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 []xml.Token
|
||||
if w.responseDescription != "" {
|
||||
name := xml.Name{Space: "DAV:", Local: "responsedescription"}
|
||||
end = append(end,
|
||||
xml.StartElement{Name: name},
|
||||
xml.CharData(w.responseDescription),
|
||||
xml.EndElement{Name: name},
|
||||
)
|
||||
}
|
||||
end = append(end, xml.EndElement{
|
||||
Name: xml.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 = xml.Name{Space: "http://www.w3.org/XML/1998/namespace", Local: "lang"}
|
||||
|
||||
func xmlLang(s xml.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 *xml.Decoder, start xml.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 := xml.NewEncoder(&b)
|
||||
for {
|
||||
t, err := next(d)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if e, ok := t.(xml.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 *xml.Decoder, start xml.StartElement) error {
|
||||
lang := xmlLang(start, "")
|
||||
for {
|
||||
t, err := next(d)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
switch elem := t.(type) {
|
||||
case xml.EndElement:
|
||||
if len(*ps) == 0 {
|
||||
return fmt.Errorf("%s must not be empty", start.Name.Local)
|
||||
}
|
||||
return nil
|
||||
case xml.StartElement:
|
||||
p := Property{
|
||||
XMLName: xml.Name(t.(xml.StartElement).Name),
|
||||
Lang: xmlLang(t.(xml.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 xml.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 xml.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 = xml.NewDecoder(r).Decode(&pu); err != nil {
|
||||
return nil, http.StatusBadRequest, err
|
||||
}
|
||||
for _, op := range pu.SetRemove {
|
||||
remove := false
|
||||
switch op.XMLName {
|
||||
case xml.Name{Space: "DAV:", Local: "set"}:
|
||||
// No-op.
|
||||
case xml.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
|
||||
}
|
904
xml_test.go
Normal file
904
xml_test.go
Normal file
@ -0,0 +1,904 @@
|
||||
// Copyright 2014 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package webdav
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestReadLockInfo(t *testing.T) {
|
||||
// The "section x.y.z" test cases come from section x.y.z of the spec at
|
||||
// http://www.webdav.org/specs/rfc4918.html
|
||||
testCases := []struct {
|
||||
desc string
|
||||
input string
|
||||
wantLI lockInfo
|
||||
wantStatus int
|
||||
}{{
|
||||
"bad: junk",
|
||||
"xxx",
|
||||
lockInfo{},
|
||||
http.StatusBadRequest,
|
||||
}, {
|
||||
"bad: invalid owner XML",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n" +
|
||||
" <D:owner>\n" +
|
||||
" <D:href> no end tag \n" +
|
||||
" </D:owner>\n" +
|
||||
"</D:lockinfo>",
|
||||
lockInfo{},
|
||||
http.StatusBadRequest,
|
||||
}, {
|
||||
"bad: invalid UTF-8",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n" +
|
||||
" <D:owner>\n" +
|
||||
" <D:href> \xff </D:href>\n" +
|
||||
" </D:owner>\n" +
|
||||
"</D:lockinfo>",
|
||||
lockInfo{},
|
||||
http.StatusBadRequest,
|
||||
}, {
|
||||
"bad: unfinished XML #1",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n",
|
||||
lockInfo{},
|
||||
http.StatusBadRequest,
|
||||
}, {
|
||||
"bad: unfinished XML #2",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n" +
|
||||
" <D:owner>\n",
|
||||
lockInfo{},
|
||||
http.StatusBadRequest,
|
||||
}, {
|
||||
"good: empty",
|
||||
"",
|
||||
lockInfo{},
|
||||
0,
|
||||
}, {
|
||||
"good: plain-text owner",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n" +
|
||||
" <D:owner>gopher</D:owner>\n" +
|
||||
"</D:lockinfo>",
|
||||
lockInfo{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "lockinfo"},
|
||||
Exclusive: new(struct{}),
|
||||
Write: new(struct{}),
|
||||
Owner: owner{
|
||||
InnerXML: "gopher",
|
||||
},
|
||||
},
|
||||
0,
|
||||
}, {
|
||||
"section 9.10.7",
|
||||
"" +
|
||||
"<D:lockinfo xmlns:D='DAV:'>\n" +
|
||||
" <D:lockscope><D:exclusive/></D:lockscope>\n" +
|
||||
" <D:locktype><D:write/></D:locktype>\n" +
|
||||
" <D:owner>\n" +
|
||||
" <D:href>http://example.org/~ejw/contact.html</D:href>\n" +
|
||||
" </D:owner>\n" +
|
||||
"</D:lockinfo>",
|
||||
lockInfo{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "lockinfo"},
|
||||
Exclusive: new(struct{}),
|
||||
Write: new(struct{}),
|
||||
Owner: owner{
|
||||
InnerXML: "\n <D:href>http://example.org/~ejw/contact.html</D:href>\n ",
|
||||
},
|
||||
},
|
||||
0,
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
li, status, err := readLockInfo(strings.NewReader(tc.input))
|
||||
if tc.wantStatus != 0 {
|
||||
if err == nil {
|
||||
t.Errorf("%s: got nil error, want non-nil", tc.desc)
|
||||
continue
|
||||
}
|
||||
} else if err != nil {
|
||||
t.Errorf("%s: %v", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(li, tc.wantLI) || status != tc.wantStatus {
|
||||
t.Errorf("%s:\ngot lockInfo=%v, status=%v\nwant lockInfo=%v, status=%v",
|
||||
tc.desc, li, status, tc.wantLI, tc.wantStatus)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadPropfind(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
input string
|
||||
wantPF propfind
|
||||
wantStatus int
|
||||
}{{
|
||||
desc: "propfind: propname",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:propname/>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Propname: new(struct{}),
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: empty body means allprop",
|
||||
input: "",
|
||||
wantPF: propfind{
|
||||
Allprop: new(struct{}),
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: allprop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:allprop/>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Allprop: new(struct{}),
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: allprop followed by include",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:allprop/>\n" +
|
||||
" <A:include><A:displayname/></A:include>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Allprop: new(struct{}),
|
||||
Include: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: include followed by allprop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:include><A:displayname/></A:include>\n" +
|
||||
" <A:allprop/>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Allprop: new(struct{}),
|
||||
Include: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: propfind",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:displayname/></A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: prop with ignored comments",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop>\n" +
|
||||
" <!-- ignore -->\n" +
|
||||
" <A:displayname><!-- ignore --></A:displayname>\n" +
|
||||
" </A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: propfind with ignored whitespace",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop> <A:displayname/></A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: propfind with ignored mixed-content",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop>foo<A:displayname/>bar</A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: propname with ignored element (section A.4)",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:propname/>\n" +
|
||||
" <E:leave-out xmlns:E='E:'>*boss*</E:leave-out>\n" +
|
||||
"</A:propfind>",
|
||||
wantPF: propfind{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
|
||||
Propname: new(struct{}),
|
||||
},
|
||||
}, {
|
||||
desc: "propfind: bad: junk",
|
||||
input: "xxx",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: propname and allprop (section A.3)",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:propname/>" +
|
||||
" <A:allprop/>" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: propname and prop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:displayname/></A:prop>\n" +
|
||||
" <A:propname/>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: allprop and prop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:allprop/>\n" +
|
||||
" <A:prop><A:foo/><A:/prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: empty propfind with ignored element (section A.4)",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <E:expired-props/>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: empty prop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop/>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: prop with just chardata",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop>foo</A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "bad: interrupted prop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:foo></A:prop>\n",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "bad: malformed end element prop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:foo/></A:bar></A:prop>\n",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: property with chardata value",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:foo>bar</A:foo></A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: property with whitespace value",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:prop><A:foo> </A:foo></A:prop>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "propfind: bad: include without allprop",
|
||||
input: "" +
|
||||
"<A:propfind xmlns:A='DAV:'>\n" +
|
||||
" <A:include><A:foo/></A:include>\n" +
|
||||
"</A:propfind>",
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
pf, status, err := readPropfind(strings.NewReader(tc.input))
|
||||
if tc.wantStatus != 0 {
|
||||
if err == nil {
|
||||
t.Errorf("%s: got nil error, want non-nil", tc.desc)
|
||||
continue
|
||||
}
|
||||
} else if err != nil {
|
||||
t.Errorf("%s: %v", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(pf, tc.wantPF) || status != tc.wantStatus {
|
||||
t.Errorf("%s:\ngot propfind=%v, status=%v\nwant propfind=%v, status=%v",
|
||||
tc.desc, pf, status, tc.wantPF, tc.wantStatus)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultistatusWriter(t *testing.T) {
|
||||
///The "section x.y.z" test cases come from section x.y.z of the spec at
|
||||
// http://www.webdav.org/specs/rfc4918.html
|
||||
testCases := []struct {
|
||||
desc string
|
||||
responses []response
|
||||
respdesc string
|
||||
writeHeader bool
|
||||
wantXML string
|
||||
wantCode int
|
||||
wantErr error
|
||||
}{{
|
||||
desc: "section 9.2.2 (failed dependency)",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo"},
|
||||
Propstat: []propstat{{
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{
|
||||
Space: "http://ns.example.com/",
|
||||
Local: "Authors",
|
||||
},
|
||||
}},
|
||||
Status: "HTTP/1.1 424 Failed Dependency",
|
||||
}, {
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{
|
||||
Space: "http://ns.example.com/",
|
||||
Local: "Copyright-Owner",
|
||||
},
|
||||
}},
|
||||
Status: "HTTP/1.1 409 Conflict",
|
||||
}},
|
||||
ResponseDescription: "Copyright Owner cannot be deleted or altered.",
|
||||
}},
|
||||
wantXML: `` +
|
||||
`<?xml version="1.0" encoding="UTF-8"?>` +
|
||||
`<multistatus xmlns="DAV:">` +
|
||||
` <response>` +
|
||||
` <href>http://example.com/foo</href>` +
|
||||
` <propstat>` +
|
||||
` <prop>` +
|
||||
` <Authors xmlns="http://ns.example.com/"></Authors>` +
|
||||
` </prop>` +
|
||||
` <status>HTTP/1.1 424 Failed Dependency</status>` +
|
||||
` </propstat>` +
|
||||
` <propstat xmlns="DAV:">` +
|
||||
` <prop>` +
|
||||
` <Copyright-Owner xmlns="http://ns.example.com/"></Copyright-Owner>` +
|
||||
` </prop>` +
|
||||
` <status>HTTP/1.1 409 Conflict</status>` +
|
||||
` </propstat>` +
|
||||
` <responsedescription>Copyright Owner cannot be deleted or altered.</responsedescription>` +
|
||||
`</response>` +
|
||||
`</multistatus>`,
|
||||
wantCode: StatusMulti,
|
||||
}, {
|
||||
desc: "section 9.6.2 (lock-token-submitted)",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo"},
|
||||
Status: "HTTP/1.1 423 Locked",
|
||||
Error: &xmlError{
|
||||
InnerXML: []byte(`<lock-token-submitted xmlns="DAV:"/>`),
|
||||
},
|
||||
}},
|
||||
wantXML: `` +
|
||||
`<?xml version="1.0" encoding="UTF-8"?>` +
|
||||
`<multistatus xmlns="DAV:">` +
|
||||
` <response>` +
|
||||
` <href>http://example.com/foo</href>` +
|
||||
` <status>HTTP/1.1 423 Locked</status>` +
|
||||
` <error><lock-token-submitted xmlns="DAV:"/></error>` +
|
||||
` </response>` +
|
||||
`</multistatus>`,
|
||||
wantCode: StatusMulti,
|
||||
}, {
|
||||
desc: "section 9.1.3",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo"},
|
||||
Propstat: []propstat{{
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{Space: "http://ns.example.com/boxschema/", Local: "bigbox"},
|
||||
InnerXML: []byte(`` +
|
||||
`<BoxType xmlns="http://ns.example.com/boxschema/">` +
|
||||
`Box type A` +
|
||||
`</BoxType>`),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "http://ns.example.com/boxschema/", Local: "author"},
|
||||
InnerXML: []byte(`` +
|
||||
`<Name xmlns="http://ns.example.com/boxschema/">` +
|
||||
`J.J. Johnson` +
|
||||
`</Name>`),
|
||||
}},
|
||||
Status: "HTTP/1.1 200 OK",
|
||||
}, {
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{Space: "http://ns.example.com/boxschema/", Local: "DingALing"},
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "http://ns.example.com/boxschema/", Local: "Random"},
|
||||
}},
|
||||
Status: "HTTP/1.1 403 Forbidden",
|
||||
ResponseDescription: "The user does not have access to the DingALing property.",
|
||||
}},
|
||||
}},
|
||||
respdesc: "There has been an access violation error.",
|
||||
wantXML: `` +
|
||||
`<?xml version="1.0" encoding="UTF-8"?>` +
|
||||
`<multistatus xmlns="DAV:" xmlns:B="http://ns.example.com/boxschema/">` +
|
||||
` <response>` +
|
||||
` <href>http://example.com/foo</href>` +
|
||||
` <propstat>` +
|
||||
` <prop>` +
|
||||
` <B:bigbox><B:BoxType>Box type A</B:BoxType></B:bigbox>` +
|
||||
` <B:author><B:Name>J.J. Johnson</B:Name></B:author>` +
|
||||
` </prop>` +
|
||||
` <status>HTTP/1.1 200 OK</status>` +
|
||||
` </propstat>` +
|
||||
` <propstat>` +
|
||||
` <prop>` +
|
||||
` <B:DingALing/>` +
|
||||
` <B:Random/>` +
|
||||
` </prop>` +
|
||||
` <status>HTTP/1.1 403 Forbidden</status>` +
|
||||
` <responsedescription>The user does not have access to the DingALing property.</responsedescription>` +
|
||||
` </propstat>` +
|
||||
` </response>` +
|
||||
` <responsedescription>There has been an access violation error.</responsedescription>` +
|
||||
`</multistatus>`,
|
||||
wantCode: StatusMulti,
|
||||
}, {
|
||||
desc: "no response written",
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "no response written (with description)",
|
||||
respdesc: "too bad",
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "empty multistatus with header",
|
||||
writeHeader: true,
|
||||
wantXML: `<multistatus xmlns="DAV:"></multistatus>`,
|
||||
wantCode: StatusMulti,
|
||||
}, {
|
||||
desc: "bad: no href",
|
||||
responses: []response{{
|
||||
Propstat: []propstat{{
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{
|
||||
Space: "http://example.com/",
|
||||
Local: "foo",
|
||||
},
|
||||
}},
|
||||
Status: "HTTP/1.1 200 OK",
|
||||
}},
|
||||
}},
|
||||
wantErr: errInvalidResponse,
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "bad: multiple hrefs and no status",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo", "http://example.com/bar"},
|
||||
}},
|
||||
wantErr: errInvalidResponse,
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "bad: one href and no propstat",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo"},
|
||||
}},
|
||||
wantErr: errInvalidResponse,
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "bad: status with one href and propstat",
|
||||
responses: []response{{
|
||||
Href: []string{"http://example.com/foo"},
|
||||
Propstat: []propstat{{
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{
|
||||
Space: "http://example.com/",
|
||||
Local: "foo",
|
||||
},
|
||||
}},
|
||||
Status: "HTTP/1.1 200 OK",
|
||||
}},
|
||||
Status: "HTTP/1.1 200 OK",
|
||||
}},
|
||||
wantErr: errInvalidResponse,
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}, {
|
||||
desc: "bad: multiple hrefs and propstat",
|
||||
responses: []response{{
|
||||
Href: []string{
|
||||
"http://example.com/foo",
|
||||
"http://example.com/bar",
|
||||
},
|
||||
Propstat: []propstat{{
|
||||
Prop: []Property{{
|
||||
XMLName: xml.Name{
|
||||
Space: "http://example.com/",
|
||||
Local: "foo",
|
||||
},
|
||||
}},
|
||||
Status: "HTTP/1.1 200 OK",
|
||||
}},
|
||||
}},
|
||||
wantErr: errInvalidResponse,
|
||||
// default of http.responseWriter
|
||||
wantCode: http.StatusOK,
|
||||
}}
|
||||
|
||||
n := xmlNormalizer{omitWhitespace: true}
|
||||
loop:
|
||||
for _, tc := range testCases {
|
||||
rec := httptest.NewRecorder()
|
||||
w := multistatusWriter{w: rec, responseDescription: tc.respdesc}
|
||||
if tc.writeHeader {
|
||||
if err := w.writeHeader(); err != nil {
|
||||
t.Errorf("%s: got writeHeader error %v, want nil", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
}
|
||||
for _, r := range tc.responses {
|
||||
if err := w.write(&r); err != nil {
|
||||
if err != tc.wantErr {
|
||||
t.Errorf("%s: got write error %v, want %v",
|
||||
tc.desc, err, tc.wantErr)
|
||||
}
|
||||
continue loop
|
||||
}
|
||||
}
|
||||
if err := w.close(); err != tc.wantErr {
|
||||
t.Errorf("%s: got close error %v, want %v",
|
||||
tc.desc, err, tc.wantErr)
|
||||
continue
|
||||
}
|
||||
if rec.Code != tc.wantCode {
|
||||
t.Errorf("%s: got HTTP status code %d, want %d\n",
|
||||
tc.desc, rec.Code, tc.wantCode)
|
||||
continue
|
||||
}
|
||||
gotXML := rec.Body.String()
|
||||
eq, err := n.equalXML(strings.NewReader(gotXML), strings.NewReader(tc.wantXML))
|
||||
if err != nil {
|
||||
t.Errorf("%s: equalXML: %v", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
if !eq {
|
||||
t.Errorf("%s: XML body\ngot %s\nwant %s", tc.desc, gotXML, tc.wantXML)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadProppatch(t *testing.T) {
|
||||
ppStr := func(pps []Proppatch) string {
|
||||
var outer []string
|
||||
for _, pp := range pps {
|
||||
var inner []string
|
||||
for _, p := range pp.Props {
|
||||
inner = append(inner, fmt.Sprintf("{XMLName: %q, Lang: %q, InnerXML: %q}",
|
||||
p.XMLName, p.Lang, p.InnerXML))
|
||||
}
|
||||
outer = append(outer, fmt.Sprintf("{Remove: %t, Props: [%s]}",
|
||||
pp.Remove, strings.Join(inner, ", ")))
|
||||
}
|
||||
return "[" + strings.Join(outer, ", ") + "]"
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
desc string
|
||||
input string
|
||||
wantPP []Proppatch
|
||||
wantStatus int
|
||||
}{{
|
||||
desc: "proppatch: section 9.2 (with simple property value)",
|
||||
input: `` +
|
||||
`<?xml version="1.0" encoding="utf-8" ?>` +
|
||||
`<D:propertyupdate xmlns:D="DAV:"` +
|
||||
` xmlns:Z="http://ns.example.com/z/">` +
|
||||
` <D:set>` +
|
||||
` <D:prop><Z:Authors>somevalue</Z:Authors></D:prop>` +
|
||||
` </D:set>` +
|
||||
` <D:remove>` +
|
||||
` <D:prop><Z:Copyright-Owner/></D:prop>` +
|
||||
` </D:remove>` +
|
||||
`</D:propertyupdate>`,
|
||||
wantPP: []Proppatch{{
|
||||
Props: []Property{{
|
||||
xml.Name{Space: "http://ns.example.com/z/", Local: "Authors"},
|
||||
"",
|
||||
[]byte(`somevalue`),
|
||||
}},
|
||||
}, {
|
||||
Remove: true,
|
||||
Props: []Property{{
|
||||
xml.Name{Space: "http://ns.example.com/z/", Local: "Copyright-Owner"},
|
||||
"",
|
||||
nil,
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "proppatch: lang attribute on prop",
|
||||
input: `` +
|
||||
`<?xml version="1.0" encoding="utf-8" ?>` +
|
||||
`<D:propertyupdate xmlns:D="DAV:">` +
|
||||
` <D:set>` +
|
||||
` <D:prop xml:lang="en">` +
|
||||
` <foo xmlns="http://example.com/ns"/>` +
|
||||
` </D:prop>` +
|
||||
` </D:set>` +
|
||||
`</D:propertyupdate>`,
|
||||
wantPP: []Proppatch{{
|
||||
Props: []Property{{
|
||||
xml.Name{Space: "http://example.com/ns", Local: "foo"},
|
||||
"en",
|
||||
nil,
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
desc: "bad: remove with value",
|
||||
input: `` +
|
||||
`<?xml version="1.0" encoding="utf-8" ?>` +
|
||||
`<D:propertyupdate xmlns:D="DAV:"` +
|
||||
` xmlns:Z="http://ns.example.com/z/">` +
|
||||
` <D:remove>` +
|
||||
` <D:prop>` +
|
||||
` <Z:Authors>` +
|
||||
` <Z:Author>Jim Whitehead</Z:Author>` +
|
||||
` </Z:Authors>` +
|
||||
` </D:prop>` +
|
||||
` </D:remove>` +
|
||||
`</D:propertyupdate>`,
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "bad: empty propertyupdate",
|
||||
input: `` +
|
||||
`<?xml version="1.0" encoding="utf-8" ?>` +
|
||||
`<D:propertyupdate xmlns:D="DAV:"` +
|
||||
`</D:propertyupdate>`,
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}, {
|
||||
desc: "bad: empty prop",
|
||||
input: `` +
|
||||
`<?xml version="1.0" encoding="utf-8" ?>` +
|
||||
`<D:propertyupdate xmlns:D="DAV:"` +
|
||||
` xmlns:Z="http://ns.example.com/z/">` +
|
||||
` <D:remove>` +
|
||||
` <D:prop/>` +
|
||||
` </D:remove>` +
|
||||
`</D:propertyupdate>`,
|
||||
wantStatus: http.StatusBadRequest,
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
pp, status, err := readProppatch(strings.NewReader(tc.input))
|
||||
if tc.wantStatus != 0 {
|
||||
if err == nil {
|
||||
t.Errorf("%s: got nil error, want non-nil", tc.desc)
|
||||
continue
|
||||
}
|
||||
} else if err != nil {
|
||||
t.Errorf("%s: %v", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
if status != tc.wantStatus {
|
||||
t.Errorf("%s: got status %d, want %d", tc.desc, status, tc.wantStatus)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(pp, tc.wantPP) || status != tc.wantStatus {
|
||||
t.Errorf("%s: proppatch\ngot %v\nwant %v", tc.desc, ppStr(pp), ppStr(tc.wantPP))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnmarshalXMLValue(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
input string
|
||||
wantVal string
|
||||
}{{
|
||||
desc: "simple char data",
|
||||
input: "<root>foo</root>",
|
||||
wantVal: "foo",
|
||||
}, {
|
||||
desc: "empty element",
|
||||
input: "<root><foo/></root>",
|
||||
wantVal: "<foo/>",
|
||||
}, {
|
||||
desc: "preserve namespace",
|
||||
input: `<root><foo xmlns="bar"/></root>`,
|
||||
wantVal: `<foo xmlns="bar"/>`,
|
||||
}, {
|
||||
desc: "preserve root element namespace",
|
||||
input: `<root xmlns:bar="bar"><bar:foo/></root>`,
|
||||
wantVal: `<foo xmlns="bar"/>`,
|
||||
}, {
|
||||
desc: "preserve whitespace",
|
||||
input: "<root> \t </root>",
|
||||
wantVal: " \t ",
|
||||
}, {
|
||||
desc: "preserve mixed content",
|
||||
input: `<root xmlns="bar"> <foo>a<bam xmlns="baz"/> </foo> </root>`,
|
||||
wantVal: ` <foo xmlns="bar">a<bam xmlns="baz"/> </foo> `,
|
||||
}, {
|
||||
desc: "section 9.2",
|
||||
input: `` +
|
||||
`<Z:Authors xmlns:Z="http://ns.example.com/z/">` +
|
||||
` <Z:Author>Jim Whitehead</Z:Author>` +
|
||||
` <Z:Author>Roy Fielding</Z:Author>` +
|
||||
`</Z:Authors>`,
|
||||
wantVal: `` +
|
||||
` <Author xmlns="http://ns.example.com/z/">Jim Whitehead</Author>` +
|
||||
` <Author xmlns="http://ns.example.com/z/">Roy Fielding</Author>`,
|
||||
}, {
|
||||
desc: "section 4.3.1 (mixed content)",
|
||||
input: `` +
|
||||
`<x:author ` +
|
||||
` xmlns:x='http://example.com/ns' ` +
|
||||
` xmlns:D="DAV:">` +
|
||||
` <x:name>Jane Doe</x:name>` +
|
||||
` <!-- Jane's contact info -->` +
|
||||
` <x:uri type='email'` +
|
||||
` added='2005-11-26'>mailto:jane.doe@example.com</x:uri>` +
|
||||
` <x:uri type='web'` +
|
||||
` added='2005-11-27'>http://www.example.com</x:uri>` +
|
||||
` <x:notes xmlns:h='http://www.w3.org/1999/xhtml'>` +
|
||||
` Jane has been working way <h:em>too</h:em> long on the` +
|
||||
` long-awaited revision of <![CDATA[<RFC2518>]]>.` +
|
||||
` </x:notes>` +
|
||||
`</x:author>`,
|
||||
wantVal: `` +
|
||||
` <name xmlns="http://example.com/ns">Jane Doe</name>` +
|
||||
` ` +
|
||||
` <uri type='email'` +
|
||||
` xmlns="http://example.com/ns" ` +
|
||||
` added='2005-11-26'>mailto:jane.doe@example.com</uri>` +
|
||||
` <uri added='2005-11-27'` +
|
||||
` type='web'` +
|
||||
` xmlns="http://example.com/ns">http://www.example.com</uri>` +
|
||||
` <notes xmlns="http://example.com/ns" ` +
|
||||
` xmlns:h="http://www.w3.org/1999/xhtml">` +
|
||||
` Jane has been working way <h:em>too</h:em> long on the` +
|
||||
` long-awaited revision of <RFC2518>.` +
|
||||
` </notes>`,
|
||||
}}
|
||||
|
||||
var n xmlNormalizer
|
||||
for _, tc := range testCases {
|
||||
d := xml.NewDecoder(strings.NewReader(tc.input))
|
||||
var v xmlValue
|
||||
if err := d.Decode(&v); err != nil {
|
||||
t.Errorf("%s: got error %v, want nil", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
eq, err := n.equalXML(bytes.NewReader(v), strings.NewReader(tc.wantVal))
|
||||
if err != nil {
|
||||
t.Errorf("%s: equalXML: %v", tc.desc, err)
|
||||
continue
|
||||
}
|
||||
if !eq {
|
||||
t.Errorf("%s:\ngot %s\nwant %s", tc.desc, string(v), tc.wantVal)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// xmlNormalizer normalizes XML.
|
||||
type xmlNormalizer struct {
|
||||
// omitWhitespace instructs to ignore whitespace between element tags.
|
||||
omitWhitespace bool
|
||||
// omitComments instructs to ignore XML comments.
|
||||
omitComments bool
|
||||
}
|
||||
|
||||
// normalize writes the normalized XML content of r to w. It applies the
|
||||
// following rules
|
||||
//
|
||||
// * Rename namespace prefixes according to an internal heuristic.
|
||||
// * Remove unnecessary namespace declarations.
|
||||
// * Sort attributes in XML start elements in lexical order of their
|
||||
// fully qualified name.
|
||||
// * Remove XML directives and processing instructions.
|
||||
// * Remove CDATA between XML tags that only contains whitespace, if
|
||||
// instructed to do so.
|
||||
// * Remove comments, if instructed to do so.
|
||||
//
|
||||
func (n *xmlNormalizer) normalize(w io.Writer, r io.Reader) error {
|
||||
d := xml.NewDecoder(r)
|
||||
e := xml.NewEncoder(w)
|
||||
for {
|
||||
t, err := d.Token()
|
||||
if err != nil {
|
||||
if t == nil && err == io.EOF {
|
||||
break
|
||||
}
|
||||
return err
|
||||
}
|
||||
switch val := t.(type) {
|
||||
case xml.Directive, xml.ProcInst:
|
||||
continue
|
||||
case xml.Comment:
|
||||
if n.omitComments {
|
||||
continue
|
||||
}
|
||||
case xml.CharData:
|
||||
if n.omitWhitespace && len(bytes.TrimSpace(val)) == 0 {
|
||||
continue
|
||||
}
|
||||
case xml.StartElement:
|
||||
start, _ := xml.CopyToken(val).(xml.StartElement)
|
||||
attr := start.Attr[:0]
|
||||
for _, a := range start.Attr {
|
||||
if a.Name.Space == "xmlns" || a.Name.Local == "xmlns" {
|
||||
continue
|
||||
}
|
||||
attr = append(attr, a)
|
||||
}
|
||||
sort.Sort(byName(attr))
|
||||
start.Attr = attr
|
||||
t = start
|
||||
}
|
||||
err = e.EncodeToken(t)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return e.Flush()
|
||||
}
|
||||
|
||||
// equalXML tests for equality of the normalized XML contents of a and b.
|
||||
func (n *xmlNormalizer) equalXML(a, b io.Reader) (bool, error) {
|
||||
var buf bytes.Buffer
|
||||
if err := n.normalize(&buf, a); err != nil {
|
||||
return false, err
|
||||
}
|
||||
normA := buf.String()
|
||||
buf.Reset()
|
||||
if err := n.normalize(&buf, b); err != nil {
|
||||
return false, err
|
||||
}
|
||||
normB := buf.String()
|
||||
return normA == normB, nil
|
||||
}
|
||||
|
||||
type byName []xml.Attr
|
||||
|
||||
func (a byName) Len() int { return len(a) }
|
||||
func (a byName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
||||
func (a byName) Less(i, j int) bool {
|
||||
if a[i].Name.Space != a[j].Name.Space {
|
||||
return a[i].Name.Space < a[j].Name.Space
|
||||
}
|
||||
return a[i].Name.Local < a[j].Name.Local
|
||||
}
|
Loading…
Reference in New Issue
Block a user