diff --git a/LICENSE b/LICENSE
index a27b2f8..2897a76 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,28 +1,21 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-Copyright (c) 2017 emersion
+The MIT License (MIT)
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
+Copyright (c) 2020 Simon Ser
- * 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.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
-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.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/carddav/backend.go b/carddav/backend.go
deleted file mode 100644
index f9ff3ef..0000000
--- a/carddav/backend.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package carddav
-
-// TODO: add context support
-
-import (
- "errors"
- "os"
-
- "github.com/emersion/go-vcard"
-)
-
-var (
- ErrNotFound = errors.New("carddav: not found")
-)
-
-type AddressBookInfo struct {
- Name string
- Description string
- MaxResourceSize int
-}
-
-type AddressObject interface {
- ID() string
- Stat() (os.FileInfo, error) // can return nil, nil
- Card() (vcard.Card, error)
- SetCard(vcard.Card) error
- Remove() error
-}
-
-type AddressBook interface {
- Info() (*AddressBookInfo, error)
- GetAddressObject(id string) (AddressObject, error)
- ListAddressObjects() ([]AddressObject, error)
- CreateAddressObject(vcard.Card) (AddressObject, error)
-}
diff --git a/carddav/carddav.go b/carddav/carddav.go
deleted file mode 100644
index b69d8a3..0000000
--- a/carddav/carddav.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// Package carddav provides a CardDAV server implementation, as defined in
-// RFC 6352.
-package carddav
-
-import (
- "bytes"
- "encoding/xml"
- "net/http"
- "net/url"
- "os"
-
- "github.com/emersion/go-vcard"
- "github.com/emersion/go-webdav"
- "golang.org/x/net/context"
-
- "log"
-)
-
-var addressDataName = xml.Name{Space: "urn:ietf:params:xml:ns:carddav", Local: "address-data"}
-
-type responseWriter struct {
- http.ResponseWriter
-}
-
-func (w responseWriter) Write(b []byte) (int, error) {
- return w.ResponseWriter.Write(b)
-}
-
-type Handler struct {
- ab AddressBook
- webdav *webdav.Handler
-}
-
-func NewHandler(ab AddressBook) *Handler {
- return &Handler{
- ab: ab,
- webdav: &webdav.Handler{
- FileSystem: &fileSystem{ab},
- Logger: func(req *http.Request, err error) {
- if err != nil {
- log.Println("ERROR", req, err)
- }
- },
- },
- }
-}
-
-func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
- if r.Method == http.MethodOptions {
- w.Header().Add("DAV", "addressbook")
- }
-
- w = responseWriter{w}
- switch r.Method {
- case "REPORT":
- code, err := h.handleReport(w, r)
- if err != nil {
- if code == 0 {
- code = http.StatusInternalServerError
- }
- http.Error(w, err.Error(), code)
- }
- case "OPTIONS":
- w.Header().Add("Allow", "REPORT")
- fallthrough
- default:
- h.webdav.ServeHTTP(w, r)
- }
-}
-
-func (h *Handler) handleReport(w http.ResponseWriter, r *http.Request) (int, error) {
- var mg addressbookMultiget
- if err := xml.NewDecoder(r.Body).Decode(&mg); err != nil {
- return http.StatusBadRequest, err
- }
-
- mw := webdav.NewMultistatusWriter(w)
- defer mw.Close()
-
- if len(mg.Href) == 0 {
- mg.Href = []string{r.URL.Path}
- }
- for _, href := range mg.Href {
- pstats, status, err := multiget(r.Context(), h.webdav.FileSystem, h.webdav.LockSystem, href, []xml.Name(mg.Prop), mg.Allprop != nil)
- if err != nil {
- return status, err
- }
-
- resp := &webdav.Response{
- Href: []string{(&url.URL{Path: href}).EscapedPath()},
- Status: status,
- Propstat: pstats,
- }
-
- if err := mw.Write(resp); err != nil {
- return 0, err
- }
- }
-
- return 0, nil
-}
-
-func multiget(ctx context.Context, fs webdav.FileSystem, ls webdav.LockSystem, name string, pnames []xml.Name, allprop bool) ([]webdav.Propstat, int, error) {
- wantAddressData := false
- for i, pname := range pnames {
- if pname == addressDataName {
- pnames = append(pnames[:i], pnames[i+1:]...)
- wantAddressData = true
- break
- }
- }
-
- var pstats []webdav.Propstat
- var err error
- if allprop {
- wantAddressData = true
- pstats, err = webdav.Allprop(ctx, fs, ls, name, pnames)
- } else {
- pstats, err = webdav.Props(ctx, fs, ls, name, pnames)
- }
- if err != nil {
- return pstats, 0, err
- }
-
- // TODO: locking stuff
-
- f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
- if err != nil {
- return nil, http.StatusNotFound, err
- }
- defer f.Close()
- fi, err := f.Stat()
- if err != nil {
- return nil, http.StatusNotFound, err
- }
-
- if wantAddressData {
- if fi.IsDir() {
- // TODO
- return nil, http.StatusNotFound, err
- }
-
- prop, status, err := addressdata(f.(*file).ao)
- if err != nil {
- return nil, status, err
- }
- if status == 0 {
- status = http.StatusOK
- }
-
- inserted := false
- for i, pstat := range pstats {
- if pstat.Status == status {
- pstats[i].Props = append(pstat.Props, prop)
- inserted = true
- break
- }
- }
-
- if !inserted {
- pstats = append(pstats, webdav.Propstat{
- Props: []webdav.Property{prop},
- Status: status,
- })
- }
- }
-
- return pstats, 0, nil
-}
-
-func addressdata(ao AddressObject) (webdav.Property, int, error) {
- prop := webdav.Property{XMLName: addressDataName}
-
- card, err := ao.Card()
- if err != nil {
- return prop, 0, err
- }
-
- // TODO: restrict to requested props
-
- var b bytes.Buffer
- if err := vcard.NewEncoder(&b).Encode(card); err != nil {
- return prop, 0, err
- }
-
- var escaped bytes.Buffer
- if err := xml.EscapeText(&escaped, b.Bytes()); err != nil {
- return prop, 0, err
- }
-
- prop.InnerXML = escaped.Bytes()
- return prop, 0, nil
-}
diff --git a/carddav/fs.go b/carddav/fs.go
deleted file mode 100644
index 7b882f5..0000000
--- a/carddav/fs.go
+++ /dev/null
@@ -1,408 +0,0 @@
-package carddav
-
-import (
- "bytes"
- "encoding/xml"
- "errors"
- "os"
- "strconv"
- "strings"
- "time"
-
- "github.com/emersion/go-vcard"
- "github.com/emersion/go-webdav"
- "golang.org/x/net/context"
-)
-
-var (
- errNotYetImplemented = errors.New("not yet implemented")
- errUnsupported = errors.New("unsupported")
-)
-
-const nsDAV = "DAV:"
-
-var (
- resourcetype = xml.Name{Space: nsDAV, Local: "resourcetype"}
- displayname = xml.Name{Space: nsDAV, Local: "displayname"}
- getcontenttype = xml.Name{Space: nsDAV, Local: "getcontenttype"}
-)
-
-const nsCardDAV = "urn:ietf:params:xml:ns:carddav"
-
-var (
- addressBookDescription = xml.Name{Space: nsCardDAV, Local: "addressbook-description"}
- addressBookSupportedAddressData = xml.Name{Space: nsCardDAV, Local: "supported-address-data"}
- addressBookMaxResourceSize = xml.Name{Space: nsCardDAV, Local: "max-resource-size"}
- addressBookHomeSet = xml.Name{Space: nsCardDAV, Local: "addressbook-home-set"}
-)
-
-func addressObjectName(ao AddressObject) string {
- return ao.ID()
-}
-
-type fileInfo struct {
- name string
- size int64
- mode os.FileMode
- modTime time.Time
-}
-
-func addressObjectFileInfo(ao AddressObject) *fileInfo {
- return &fileInfo{
- name: addressObjectName(ao),
- mode: os.ModePerm,
- }
-}
-
-func (fi *fileInfo) Name() string {
- return fi.name
-}
-
-func (fi *fileInfo) Size() int64 {
- return fi.size
-}
-
-func (fi *fileInfo) Mode() os.FileMode {
- return fi.mode
-}
-
-func (fi *fileInfo) ModTime() time.Time {
- return fi.modTime
-}
-
-func (fi *fileInfo) IsDir() bool {
- return fi.mode.IsDir()
-}
-
-func (fi *fileInfo) Sys() interface{} {
- return nil
-}
-
-type file struct {
- r *bytes.Reader
- w *bytes.Buffer
- fs *fileSystem
- ao AddressObject
-}
-
-func (f *file) Close() error {
- if f.w != nil {
- defer func() {
- f.w = nil
- }()
-
- card, err := vcard.NewDecoder(f.w).Decode()
- if err != nil {
- return err
- }
-
- if err := f.ao.SetCard(card); err != nil {
- return err
- }
- }
-
- f.r = nil
- return nil
-}
-
-func (f *file) Read(b []byte) (int, error) {
- if f.r == nil {
- card, err := f.ao.Card()
- if err != nil {
- return 0, err
- }
-
- var b bytes.Buffer
- if err := vcard.NewEncoder(&b).Encode(card); err != nil {
- return 0, err
- }
-
- f.r = bytes.NewReader(b.Bytes())
- }
-
- return f.r.Read(b)
-}
-
-func (f *file) Write(b []byte) (int, error) {
- if f.w == nil {
- f.w = &bytes.Buffer{}
- }
- return f.w.Write(b)
-}
-
-func (f *file) Seek(offset int64, whence int) (int64, error) {
- if f.r == nil {
- if _, err := f.Read(nil); err != nil {
- return 0, err
- }
- }
-
- return f.r.Seek(offset, whence)
-}
-
-func (f *file) Readdir(count int) ([]os.FileInfo, error) {
- return nil, errUnsupported
-}
-
-func (f *file) Stat() (os.FileInfo, error) {
- info, err := f.ao.Stat()
- if info != nil || err != nil {
- return info, err
- }
- return addressObjectFileInfo(f.ao), nil
-}
-
-func (f *file) DeadProps() (map[xml.Name]webdav.Property, error) {
- return map[xml.Name]webdav.Property{
- getcontenttype: webdav.Property{
- XMLName: getcontenttype,
- InnerXML: []byte(vcard.MIMEType),
- },
- }, nil
-}
-
-func (f *file) Patch([]webdav.Proppatch) ([]webdav.Propstat, error) {
- return nil, errUnsupported
-}
-
-type newFile struct {
- buf bytes.Buffer
- fs *fileSystem
- ao AddressObject
-}
-
-func (f *newFile) Close() error {
- if f.ao == nil {
- defer f.buf.Reset()
-
- card, err := vcard.NewDecoder(&f.buf).Decode()
- if err != nil {
- return err
- }
-
- ao, err := f.fs.ab.CreateAddressObject(card)
- if err != nil {
- return err
- }
-
- f.ao = ao
- }
-
- return nil
-}
-
-func (f *newFile) Read(b []byte) (int, error) {
- return 0, errUnsupported
-}
-
-func (f *newFile) Write(b []byte) (int, error) {
- // TODO: limit amount of data in f.buf
- if f.ao != nil {
- return 0, errUnsupported
- }
-
- return f.buf.Write(b)
-}
-
-func (f *newFile) Seek(offset int64, whence int) (int64, error) {
- return 0, errUnsupported
-}
-
-func (f *newFile) Readdir(count int) ([]os.FileInfo, error) {
- return nil, errUnsupported
-}
-
-func (f *newFile) Stat() (os.FileInfo, error) {
- // Only available after a successful call to Close
- if f.ao == nil {
- return nil, errUnsupported
- }
-
- info, err := f.ao.Stat()
- if info != nil || err != nil {
- return info, err
- }
- return addressObjectFileInfo(f.ao), nil
-}
-
-type dir struct {
- fs *fileSystem
- name string
- files []os.FileInfo
-
- n int
-}
-
-func (d *dir) Close() error {
- return nil
-}
-
-func (d *dir) Read(b []byte) (int, error) {
- return 0, errUnsupported
-}
-
-func (d *dir) Write(b []byte) (int, error) {
- return 0, errUnsupported
-}
-
-func (d *dir) Seek(offset int64, whence int) (int64, error) {
- return 0, errUnsupported
-}
-
-func (d *dir) Readdir(count int) ([]os.FileInfo, error) {
- if d.files == nil {
- aos, err := d.fs.ab.ListAddressObjects()
- if err != nil {
- return nil, err
- }
-
- d.files = make([]os.FileInfo, len(aos))
- for i, ao := range aos {
- d.files[i] = addressObjectFileInfo(ao)
- }
- }
-
- if count == 0 {
- count = len(d.files) - d.n
- }
- if d.n >= len(d.files) {
- return nil, nil
- }
-
- from := d.n
- d.n += count
- if d.n > len(d.files) {
- d.n = len(d.files)
- }
-
- return d.files[from:d.n], nil
-}
-
-func (d *dir) Stat() (os.FileInfo, error) {
- return &fileInfo{
- name: d.name,
- mode: os.ModeDir | os.ModePerm,
- }, nil
-}
-
-func (d *dir) DeadProps() (map[xml.Name]webdav.Property, error) {
- info, err := d.fs.ab.Info()
- if err != nil {
- return nil, err
- }
-
- return map[xml.Name]webdav.Property{
- resourcetype: webdav.Property{
- XMLName: resourcetype,
- InnerXML: []byte(``),
- },
- displayname: webdav.Property{
- XMLName: displayname,
- InnerXML: []byte(info.Name),
- },
- addressBookDescription: webdav.Property{
- XMLName: addressBookDescription,
- InnerXML: []byte(info.Description),
- },
- addressBookSupportedAddressData: webdav.Property{
- XMLName: addressBookSupportedAddressData,
- InnerXML: []byte(`` +
- ``),
- },
- addressBookMaxResourceSize: webdav.Property{
- XMLName: addressBookMaxResourceSize,
- InnerXML: []byte(strconv.Itoa(info.MaxResourceSize)),
- },
- addressBookHomeSet: webdav.Property{
- XMLName: addressBookHomeSet,
- InnerXML: []byte(`/`),
- },
- }, nil
-}
-
-func (d *dir) Patch([]webdav.Proppatch) ([]webdav.Propstat, error) {
- return nil, errUnsupported
-}
-
-type fileSystem struct {
- ab AddressBook
-}
-
-func (fs *fileSystem) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- return errNotYetImplemented
-}
-
-func (fs *fileSystem) addressObjectID(name string) string {
- return strings.TrimLeft(name, "/")
-}
-
-func (fs *fileSystem) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
- if name == "/" {
- return &dir{
- fs: fs,
- name: name,
- }, nil
- }
-
- id := fs.addressObjectID(name)
- ao, err := fs.ab.GetAddressObject(id)
- if err == ErrNotFound && flag & os.O_CREATE != 0 {
- return &newFile{fs: fs}, nil
- } else if err != nil {
- return nil, err
- }
-
- f := &file{
- fs: fs,
- ao: ao,
- }
-
- if flag&os.O_RDONLY != 0 {
- // This file will be read, cache its contents
- if _, err := f.Read(nil); err != nil {
- return f, err
- }
- }
-
- return f, nil
-}
-
-func (fs *fileSystem) RemoveAll(ctx context.Context, name string) error {
- if name == "/" {
- return errUnsupported
- }
-
- id := fs.addressObjectID(name)
- ao, err := fs.ab.GetAddressObject(id)
- if err != nil {
- return err
- }
-
- return ao.Remove()
-}
-
-func (fs *fileSystem) Rename(ctx context.Context, oldName, newName string) error {
- return errNotYetImplemented
-}
-
-func (fs *fileSystem) Stat(ctx context.Context, name string) (os.FileInfo, error) {
- if name == "/" {
- return &fileInfo{
- name: name,
- mode: os.ModeDir | os.ModePerm,
- }, nil
- }
-
- id := fs.addressObjectID(name)
- ao, err := fs.ab.GetAddressObject(id)
- if err != nil {
- return nil, err
- }
-
- info, err := ao.Stat()
- if info != nil || err != nil {
- return info, err
- }
-
- return addressObjectFileInfo(ao), nil
-}
diff --git a/carddav/xml.go b/carddav/xml.go
deleted file mode 100644
index 9bc7c5a..0000000
--- a/carddav/xml.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package carddav
-
-import (
- "encoding/xml"
-
- "github.com/emersion/go-webdav"
-)
-
-// https://tools.ietf.org/html/rfc6352#section-10.7
-type addressbookMultiget struct {
- XMLName xml.Name `xml:"urn:ietf:params:xml:ns:carddav addressbook-multiget"`
- Allprop *struct{} `xml:"DAV: allprop"`
- Propname *struct{} `xml:"DAV: propname"`
- Prop webdav.PropfindProps `xml:"DAV: prop"`
- Href []string `xml:"DAV: href"`
-}
-
-// TODO
-type addressData struct {
- XMLName xml.Name `xml:"urn:ietf:params:xml:ns:carddav address-data"`
- ContentType string `xml:"content-type,attr"`
- Version string `xml:"version,attr"`
- Prop []string `xml:"prop>name,attr"`
-}
diff --git a/file.go b/file.go
deleted file mode 100644
index 748118d..0000000
--- a/file.go
+++ /dev/null
@@ -1,796 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "encoding/xml"
- "io"
- "net/http"
- "os"
- "path"
- "path/filepath"
- "strings"
- "sync"
- "time"
-
- "golang.org/x/net/context"
-)
-
-// slashClean is equivalent to but slightly more efficient than
-// path.Clean("/" + name).
-func slashClean(name string) string {
- if name == "" || name[0] != '/' {
- name = "/" + name
- }
- return path.Clean(name)
-}
-
-// A FileSystem implements access to a collection of named files. The elements
-// in a file path are separated by slash ('/', U+002F) characters, regardless
-// of host operating system convention.
-//
-// Each method has the same semantics as the os package's function of the same
-// name.
-//
-// Note that the os.Rename documentation says that "OS-specific restrictions
-// might apply". In particular, whether or not renaming a file or directory
-// overwriting another existing file or directory is an error is OS-dependent.
-type FileSystem interface {
- Mkdir(ctx context.Context, name string, perm os.FileMode) error
- OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error)
- RemoveAll(ctx context.Context, name string) error
- Rename(ctx context.Context, oldName, newName string) error
- Stat(ctx context.Context, name string) (os.FileInfo, error)
-}
-
-// A File is returned by a FileSystem's OpenFile method and can be served by a
-// Handler.
-//
-// A File may optionally implement the DeadPropsHolder interface, if it can
-// load and save dead properties.
-type File interface {
- http.File
- io.Writer
-}
-
-// A Dir implements FileSystem using the native file system restricted to a
-// specific directory tree.
-//
-// While the FileSystem.OpenFile method takes '/'-separated paths, a Dir's
-// string value is a filename on the native file system, not a URL, so it is
-// separated by filepath.Separator, which isn't necessarily '/'.
-//
-// An empty Dir is treated as ".".
-type Dir string
-
-func (d Dir) resolve(name string) string {
- // This implementation is based on Dir.Open's code in the standard net/http package.
- if filepath.Separator != '/' && strings.IndexRune(name, filepath.Separator) >= 0 ||
- strings.Contains(name, "\x00") {
- return ""
- }
- dir := string(d)
- if dir == "" {
- dir = "."
- }
- return filepath.Join(dir, filepath.FromSlash(slashClean(name)))
-}
-
-func (d Dir) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- if name = d.resolve(name); name == "" {
- return os.ErrNotExist
- }
- return os.Mkdir(name, perm)
-}
-
-func (d Dir) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
- if name = d.resolve(name); name == "" {
- return nil, os.ErrNotExist
- }
- f, err := os.OpenFile(name, flag, perm)
- if err != nil {
- return nil, err
- }
- return f, nil
-}
-
-func (d Dir) RemoveAll(ctx context.Context, name string) error {
- if name = d.resolve(name); name == "" {
- return os.ErrNotExist
- }
- if name == filepath.Clean(string(d)) {
- // Prohibit removing the virtual root directory.
- return os.ErrInvalid
- }
- return os.RemoveAll(name)
-}
-
-func (d Dir) Rename(ctx context.Context, oldName, newName string) error {
- if oldName = d.resolve(oldName); oldName == "" {
- return os.ErrNotExist
- }
- if newName = d.resolve(newName); newName == "" {
- return os.ErrNotExist
- }
- if root := filepath.Clean(string(d)); root == oldName || root == newName {
- // Prohibit renaming from or to the virtual root directory.
- return os.ErrInvalid
- }
- return os.Rename(oldName, newName)
-}
-
-func (d Dir) Stat(ctx context.Context, name string) (os.FileInfo, error) {
- if name = d.resolve(name); name == "" {
- return nil, os.ErrNotExist
- }
- return os.Stat(name)
-}
-
-// NewMemFS returns a new in-memory FileSystem implementation.
-func NewMemFS() FileSystem {
- return &memFS{
- root: memFSNode{
- children: make(map[string]*memFSNode),
- mode: 0660 | os.ModeDir,
- modTime: time.Now(),
- },
- }
-}
-
-// A memFS implements FileSystem, storing all metadata and actual file data
-// in-memory. No limits on filesystem size are used, so it is not recommended
-// this be used where the clients are untrusted.
-//
-// Concurrent access is permitted. The tree structure is protected by a mutex,
-// and each node's contents and metadata are protected by a per-node mutex.
-//
-// TODO: Enforce file permissions.
-type memFS struct {
- mu sync.Mutex
- root memFSNode
-}
-
-// TODO: clean up and rationalize the walk/find code.
-
-// walk walks the directory tree for the fullname, calling f at each step. If f
-// returns an error, the walk will be aborted and return that same error.
-//
-// dir is the directory at that step, frag is the name fragment, and final is
-// whether it is the final step. For example, walking "/foo/bar/x" will result
-// in 3 calls to f:
-// - "/", "foo", false
-// - "/foo/", "bar", false
-// - "/foo/bar/", "x", true
-// The frag argument will be empty only if dir is the root node and the walk
-// ends at that root node.
-func (fs *memFS) walk(op, fullname string, f func(dir *memFSNode, frag string, final bool) error) error {
- original := fullname
- fullname = slashClean(fullname)
-
- // Strip any leading "/"s to make fullname a relative path, as the walk
- // starts at fs.root.
- if fullname[0] == '/' {
- fullname = fullname[1:]
- }
- dir := &fs.root
-
- for {
- frag, remaining := fullname, ""
- i := strings.IndexRune(fullname, '/')
- final := i < 0
- if !final {
- frag, remaining = fullname[:i], fullname[i+1:]
- }
- if frag == "" && dir != &fs.root {
- panic("webdav: empty path fragment for a clean path")
- }
- if err := f(dir, frag, final); err != nil {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: err,
- }
- }
- if final {
- break
- }
- child := dir.children[frag]
- if child == nil {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: os.ErrNotExist,
- }
- }
- if !child.mode.IsDir() {
- return &os.PathError{
- Op: op,
- Path: original,
- Err: os.ErrInvalid,
- }
- }
- dir, fullname = child, remaining
- }
- return nil
-}
-
-// find returns the parent of the named node and the relative name fragment
-// from the parent to the child. For example, if finding "/foo/bar/baz" then
-// parent will be the node for "/foo/bar" and frag will be "baz".
-//
-// If the fullname names the root node, then parent, frag and err will be zero.
-//
-// find returns an error if the parent does not already exist or the parent
-// isn't a directory, but it will not return an error per se if the child does
-// not already exist. The error returned is either nil or an *os.PathError
-// whose Op is op.
-func (fs *memFS) find(op, fullname string) (parent *memFSNode, frag string, err error) {
- err = fs.walk(op, fullname, func(parent0 *memFSNode, frag0 string, final bool) error {
- if !final {
- return nil
- }
- if frag0 != "" {
- parent, frag = parent0, frag0
- }
- return nil
- })
- return parent, frag, err
-}
-
-func (fs *memFS) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("mkdir", name)
- if err != nil {
- return err
- }
- if dir == nil {
- // We can't create the root.
- return os.ErrInvalid
- }
- if _, ok := dir.children[frag]; ok {
- return os.ErrExist
- }
- dir.children[frag] = &memFSNode{
- children: make(map[string]*memFSNode),
- mode: perm.Perm() | os.ModeDir,
- modTime: time.Now(),
- }
- return nil
-}
-
-func (fs *memFS) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error) {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("open", name)
- if err != nil {
- return nil, err
- }
- var n *memFSNode
- if dir == nil {
- // We're opening the root.
- if flag&(os.O_WRONLY|os.O_RDWR) != 0 {
- return nil, os.ErrPermission
- }
- n, frag = &fs.root, "/"
-
- } else {
- n = dir.children[frag]
- if flag&(os.O_SYNC|os.O_APPEND) != 0 {
- // memFile doesn't support these flags yet.
- return nil, os.ErrInvalid
- }
- if flag&os.O_CREATE != 0 {
- if flag&os.O_EXCL != 0 && n != nil {
- return nil, os.ErrExist
- }
- if n == nil {
- n = &memFSNode{
- mode: perm.Perm(),
- }
- dir.children[frag] = n
- }
- }
- if n == nil {
- return nil, os.ErrNotExist
- }
- if flag&(os.O_WRONLY|os.O_RDWR) != 0 && flag&os.O_TRUNC != 0 {
- n.mu.Lock()
- n.data = nil
- n.mu.Unlock()
- }
- }
-
- children := make([]os.FileInfo, 0, len(n.children))
- for cName, c := range n.children {
- children = append(children, c.stat(cName))
- }
- return &memFile{
- n: n,
- nameSnapshot: frag,
- childrenSnapshot: children,
- }, nil
-}
-
-func (fs *memFS) RemoveAll(ctx context.Context, name string) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("remove", name)
- if err != nil {
- return err
- }
- if dir == nil {
- // We can't remove the root.
- return os.ErrInvalid
- }
- delete(dir.children, frag)
- return nil
-}
-
-func (fs *memFS) Rename(ctx context.Context, oldName, newName string) error {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- oldName = slashClean(oldName)
- newName = slashClean(newName)
- if oldName == newName {
- return nil
- }
- if strings.HasPrefix(newName, oldName+"/") {
- // We can't rename oldName to be a sub-directory of itself.
- return os.ErrInvalid
- }
-
- oDir, oFrag, err := fs.find("rename", oldName)
- if err != nil {
- return err
- }
- if oDir == nil {
- // We can't rename from the root.
- return os.ErrInvalid
- }
-
- nDir, nFrag, err := fs.find("rename", newName)
- if err != nil {
- return err
- }
- if nDir == nil {
- // We can't rename to the root.
- return os.ErrInvalid
- }
-
- oNode, ok := oDir.children[oFrag]
- if !ok {
- return os.ErrNotExist
- }
- if oNode.children != nil {
- if nNode, ok := nDir.children[nFrag]; ok {
- if nNode.children == nil {
- return errNotADirectory
- }
- if len(nNode.children) != 0 {
- return errDirectoryNotEmpty
- }
- }
- }
- delete(oDir.children, oFrag)
- nDir.children[nFrag] = oNode
- return nil
-}
-
-func (fs *memFS) Stat(ctx context.Context, name string) (os.FileInfo, error) {
- fs.mu.Lock()
- defer fs.mu.Unlock()
-
- dir, frag, err := fs.find("stat", name)
- if err != nil {
- return nil, err
- }
- if dir == nil {
- // We're stat'ting the root.
- return fs.root.stat("/"), nil
- }
- if n, ok := dir.children[frag]; ok {
- return n.stat(path.Base(name)), nil
- }
- return nil, os.ErrNotExist
-}
-
-// A memFSNode represents a single entry in the in-memory filesystem and also
-// implements os.FileInfo.
-type memFSNode struct {
- // children is protected by memFS.mu.
- children map[string]*memFSNode
-
- mu sync.Mutex
- data []byte
- mode os.FileMode
- modTime time.Time
- deadProps map[xml.Name]Property
-}
-
-func (n *memFSNode) stat(name string) *memFileInfo {
- n.mu.Lock()
- defer n.mu.Unlock()
- return &memFileInfo{
- name: name,
- size: int64(len(n.data)),
- mode: n.mode,
- modTime: n.modTime,
- }
-}
-
-func (n *memFSNode) DeadProps() (map[xml.Name]Property, error) {
- n.mu.Lock()
- defer n.mu.Unlock()
- if len(n.deadProps) == 0 {
- return nil, nil
- }
- ret := make(map[xml.Name]Property, len(n.deadProps))
- for k, v := range n.deadProps {
- ret[k] = v
- }
- return ret, nil
-}
-
-func (n *memFSNode) Patch(patches []Proppatch) ([]Propstat, error) {
- n.mu.Lock()
- defer n.mu.Unlock()
- pstat := Propstat{Status: http.StatusOK}
- for _, patch := range patches {
- for _, p := range patch.Props {
- pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName})
- if patch.Remove {
- delete(n.deadProps, p.XMLName)
- continue
- }
- if n.deadProps == nil {
- n.deadProps = map[xml.Name]Property{}
- }
- n.deadProps[p.XMLName] = p
- }
- }
- return []Propstat{pstat}, nil
-}
-
-type memFileInfo struct {
- name string
- size int64
- mode os.FileMode
- modTime time.Time
-}
-
-func (f *memFileInfo) Name() string { return f.name }
-func (f *memFileInfo) Size() int64 { return f.size }
-func (f *memFileInfo) Mode() os.FileMode { return f.mode }
-func (f *memFileInfo) ModTime() time.Time { return f.modTime }
-func (f *memFileInfo) IsDir() bool { return f.mode.IsDir() }
-func (f *memFileInfo) Sys() interface{} { return nil }
-
-// A memFile is a File implementation for a memFSNode. It is a per-file (not
-// per-node) read/write position, and a snapshot of the memFS' tree structure
-// (a node's name and children) for that node.
-type memFile struct {
- n *memFSNode
- nameSnapshot string
- childrenSnapshot []os.FileInfo
- // pos is protected by n.mu.
- pos int
-}
-
-// A *memFile implements the optional DeadPropsHolder interface.
-var _ DeadPropsHolder = (*memFile)(nil)
-
-func (f *memFile) DeadProps() (map[xml.Name]Property, error) { return f.n.DeadProps() }
-func (f *memFile) Patch(patches []Proppatch) ([]Propstat, error) { return f.n.Patch(patches) }
-
-func (f *memFile) Close() error {
- return nil
-}
-
-func (f *memFile) Read(p []byte) (int, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- if f.n.mode.IsDir() {
- return 0, os.ErrInvalid
- }
- if f.pos >= len(f.n.data) {
- return 0, io.EOF
- }
- n := copy(p, f.n.data[f.pos:])
- f.pos += n
- return n, nil
-}
-
-func (f *memFile) Readdir(count int) ([]os.FileInfo, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- if !f.n.mode.IsDir() {
- return nil, os.ErrInvalid
- }
- old := f.pos
- if old >= len(f.childrenSnapshot) {
- // The os.File Readdir docs say that at the end of a directory,
- // the error is io.EOF if count > 0 and nil if count <= 0.
- if count > 0 {
- return nil, io.EOF
- }
- return nil, nil
- }
- if count > 0 {
- f.pos += count
- if f.pos > len(f.childrenSnapshot) {
- f.pos = len(f.childrenSnapshot)
- }
- } else {
- f.pos = len(f.childrenSnapshot)
- old = 0
- }
- return f.childrenSnapshot[old:f.pos], nil
-}
-
-func (f *memFile) Seek(offset int64, whence int) (int64, error) {
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
- npos := f.pos
- // TODO: How to handle offsets greater than the size of system int?
- switch whence {
- case os.SEEK_SET:
- npos = int(offset)
- case os.SEEK_CUR:
- npos += int(offset)
- case os.SEEK_END:
- npos = len(f.n.data) + int(offset)
- default:
- npos = -1
- }
- if npos < 0 {
- return 0, os.ErrInvalid
- }
- f.pos = npos
- return int64(f.pos), nil
-}
-
-func (f *memFile) Stat() (os.FileInfo, error) {
- return f.n.stat(f.nameSnapshot), nil
-}
-
-func (f *memFile) Write(p []byte) (int, error) {
- lenp := len(p)
- f.n.mu.Lock()
- defer f.n.mu.Unlock()
-
- if f.n.mode.IsDir() {
- return 0, os.ErrInvalid
- }
- if f.pos < len(f.n.data) {
- n := copy(f.n.data[f.pos:], p)
- f.pos += n
- p = p[n:]
- } else if f.pos > len(f.n.data) {
- // Write permits the creation of holes, if we've seek'ed past the
- // existing end of file.
- if f.pos <= cap(f.n.data) {
- oldLen := len(f.n.data)
- f.n.data = f.n.data[:f.pos]
- hole := f.n.data[oldLen:]
- for i := range hole {
- hole[i] = 0
- }
- } else {
- d := make([]byte, f.pos, f.pos+len(p))
- copy(d, f.n.data)
- f.n.data = d
- }
- }
-
- if len(p) > 0 {
- // We should only get here if f.pos == len(f.n.data).
- f.n.data = append(f.n.data, p...)
- f.pos = len(f.n.data)
- }
- f.n.modTime = time.Now()
- return lenp, nil
-}
-
-// moveFiles moves files and/or directories from src to dst.
-//
-// See section 9.9.4 for when various HTTP status codes apply.
-func moveFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool) (status int, err error) {
- created := false
- if _, err := fs.Stat(ctx, dst); err != nil {
- if !os.IsNotExist(err) {
- return http.StatusForbidden, err
- }
- created = true
- } else if overwrite {
- // Section 9.9.3 says that "If a resource exists at the destination
- // and the Overwrite header is "T", then prior to performing the move,
- // the server must perform a DELETE with "Depth: infinity" on the
- // destination resource.
- if err := fs.RemoveAll(ctx, dst); err != nil {
- return http.StatusForbidden, err
- }
- } else {
- return http.StatusPreconditionFailed, os.ErrExist
- }
- if err := fs.Rename(ctx, src, dst); err != nil {
- return http.StatusForbidden, err
- }
- if created {
- return http.StatusCreated, nil
- }
- return http.StatusNoContent, nil
-}
-
-func copyProps(dst, src File) error {
- d, ok := dst.(DeadPropsHolder)
- if !ok {
- return nil
- }
- s, ok := src.(DeadPropsHolder)
- if !ok {
- return nil
- }
- m, err := s.DeadProps()
- if err != nil {
- return err
- }
- props := make([]Property, 0, len(m))
- for _, prop := range m {
- props = append(props, prop)
- }
- _, err = d.Patch([]Proppatch{{Props: props}})
- return err
-}
-
-// copyFiles copies files and/or directories from src to dst.
-//
-// See section 9.8.5 for when various HTTP status codes apply.
-func copyFiles(ctx context.Context, fs FileSystem, src, dst string, overwrite bool, depth int, recursion int) (status int, err error) {
- if recursion == 1000 {
- return http.StatusInternalServerError, errRecursionTooDeep
- }
- recursion++
-
- // TODO: section 9.8.3 says that "Note that an infinite-depth COPY of /A/
- // into /A/B/ could lead to infinite recursion if not handled correctly."
-
- srcFile, err := fs.OpenFile(ctx, src, os.O_RDONLY, 0)
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusNotFound, err
- }
- return http.StatusInternalServerError, err
- }
- defer srcFile.Close()
- srcStat, err := srcFile.Stat()
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusNotFound, err
- }
- return http.StatusInternalServerError, err
- }
- srcPerm := srcStat.Mode() & os.ModePerm
-
- created := false
- if _, err := fs.Stat(ctx, dst); err != nil {
- if os.IsNotExist(err) {
- created = true
- } else {
- return http.StatusForbidden, err
- }
- } else {
- if !overwrite {
- return http.StatusPreconditionFailed, os.ErrExist
- }
- if err := fs.RemoveAll(ctx, dst); err != nil && !os.IsNotExist(err) {
- return http.StatusForbidden, err
- }
- }
-
- if srcStat.IsDir() {
- if err := fs.Mkdir(ctx, dst, srcPerm); err != nil {
- return http.StatusForbidden, err
- }
- if depth == infiniteDepth {
- children, err := srcFile.Readdir(-1)
- if err != nil {
- return http.StatusForbidden, err
- }
- for _, c := range children {
- name := c.Name()
- s := path.Join(src, name)
- d := path.Join(dst, name)
- cStatus, cErr := copyFiles(ctx, fs, s, d, overwrite, depth, recursion)
- if cErr != nil {
- // TODO: MultiStatus.
- return cStatus, cErr
- }
- }
- }
-
- } else {
- dstFile, err := fs.OpenFile(ctx, dst, os.O_RDWR|os.O_CREATE|os.O_TRUNC, srcPerm)
- if err != nil {
- if os.IsNotExist(err) {
- return http.StatusConflict, err
- }
- return http.StatusForbidden, err
-
- }
- _, copyErr := io.Copy(dstFile, srcFile)
- propsErr := copyProps(dstFile, srcFile)
- closeErr := dstFile.Close()
- if copyErr != nil {
- return http.StatusInternalServerError, copyErr
- }
- if propsErr != nil {
- return http.StatusInternalServerError, propsErr
- }
- if closeErr != nil {
- return http.StatusInternalServerError, closeErr
- }
- }
-
- if created {
- return http.StatusCreated, nil
- }
- return http.StatusNoContent, nil
-}
-
-// walkFS traverses filesystem fs starting at name up to depth levels.
-//
-// Allowed values for depth are 0, 1 or infiniteDepth. For each visited node,
-// walkFS calls walkFn. If a visited file system node is a directory and
-// walkFn returns filepath.SkipDir, walkFS will skip traversal of this node.
-func walkFS(ctx context.Context, fs FileSystem, depth int, name string, info os.FileInfo, walkFn filepath.WalkFunc) error {
- // This implementation is based on Walk's code in the standard path/filepath package.
- err := walkFn(name, info, nil)
- if err != nil {
- if info.IsDir() && err == filepath.SkipDir {
- return nil
- }
- return err
- }
- if !info.IsDir() || depth == 0 {
- return nil
- }
- if depth == 1 {
- depth = 0
- }
-
- // Read directory names.
- f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
- if err != nil {
- return walkFn(name, info, err)
- }
- fileInfos, err := f.Readdir(0)
- f.Close()
- if err != nil {
- return walkFn(name, info, err)
- }
-
- for _, fileInfo := range fileInfos {
- filename := path.Join(name, fileInfo.Name())
- fileInfo, err := fs.Stat(ctx, filename)
- if err != nil {
- if err := walkFn(filename, fileInfo, err); err != nil && err != filepath.SkipDir {
- return err
- }
- } else {
- err = walkFS(ctx, fs, depth, filename, fileInfo, walkFn)
- if err != nil {
- if !fileInfo.IsDir() || err != filepath.SkipDir {
- return err
- }
- }
- }
- }
- return nil
-}
diff --git a/file_go1.6.go b/file_go1.6.go
deleted file mode 100644
index fa38770..0000000
--- a/file_go1.6.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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()
-}
diff --git a/file_go1.7.go b/file_go1.7.go
deleted file mode 100644
index d1c3de8..0000000
--- a/file_go1.7.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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()
-}
diff --git a/file_test.go b/file_test.go
deleted file mode 100644
index bfd96e1..0000000
--- a/file_test.go
+++ /dev/null
@@ -1,1184 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "encoding/xml"
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "path"
- "path/filepath"
- "reflect"
- "runtime"
- "sort"
- "strconv"
- "strings"
- "testing"
-
- "golang.org/x/net/context"
-)
-
-func TestSlashClean(t *testing.T) {
- testCases := []string{
- "",
- ".",
- "/",
- "/./",
- "//",
- "//.",
- "//a",
- "/a",
- "/a/b/c",
- "/a//b/./../c/d/",
- "a",
- "a/b/c",
- }
- for _, tc := range testCases {
- got := slashClean(tc)
- want := path.Clean("/" + tc)
- if got != want {
- t.Errorf("tc=%q: got %q, want %q", tc, got, want)
- }
- }
-}
-
-func TestDirResolve(t *testing.T) {
- testCases := []struct {
- dir, name, want string
- }{
- {"/", "", "/"},
- {"/", "/", "/"},
- {"/", ".", "/"},
- {"/", "./a", "/a"},
- {"/", "..", "/"},
- {"/", "..", "/"},
- {"/", "../", "/"},
- {"/", "../.", "/"},
- {"/", "../a", "/a"},
- {"/", "../..", "/"},
- {"/", "../bar/a", "/bar/a"},
- {"/", "../baz/a", "/baz/a"},
- {"/", "...", "/..."},
- {"/", ".../a", "/.../a"},
- {"/", ".../..", "/"},
- {"/", "a", "/a"},
- {"/", "a/./b", "/a/b"},
- {"/", "a/../../b", "/b"},
- {"/", "a/../b", "/b"},
- {"/", "a/b", "/a/b"},
- {"/", "a/b/c/../../d", "/a/d"},
- {"/", "a/b/c/../../../d", "/d"},
- {"/", "a/b/c/../../../../d", "/d"},
- {"/", "a/b/c/d", "/a/b/c/d"},
-
- {"/foo/bar", "", "/foo/bar"},
- {"/foo/bar", "/", "/foo/bar"},
- {"/foo/bar", ".", "/foo/bar"},
- {"/foo/bar", "./a", "/foo/bar/a"},
- {"/foo/bar", "..", "/foo/bar"},
- {"/foo/bar", "../", "/foo/bar"},
- {"/foo/bar", "../.", "/foo/bar"},
- {"/foo/bar", "../a", "/foo/bar/a"},
- {"/foo/bar", "../..", "/foo/bar"},
- {"/foo/bar", "../bar/a", "/foo/bar/bar/a"},
- {"/foo/bar", "../baz/a", "/foo/bar/baz/a"},
- {"/foo/bar", "...", "/foo/bar/..."},
- {"/foo/bar", ".../a", "/foo/bar/.../a"},
- {"/foo/bar", ".../..", "/foo/bar"},
- {"/foo/bar", "a", "/foo/bar/a"},
- {"/foo/bar", "a/./b", "/foo/bar/a/b"},
- {"/foo/bar", "a/../../b", "/foo/bar/b"},
- {"/foo/bar", "a/../b", "/foo/bar/b"},
- {"/foo/bar", "a/b", "/foo/bar/a/b"},
- {"/foo/bar", "a/b/c/../../d", "/foo/bar/a/d"},
- {"/foo/bar", "a/b/c/../../../d", "/foo/bar/d"},
- {"/foo/bar", "a/b/c/../../../../d", "/foo/bar/d"},
- {"/foo/bar", "a/b/c/d", "/foo/bar/a/b/c/d"},
-
- {"/foo/bar/", "", "/foo/bar"},
- {"/foo/bar/", "/", "/foo/bar"},
- {"/foo/bar/", ".", "/foo/bar"},
- {"/foo/bar/", "./a", "/foo/bar/a"},
- {"/foo/bar/", "..", "/foo/bar"},
-
- {"/foo//bar///", "", "/foo/bar"},
- {"/foo//bar///", "/", "/foo/bar"},
- {"/foo//bar///", ".", "/foo/bar"},
- {"/foo//bar///", "./a", "/foo/bar/a"},
- {"/foo//bar///", "..", "/foo/bar"},
-
- {"/x/y/z", "ab/c\x00d/ef", ""},
-
- {".", "", "."},
- {".", "/", "."},
- {".", ".", "."},
- {".", "./a", "a"},
- {".", "..", "."},
- {".", "..", "."},
- {".", "../", "."},
- {".", "../.", "."},
- {".", "../a", "a"},
- {".", "../..", "."},
- {".", "../bar/a", "bar/a"},
- {".", "../baz/a", "baz/a"},
- {".", "...", "..."},
- {".", ".../a", ".../a"},
- {".", ".../..", "."},
- {".", "a", "a"},
- {".", "a/./b", "a/b"},
- {".", "a/../../b", "b"},
- {".", "a/../b", "b"},
- {".", "a/b", "a/b"},
- {".", "a/b/c/../../d", "a/d"},
- {".", "a/b/c/../../../d", "d"},
- {".", "a/b/c/../../../../d", "d"},
- {".", "a/b/c/d", "a/b/c/d"},
-
- {"", "", "."},
- {"", "/", "."},
- {"", ".", "."},
- {"", "./a", "a"},
- {"", "..", "."},
- }
-
- for _, tc := range testCases {
- d := Dir(filepath.FromSlash(tc.dir))
- if got := filepath.ToSlash(d.resolve(tc.name)); got != tc.want {
- t.Errorf("dir=%q, name=%q: got %q, want %q", tc.dir, tc.name, got, tc.want)
- }
- }
-}
-
-func TestWalk(t *testing.T) {
- type walkStep struct {
- name, frag string
- final bool
- }
-
- testCases := []struct {
- dir string
- want []walkStep
- }{
- {"", []walkStep{
- {"", "", true},
- }},
- {"/", []walkStep{
- {"", "", true},
- }},
- {"/a", []walkStep{
- {"", "a", true},
- }},
- {"/a/", []walkStep{
- {"", "a", true},
- }},
- {"/a/b", []walkStep{
- {"", "a", false},
- {"a", "b", true},
- }},
- {"/a/b/", []walkStep{
- {"", "a", false},
- {"a", "b", true},
- }},
- {"/a/b/c", []walkStep{
- {"", "a", false},
- {"a", "b", false},
- {"b", "c", true},
- }},
- // The following test case is the one mentioned explicitly
- // in the method description.
- {"/foo/bar/x", []walkStep{
- {"", "foo", false},
- {"foo", "bar", false},
- {"bar", "x", true},
- }},
- }
-
- ctx := context.Background()
-
- for _, tc := range testCases {
- fs := NewMemFS().(*memFS)
-
- parts := strings.Split(tc.dir, "/")
- for p := 2; p < len(parts); p++ {
- d := strings.Join(parts[:p], "/")
- if err := fs.Mkdir(ctx, d, 0666); err != nil {
- t.Errorf("tc.dir=%q: mkdir: %q: %v", tc.dir, d, err)
- }
- }
-
- i, prevFrag := 0, ""
- err := fs.walk("test", tc.dir, func(dir *memFSNode, frag string, final bool) error {
- got := walkStep{
- name: prevFrag,
- frag: frag,
- final: final,
- }
- want := tc.want[i]
-
- if got != want {
- return fmt.Errorf("got %+v, want %+v", got, want)
- }
- i, prevFrag = i+1, frag
- return nil
- })
- if err != nil {
- t.Errorf("tc.dir=%q: %v", tc.dir, err)
- }
- }
-}
-
-// find appends to ss the names of the named file and its children. It is
-// analogous to the Unix find command.
-//
-// The returned strings are not guaranteed to be in any particular order.
-func find(ctx context.Context, ss []string, fs FileSystem, name string) ([]string, error) {
- stat, err := fs.Stat(ctx, name)
- if err != nil {
- return nil, err
- }
- ss = append(ss, name)
- if stat.IsDir() {
- f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
- if err != nil {
- return nil, err
- }
- defer f.Close()
- children, err := f.Readdir(-1)
- if err != nil {
- return nil, err
- }
- for _, c := range children {
- ss, err = find(ctx, ss, fs, path.Join(name, c.Name()))
- if err != nil {
- return nil, err
- }
- }
- }
- return ss, nil
-}
-
-func testFS(t *testing.T, fs FileSystem) {
- errStr := func(err error) string {
- switch {
- case os.IsExist(err):
- return "errExist"
- case os.IsNotExist(err):
- return "errNotExist"
- case err != nil:
- return "err"
- }
- return "ok"
- }
-
- // The non-"find" non-"stat" test cases should change the file system state. The
- // indentation of the "find"s and "stat"s helps distinguish such test cases.
- testCases := []string{
- " stat / want dir",
- " stat /a want errNotExist",
- " stat /d want errNotExist",
- " stat /d/e want errNotExist",
- "create /a A want ok",
- " stat /a want 1",
- "create /d/e EEE want errNotExist",
- "mk-dir /a want errExist",
- "mk-dir /d/m want errNotExist",
- "mk-dir /d want ok",
- " stat /d want dir",
- "create /d/e EEE want ok",
- " stat /d/e want 3",
- " find / /a /d /d/e",
- "create /d/f FFFF want ok",
- "create /d/g GGGGGGG want ok",
- "mk-dir /d/m want ok",
- "mk-dir /d/m want errExist",
- "create /d/m/p PPPPP want ok",
- " stat /d/e want 3",
- " stat /d/f want 4",
- " stat /d/g want 7",
- " stat /d/h want errNotExist",
- " stat /d/m want dir",
- " stat /d/m/p want 5",
- " find / /a /d /d/e /d/f /d/g /d/m /d/m/p",
- "rm-all /d want ok",
- " stat /a want 1",
- " stat /d want errNotExist",
- " stat /d/e want errNotExist",
- " stat /d/f want errNotExist",
- " stat /d/g want errNotExist",
- " stat /d/m want errNotExist",
- " stat /d/m/p want errNotExist",
- " find / /a",
- "mk-dir /d/m want errNotExist",
- "mk-dir /d want ok",
- "create /d/f FFFF want ok",
- "rm-all /d/f want ok",
- "mk-dir /d/m want ok",
- "rm-all /z want ok",
- "rm-all / want err",
- "create /b BB want ok",
- " stat / want dir",
- " stat /a want 1",
- " stat /b want 2",
- " stat /c want errNotExist",
- " stat /d want dir",
- " stat /d/m want dir",
- " find / /a /b /d /d/m",
- "move__ o=F /b /c want ok",
- " stat /b want errNotExist",
- " stat /c want 2",
- " stat /d/m want dir",
- " stat /d/n want errNotExist",
- " find / /a /c /d /d/m",
- "move__ o=F /d/m /d/n want ok",
- "create /d/n/q QQQQ want ok",
- " stat /d/m want errNotExist",
- " stat /d/n want dir",
- " stat /d/n/q want 4",
- "move__ o=F /d /d/n/z want err",
- "move__ o=T /c /d/n/q want ok",
- " stat /c want errNotExist",
- " stat /d/n/q want 2",
- " find / /a /d /d/n /d/n/q",
- "create /d/n/r RRRRR want ok",
- "mk-dir /u want ok",
- "mk-dir /u/v want ok",
- "move__ o=F /d/n /u want errExist",
- "create /t TTTTTT want ok",
- "move__ o=F /d/n /t want errExist",
- "rm-all /t want ok",
- "move__ o=F /d/n /t want ok",
- " stat /d want dir",
- " stat /d/n want errNotExist",
- " stat /d/n/r want errNotExist",
- " stat /t want dir",
- " stat /t/q want 2",
- " stat /t/r want 5",
- " find / /a /d /t /t/q /t/r /u /u/v",
- "move__ o=F /t / want errExist",
- "move__ o=T /t /u/v want ok",
- " stat /u/v/r want 5",
- "move__ o=F / /z want err",
- " find / /a /d /u /u/v /u/v/q /u/v/r",
- " stat /a want 1",
- " stat /b want errNotExist",
- " stat /c want errNotExist",
- " stat /u/v/r want 5",
- "copy__ o=F d=0 /a /b want ok",
- "copy__ o=T d=0 /a /c want ok",
- " stat /a want 1",
- " stat /b want 1",
- " stat /c want 1",
- " stat /u/v/r want 5",
- "copy__ o=F d=0 /u/v/r /b want errExist",
- " stat /b want 1",
- "copy__ o=T d=0 /u/v/r /b want ok",
- " stat /a want 1",
- " stat /b want 5",
- " stat /u/v/r want 5",
- "rm-all /a want ok",
- "rm-all /b want ok",
- "mk-dir /u/v/w want ok",
- "create /u/v/w/s SSSSSSSS want ok",
- " stat /d want dir",
- " stat /d/x want errNotExist",
- " stat /d/y want errNotExist",
- " stat /u/v/r want 5",
- " stat /u/v/w/s want 8",
- " find / /c /d /u /u/v /u/v/q /u/v/r /u/v/w /u/v/w/s",
- "copy__ o=T d=0 /u/v /d/x want ok",
- "copy__ o=T d=∞ /u/v /d/y want ok",
- "rm-all /u want ok",
- " stat /d/x want dir",
- " stat /d/x/q want errNotExist",
- " stat /d/x/r want errNotExist",
- " stat /d/x/w want errNotExist",
- " stat /d/x/w/s want errNotExist",
- " stat /d/y want dir",
- " stat /d/y/q want 2",
- " stat /d/y/r want 5",
- " stat /d/y/w want dir",
- " stat /d/y/w/s want 8",
- " stat /u want errNotExist",
- " find / /c /d /d/x /d/y /d/y/q /d/y/r /d/y/w /d/y/w/s",
- "copy__ o=F d=∞ /d/y /d/x want errExist",
- }
-
- ctx := context.Background()
-
- for i, tc := range testCases {
- tc = strings.TrimSpace(tc)
- 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":
- parts := strings.Split(arg, " ")
- if len(parts) != 4 || parts[2] != "want" {
- t.Fatalf("test case #%d %q: invalid write", i, tc)
- }
- f, opErr := fs.OpenFile(ctx, parts[0], os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if got := errStr(opErr); got != parts[3] {
- t.Fatalf("test case #%d %q: OpenFile: got %q (%v), want %q", i, tc, got, opErr, parts[3])
- }
- if f != nil {
- if _, err := f.Write([]byte(parts[1])); err != nil {
- t.Fatalf("test case #%d %q: Write: %v", i, tc, err)
- }
- if err := f.Close(); err != nil {
- t.Fatalf("test case #%d %q: Close: %v", i, tc, err)
- }
- }
-
- case "find":
- got, err := find(ctx, nil, fs, "/")
- if err != nil {
- t.Fatalf("test case #%d %q: find: %v", i, tc, err)
- }
- sort.Strings(got)
- want := strings.Split(arg, " ")
- if !reflect.DeepEqual(got, want) {
- t.Fatalf("test case #%d %q:\ngot %s\nwant %s", i, tc, got, want)
- }
-
- case "copy__", "mk-dir", "move__", "rm-all", "stat":
- nParts := 3
- switch op {
- case "copy__":
- nParts = 6
- case "move__":
- nParts = 5
- }
- parts := strings.Split(arg, " ")
- if len(parts) != nParts {
- t.Fatalf("test case #%d %q: invalid %s", i, tc, op)
- }
-
- got, opErr := "", error(nil)
- switch op {
- case "copy__":
- depth := 0
- if parts[1] == "d=∞" {
- depth = infiniteDepth
- }
- _, opErr = copyFiles(ctx, fs, parts[2], parts[3], parts[0] == "o=T", depth, 0)
- case "mk-dir":
- opErr = fs.Mkdir(ctx, parts[0], 0777)
- case "move__":
- _, opErr = moveFiles(ctx, fs, parts[1], parts[2], parts[0] == "o=T")
- case "rm-all":
- opErr = fs.RemoveAll(ctx, parts[0])
- case "stat":
- var stat os.FileInfo
- fileName := parts[0]
- if stat, opErr = fs.Stat(ctx, fileName); opErr == nil {
- if stat.IsDir() {
- got = "dir"
- } else {
- got = strconv.Itoa(int(stat.Size()))
- }
-
- if fileName == "/" {
- // For a Dir FileSystem, the virtual file system root maps to a
- // real file system name like "/tmp/webdav-test012345", which does
- // not end with "/". We skip such cases.
- } else if statName := stat.Name(); path.Base(fileName) != statName {
- t.Fatalf("test case #%d %q: file name %q inconsistent with stat name %q",
- i, tc, fileName, statName)
- }
- }
- }
- if got == "" {
- got = errStr(opErr)
- }
-
- if parts[len(parts)-2] != "want" {
- t.Fatalf("test case #%d %q: invalid %s", i, tc, op)
- }
- if want := parts[len(parts)-1]; got != want {
- t.Fatalf("test case #%d %q: got %q (%v), want %q", i, tc, got, opErr, want)
- }
- }
- }
-}
-
-func TestDir(t *testing.T) {
- switch runtime.GOOS {
- case "nacl":
- t.Skip("see golang.org/issue/12004")
- case "plan9":
- t.Skip("see golang.org/issue/11453")
- }
-
- td, err := ioutil.TempDir("", "webdav-test")
- if err != nil {
- t.Fatal(err)
- }
- defer os.RemoveAll(td)
- testFS(t, Dir(td))
-}
-
-func TestMemFS(t *testing.T) {
- testFS(t, NewMemFS())
-}
-
-func TestMemFSRoot(t *testing.T) {
- ctx := context.Background()
- fs := NewMemFS()
- for i := 0; i < 5; i++ {
- stat, err := fs.Stat(ctx, "/")
- if err != nil {
- t.Fatalf("i=%d: Stat: %v", i, err)
- }
- if !stat.IsDir() {
- t.Fatalf("i=%d: Stat.IsDir is false, want true", i)
- }
-
- f, err := fs.OpenFile(ctx, "/", os.O_RDONLY, 0)
- if err != nil {
- t.Fatalf("i=%d: OpenFile: %v", i, err)
- }
- defer f.Close()
- children, err := f.Readdir(-1)
- if err != nil {
- t.Fatalf("i=%d: Readdir: %v", i, err)
- }
- if len(children) != i {
- t.Fatalf("i=%d: got %d children, want %d", i, len(children), i)
- }
-
- if _, err := f.Write(make([]byte, 1)); err == nil {
- t.Fatalf("i=%d: Write: got nil error, want non-nil", i)
- }
-
- if err := fs.Mkdir(ctx, fmt.Sprintf("/dir%d", i), 0777); err != nil {
- t.Fatalf("i=%d: Mkdir: %v", i, err)
- }
- }
-}
-
-func TestMemFileReaddir(t *testing.T) {
- ctx := context.Background()
- fs := NewMemFS()
- if err := fs.Mkdir(ctx, "/foo", 0777); err != nil {
- t.Fatalf("Mkdir: %v", err)
- }
- readdir := func(count int) ([]os.FileInfo, error) {
- f, err := fs.OpenFile(ctx, "/foo", os.O_RDONLY, 0)
- if err != nil {
- t.Fatalf("OpenFile: %v", err)
- }
- defer f.Close()
- return f.Readdir(count)
- }
- if got, err := readdir(-1); len(got) != 0 || err != nil {
- t.Fatalf("readdir(-1): got %d fileInfos with err=%v, want 0, ", len(got), err)
- }
- if got, err := readdir(+1); len(got) != 0 || err != io.EOF {
- t.Fatalf("readdir(+1): got %d fileInfos with err=%v, want 0, EOF", len(got), err)
- }
-}
-
-func TestMemFile(t *testing.T) {
- testCases := []string{
- "wantData ",
- "wantSize 0",
- "write abc",
- "wantData abc",
- "write de",
- "wantData abcde",
- "wantSize 5",
- "write 5*x",
- "write 4*y+2*z",
- "write 3*st",
- "wantData abcdexxxxxyyyyzzststst",
- "wantSize 22",
- "seek set 4 want 4",
- "write EFG",
- "wantData abcdEFGxxxyyyyzzststst",
- "wantSize 22",
- "seek set 2 want 2",
- "read cdEF",
- "read Gx",
- "seek cur 0 want 8",
- "seek cur 2 want 10",
- "seek cur -1 want 9",
- "write J",
- "wantData abcdEFGxxJyyyyzzststst",
- "wantSize 22",
- "seek cur -4 want 6",
- "write ghijk",
- "wantData abcdEFghijkyyyzzststst",
- "wantSize 22",
- "read yyyz",
- "seek cur 0 want 15",
- "write ",
- "seek cur 0 want 15",
- "read ",
- "seek cur 0 want 15",
- "seek end -3 want 19",
- "write ZZ",
- "wantData abcdEFghijkyyyzzstsZZt",
- "wantSize 22",
- "write 4*A",
- "wantData abcdEFghijkyyyzzstsZZAAAA",
- "wantSize 25",
- "seek end 0 want 25",
- "seek end -5 want 20",
- "read Z+4*A",
- "write 5*B",
- "wantData abcdEFghijkyyyzzstsZZAAAABBBBB",
- "wantSize 30",
- "seek end 10 want 40",
- "write C",
- "wantData abcdEFghijkyyyzzstsZZAAAABBBBB..........C",
- "wantSize 41",
- "write D",
- "wantData abcdEFghijkyyyzzstsZZAAAABBBBB..........CD",
- "wantSize 42",
- "seek set 43 want 43",
- "write E",
- "wantData abcdEFghijkyyyzzstsZZAAAABBBBB..........CD.E",
- "wantSize 44",
- "seek set 0 want 0",
- "write 5*123456789_",
- "wantData 123456789_123456789_123456789_123456789_123456789_",
- "wantSize 50",
- "seek cur 0 want 50",
- "seek cur -99 want err",
- }
-
- ctx := context.Background()
-
- const filename = "/foo"
- fs := NewMemFS()
- f, err := fs.OpenFile(ctx, filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if err != nil {
- t.Fatalf("OpenFile: %v", err)
- }
- defer f.Close()
-
- 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:]
-
- // Expand an arg like "3*a+2*b" to "aaabb".
- parts := strings.Split(arg, "+")
- for j, part := range parts {
- if k := strings.IndexByte(part, '*'); k >= 0 {
- repeatCount, repeatStr := part[:k], part[k+1:]
- n, err := strconv.Atoi(repeatCount)
- if err != nil {
- t.Fatalf("test case #%d %q: invalid repeat count %q", i, tc, repeatCount)
- }
- parts[j] = strings.Repeat(repeatStr, n)
- }
- }
- arg = strings.Join(parts, "")
-
- switch op {
- default:
- t.Fatalf("test case #%d %q: invalid operation %q", i, tc, op)
-
- case "read":
- buf := make([]byte, len(arg))
- if _, err := io.ReadFull(f, buf); err != nil {
- t.Fatalf("test case #%d %q: ReadFull: %v", i, tc, err)
- }
- if got := string(buf); got != arg {
- t.Fatalf("test case #%d %q:\ngot %q\nwant %q", i, tc, got, arg)
- }
-
- case "seek":
- parts := strings.Split(arg, " ")
- if len(parts) != 4 {
- t.Fatalf("test case #%d %q: invalid seek", i, tc)
- }
-
- whence := 0
- switch parts[0] {
- default:
- t.Fatalf("test case #%d %q: invalid seek whence", i, tc)
- case "set":
- whence = os.SEEK_SET
- case "cur":
- whence = os.SEEK_CUR
- case "end":
- whence = os.SEEK_END
- }
- offset, err := strconv.Atoi(parts[1])
- if err != nil {
- t.Fatalf("test case #%d %q: invalid offset %q", i, tc, parts[1])
- }
-
- if parts[2] != "want" {
- t.Fatalf("test case #%d %q: invalid seek", i, tc)
- }
- if parts[3] == "err" {
- _, err := f.Seek(int64(offset), whence)
- if err == nil {
- t.Fatalf("test case #%d %q: Seek returned nil error, want non-nil", i, tc)
- }
- } else {
- got, err := f.Seek(int64(offset), whence)
- if err != nil {
- t.Fatalf("test case #%d %q: Seek: %v", i, tc, err)
- }
- want, err := strconv.Atoi(parts[3])
- if err != nil {
- t.Fatalf("test case #%d %q: invalid want %q", i, tc, parts[3])
- }
- if got != int64(want) {
- t.Fatalf("test case #%d %q: got %d, want %d", i, tc, got, want)
- }
- }
-
- case "write":
- n, err := f.Write([]byte(arg))
- if err != nil {
- t.Fatalf("test case #%d %q: write: %v", i, tc, err)
- }
- if n != len(arg) {
- t.Fatalf("test case #%d %q: write returned %d bytes, want %d", i, tc, n, len(arg))
- }
-
- case "wantData":
- g, err := fs.OpenFile(ctx, filename, os.O_RDONLY, 0666)
- if err != nil {
- t.Fatalf("test case #%d %q: OpenFile: %v", i, tc, err)
- }
- gotBytes, err := ioutil.ReadAll(g)
- if err != nil {
- t.Fatalf("test case #%d %q: ReadAll: %v", i, tc, err)
- }
- for i, c := range gotBytes {
- if c == '\x00' {
- gotBytes[i] = '.'
- }
- }
- got := string(gotBytes)
- if got != arg {
- t.Fatalf("test case #%d %q:\ngot %q\nwant %q", i, tc, got, arg)
- }
- if err := g.Close(); err != nil {
- t.Fatalf("test case #%d %q: Close: %v", i, tc, err)
- }
-
- case "wantSize":
- n, err := strconv.Atoi(arg)
- if err != nil {
- t.Fatalf("test case #%d %q: invalid size %q", i, tc, arg)
- }
- fi, err := fs.Stat(ctx, filename)
- if err != nil {
- t.Fatalf("test case #%d %q: Stat: %v", i, tc, err)
- }
- if got, want := fi.Size(), int64(n); got != want {
- t.Fatalf("test case #%d %q: got %d, want %d", i, tc, got, want)
- }
- }
- }
-}
-
-// TestMemFileWriteAllocs tests that writing N consecutive 1KiB chunks to a
-// memFile doesn't allocate a new buffer for each of those N times. Otherwise,
-// calling io.Copy(aMemFile, src) is likely to have quadratic complexity.
-func TestMemFileWriteAllocs(t *testing.T) {
- if runtime.Compiler == "gccgo" {
- t.Skip("gccgo allocates here")
- }
- ctx := context.Background()
- fs := NewMemFS()
- f, err := fs.OpenFile(ctx, "/xxx", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if err != nil {
- t.Fatalf("OpenFile: %v", err)
- }
- defer f.Close()
-
- xxx := make([]byte, 1024)
- for i := range xxx {
- xxx[i] = 'x'
- }
-
- a := testing.AllocsPerRun(100, func() {
- f.Write(xxx)
- })
- // AllocsPerRun returns an integral value, so we compare the rounded-down
- // number to zero.
- if a > 0 {
- t.Fatalf("%v allocs per run, want 0", a)
- }
-}
-
-func BenchmarkMemFileWrite(b *testing.B) {
- ctx := context.Background()
- fs := NewMemFS()
- xxx := make([]byte, 1024)
- for i := range xxx {
- xxx[i] = 'x'
- }
-
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- f, err := fs.OpenFile(ctx, "/xxx", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if err != nil {
- b.Fatalf("OpenFile: %v", err)
- }
- for j := 0; j < 100; j++ {
- f.Write(xxx)
- }
- if err := f.Close(); err != nil {
- b.Fatalf("Close: %v", err)
- }
- if err := fs.RemoveAll(ctx, "/xxx"); err != nil {
- b.Fatalf("RemoveAll: %v", err)
- }
- }
-}
-
-func TestCopyMoveProps(t *testing.T) {
- ctx := context.Background()
- fs := NewMemFS()
- create := func(name string) error {
- f, err := fs.OpenFile(ctx, name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if err != nil {
- return err
- }
- _, wErr := f.Write([]byte("contents"))
- cErr := f.Close()
- if wErr != nil {
- return wErr
- }
- return cErr
- }
- patch := func(name string, patches ...Proppatch) error {
- f, err := fs.OpenFile(ctx, name, os.O_RDWR, 0666)
- if err != nil {
- return err
- }
- _, pErr := f.(DeadPropsHolder).Patch(patches)
- cErr := f.Close()
- if pErr != nil {
- return pErr
- }
- return cErr
- }
- props := func(name string) (map[xml.Name]Property, error) {
- f, err := fs.OpenFile(ctx, name, os.O_RDWR, 0666)
- if err != nil {
- return nil, err
- }
- m, pErr := f.(DeadPropsHolder).DeadProps()
- cErr := f.Close()
- if pErr != nil {
- return nil, pErr
- }
- if cErr != nil {
- return nil, cErr
- }
- return m, nil
- }
-
- p0 := Property{
- XMLName: xml.Name{Space: "x:", Local: "boat"},
- InnerXML: []byte("pea-green"),
- }
- p1 := Property{
- XMLName: xml.Name{Space: "x:", Local: "ring"},
- InnerXML: []byte("1 shilling"),
- }
- p2 := Property{
- XMLName: xml.Name{Space: "x:", Local: "spoon"},
- InnerXML: []byte("runcible"),
- }
- p3 := Property{
- XMLName: xml.Name{Space: "x:", Local: "moon"},
- InnerXML: []byte("light"),
- }
-
- if err := create("/src"); err != nil {
- t.Fatalf("create /src: %v", err)
- }
- if err := patch("/src", Proppatch{Props: []Property{p0, p1}}); err != nil {
- t.Fatalf("patch /src +p0 +p1: %v", err)
- }
- if _, err := copyFiles(ctx, fs, "/src", "/tmp", true, infiniteDepth, 0); err != nil {
- t.Fatalf("copyFiles /src /tmp: %v", err)
- }
- if _, err := moveFiles(ctx, fs, "/tmp", "/dst", true); err != nil {
- t.Fatalf("moveFiles /tmp /dst: %v", err)
- }
- if err := patch("/src", Proppatch{Props: []Property{p0}, Remove: true}); err != nil {
- t.Fatalf("patch /src -p0: %v", err)
- }
- if err := patch("/src", Proppatch{Props: []Property{p2}}); err != nil {
- t.Fatalf("patch /src +p2: %v", err)
- }
- if err := patch("/dst", Proppatch{Props: []Property{p1}, Remove: true}); err != nil {
- t.Fatalf("patch /dst -p1: %v", err)
- }
- if err := patch("/dst", Proppatch{Props: []Property{p3}}); err != nil {
- t.Fatalf("patch /dst +p3: %v", err)
- }
-
- gotSrc, err := props("/src")
- if err != nil {
- t.Fatalf("props /src: %v", err)
- }
- wantSrc := map[xml.Name]Property{
- p1.XMLName: p1,
- p2.XMLName: p2,
- }
- if !reflect.DeepEqual(gotSrc, wantSrc) {
- t.Fatalf("props /src:\ngot %v\nwant %v", gotSrc, wantSrc)
- }
-
- gotDst, err := props("/dst")
- if err != nil {
- t.Fatalf("props /dst: %v", err)
- }
- wantDst := map[xml.Name]Property{
- p0.XMLName: p0,
- p3.XMLName: p3,
- }
- if !reflect.DeepEqual(gotDst, wantDst) {
- t.Fatalf("props /dst:\ngot %v\nwant %v", gotDst, wantDst)
- }
-}
-
-func TestWalkFS(t *testing.T) {
- testCases := []struct {
- desc string
- buildfs []string
- startAt string
- depth int
- walkFn filepath.WalkFunc
- want []string
- }{{
- "just root",
- []string{},
- "/",
- infiniteDepth,
- nil,
- []string{
- "/",
- },
- }, {
- "infinite walk from root",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/d",
- "mkdir /e",
- "touch /f",
- },
- "/",
- infiniteDepth,
- nil,
- []string{
- "/",
- "/a",
- "/a/b",
- "/a/b/c",
- "/a/d",
- "/e",
- "/f",
- },
- }, {
- "infinite walk from subdir",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/d",
- "mkdir /e",
- "touch /f",
- },
- "/a",
- infiniteDepth,
- nil,
- []string{
- "/a",
- "/a/b",
- "/a/b/c",
- "/a/d",
- },
- }, {
- "depth 1 walk from root",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/d",
- "mkdir /e",
- "touch /f",
- },
- "/",
- 1,
- nil,
- []string{
- "/",
- "/a",
- "/e",
- "/f",
- },
- }, {
- "depth 1 walk from subdir",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/b/g",
- "mkdir /a/b/g/h",
- "touch /a/b/g/i",
- "touch /a/b/g/h/j",
- },
- "/a/b",
- 1,
- nil,
- []string{
- "/a/b",
- "/a/b/c",
- "/a/b/g",
- },
- }, {
- "depth 0 walk from subdir",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/b/g",
- "mkdir /a/b/g/h",
- "touch /a/b/g/i",
- "touch /a/b/g/h/j",
- },
- "/a/b",
- 0,
- nil,
- []string{
- "/a/b",
- },
- }, {
- "infinite walk from file",
- []string{
- "mkdir /a",
- "touch /a/b",
- "touch /a/c",
- },
- "/a/b",
- 0,
- nil,
- []string{
- "/a/b",
- },
- }, {
- "infinite walk with skipped subdir",
- []string{
- "mkdir /a",
- "mkdir /a/b",
- "touch /a/b/c",
- "mkdir /a/b/g",
- "mkdir /a/b/g/h",
- "touch /a/b/g/i",
- "touch /a/b/g/h/j",
- "touch /a/b/z",
- },
- "/",
- infiniteDepth,
- func(path string, info os.FileInfo, err error) error {
- if path == "/a/b/g" {
- return filepath.SkipDir
- }
- return nil
- },
- []string{
- "/",
- "/a",
- "/a/b",
- "/a/b/c",
- "/a/b/z",
- },
- }}
- ctx := context.Background()
- for _, tc := range testCases {
- fs, err := buildTestFS(tc.buildfs)
- if err != nil {
- t.Fatalf("%s: cannot create test filesystem: %v", tc.desc, err)
- }
- var got []string
- traceFn := func(path string, info os.FileInfo, err error) error {
- if tc.walkFn != nil {
- err = tc.walkFn(path, info, err)
- if err != nil {
- return err
- }
- }
- got = append(got, path)
- return nil
- }
- fi, err := fs.Stat(ctx, tc.startAt)
- if err != nil {
- t.Fatalf("%s: cannot stat: %v", tc.desc, err)
- }
- err = walkFS(ctx, fs, tc.depth, tc.startAt, fi, traceFn)
- if err != nil {
- t.Errorf("%s:\ngot error %v, want nil", tc.desc, err)
- continue
- }
- sort.Strings(got)
- sort.Strings(tc.want)
- if !reflect.DeepEqual(got, tc.want) {
- t.Errorf("%s:\ngot %q\nwant %q", tc.desc, got, tc.want)
- continue
- }
- }
-}
-
-func buildTestFS(buildfs []string) (FileSystem, error) {
- // TODO: Could this be merged with the build logic in TestFS?
-
- ctx := context.Background()
- fs := NewMemFS()
- for _, b := range buildfs {
- op := strings.Split(b, " ")
- switch op[0] {
- case "mkdir":
- err := fs.Mkdir(ctx, op[1], os.ModeDir|0777)
- if err != nil {
- return nil, err
- }
- case "touch":
- f, err := fs.OpenFile(ctx, op[1], os.O_RDWR|os.O_CREATE, 0666)
- if err != nil {
- return nil, err
- }
- f.Close()
- case "write":
- f, err := fs.OpenFile(ctx, op[1], os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
- if err != nil {
- return nil, err
- }
- _, err = f.Write([]byte(op[2]))
- f.Close()
- if err != nil {
- return nil, err
- }
- default:
- return nil, fmt.Errorf("unknown file operation %q", op[0])
- }
- }
- return fs, nil
-}
diff --git a/go.mod b/go.mod
index 9c3a1b7..5aee758 100644
--- a/go.mod
+++ b/go.mod
@@ -1,8 +1,3 @@
module github.com/emersion/go-webdav
go 1.13
-
-require (
- github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5
- golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553
-)
diff --git a/go.sum b/go.sum
deleted file mode 100644
index c48bd9c..0000000
--- a/go.sum
+++ /dev/null
@@ -1,7 +0,0 @@
-github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5 h1:n9qx98xiS5V4x2WIpPC2rr9mUM5ri9r/YhCEKbhCHro=
-github.com/emersion/go-vcard v0.0.0-20190105225839-8856043f13c5/go.mod h1:WIi9g8OKJQHXtQbx7GExlo6UAFaui9WDMYabJ+Be4WI=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 h1:efeOvDhwQ29Dj3SdAV/MJf8oukgn+8D8WgaCaRMchF8=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
diff --git a/if.go b/if.go
deleted file mode 100644
index 416e81c..0000000
--- a/if.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-// 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:]
-}
diff --git a/if_test.go b/if_test.go
deleted file mode 100644
index aad61a4..0000000
--- a/if_test.go
+++ /dev/null
@@ -1,322 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "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",
- ``,
- ifHeader{},
- }, {
- "bad: no list after resource #2",
- ` (a)`,
- ifHeader{},
- }, {
- "bad: no list after resource #3",
- ` (a) (b) `,
- ifHeader{},
- }, {
- "bad: no-tag-list followed by tagged-list",
- `(a) (b) (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",
- `
- ()`,
- 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",
- `()`,
- ifHeader{
- lists: []ifList{{
- conditions: []Condition{{
- Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
- }},
- }},
- },
- }, {
- "section 7.5.2 #2",
- `
- ()`,
- ifHeader{
- lists: []ifList{{
- resourceTag: `http://example.com/locked/`,
- conditions: []Condition{{
- Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
- }},
- }},
- },
- }, {
- "section 7.5.2 #3",
- `
- ()`,
- ifHeader{
- lists: []ifList{{
- resourceTag: `http://example.com/locked/member`,
- conditions: []Condition{{
- Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
- }},
- }},
- },
- }, {
- "section 9.9.6",
- `()
- ()`,
- 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",
- `()`,
- ifHeader{
- lists: []ifList{{
- conditions: []Condition{{
- Token: `urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4`,
- }},
- }},
- },
- }, {
- "section 10.4.6",
- `(
- ["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
- )`,
- 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",
- `()
- (Not )`,
- 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",
- `
- (
- [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",
- `
- ()`,
- ifHeader{
- lists: []ifList{{
- resourceTag: `http://www.example.com/specs/`,
- conditions: []Condition{{
- Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
- }},
- }},
- },
- }, {
- "section 10.4.11 #1",
- ` (["4217"])`,
- ifHeader{
- lists: []ifList{{
- resourceTag: `/specs/rfc2518.doc`,
- conditions: []Condition{{
- ETag: `"4217"`,
- }},
- }},
- },
- }, {
- "section 10.4.11 #2",
- ` (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
- }
- }
-}
diff --git a/litmus_test_server.go b/litmus_test_server.go
deleted file mode 100644
index 514db5d..0000000
--- a/litmus_test_server.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// 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))
-}
diff --git a/lock.go b/lock.go
deleted file mode 100644
index 344ac5c..0000000
--- a/lock.go
+++ /dev/null
@@ -1,445 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "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 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
-}
diff --git a/lock_test.go b/lock_test.go
deleted file mode 100644
index 116d6c0..0000000
--- a/lock_test.go
+++ /dev/null
@@ -1,731 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "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)
- }
- }
-}
diff --git a/prop.go b/prop.go
deleted file mode 100644
index 0ef0f67..0000000
--- a/prop.go
+++ /dev/null
@@ -1,416 +0,0 @@
-// 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,
- },
-}
-
-// 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: ``,
- }
- 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 ``, 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 `` +
- `` +
- `` +
- `` +
- ``, nil
-}
diff --git a/prop_test.go b/prop_test.go
deleted file mode 100644
index 3c155a5..0000000
--- a/prop_test.go
+++ /dev/null
@@ -1,613 +0,0 @@
-// 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 = `` +
- `` +
- `` +
- `` +
- ``
- statForbiddenError = ``
- )
-
- 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(``),
- }, {
- 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(``),
- }},
- }},
- }, {
- 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) }
diff --git a/server.go b/server.go
deleted file mode 100644
index 9cba726..0000000
--- a/server.go
+++ /dev/null
@@ -1,725 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "errors"
- "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 {
- 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, PUT, MKCOL"
- if h.LockSystem != nil {
- allow += ", LOCK"
- }
- if fi, err := h.FileSystem.Stat(ctx, reqPath); err == nil {
- if fi.IsDir() {
- allow = "OPTIONS, DELETE, PROPPATCH, COPY, MOVE, PROPFIND"
- } else {
- allow = "OPTIONS, GET, HEAD, POST, DELETE, PROPPATCH, COPY, MOVE, PROPFIND, PUT"
- }
- if h.LockSystem != nil {
- allow += ", LOCK, UNLOCK"
- }
- }
- w.Header().Add("Allow", allow)
-
- // http://www.webdav.org/specs/rfc4918.html#dav.compliance.classes
- dav := "1"
- if h.LockSystem != nil {
- dav += ", 2"
- }
- w.Header().Add("DAV", dav)
-
- // 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.
- // TODO: use getcontenttype dead prop if available
- 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
- }
- if h.LockSystem != nil {
- 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
- }
- if h.LockSystem != nil {
- 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)
- closeErr := f.Close()
- fi, statErr := f.Stat()
- // TODO(rost): Returning 405 Method Not Allowed might not be appropriate.
- if copyErr != nil {
- return http.StatusMethodNotAllowed, copyErr
- }
- if closeErr != nil {
- return http.StatusMethodNotAllowed, closeErr
- }
- if statErr != nil {
- return http.StatusMethodNotAllowed, statErr
- }
-
- if path.Base(reqPath) != fi.Name() {
- w.Header().Set("Location", path.Join(path.Dir(reqPath), fi.Name()))
- }
-
- 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
- }
- if h.LockSystem != nil {
- 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.
- if h.LockSystem != nil {
- 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)
- }
-
- if h.LockSystem != nil {
- 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) {
- if h.LockSystem == nil {
- return http.StatusMethodNotAllowed, errNoLockSystem
- }
-
- 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) {
- if h.LockSystem == nil {
- return http.StatusMethodNotAllowed, errNoLockSystem
- }
-
- // 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
- }
- if h.LockSystem != nil {
- 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 {
- return &Response{
- Href: []string{(&url.URL{Path: href}).EscapedPath()},
- Propstat: pstats,
- }
-}
-
-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")
-)
diff --git a/webdav.go b/webdav.go
deleted file mode 100644
index 8a11821..0000000
--- a/webdav.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package webdav provides a WebDAV implementation, as defined in RFC 4918.
-package webdav
diff --git a/webdav_test.go b/webdav_test.go
deleted file mode 100644
index b03a025..0000000
--- a/webdav_test.go
+++ /dev/null
@@ -1,344 +0,0 @@
-// 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 = `
-
-
-
-
- http://example.org/~ejw/contact.html
-
-
- `
-
- 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",
- "&": "&",
- "foo&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(`([^<]*)`)
- displayNameRe := regexp.MustCompile(`([^<]*)`)
- 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: `/goexclusive"`
- 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, "\n"+
- "\n"+
- " \n"+
- " \n"+
- " %s\n"+
- " %s\n"+
- " Second-%d\n"+
- " %s\n"+
- " %s\n"+
- "",
- 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 := t.(type) {
- case xml.Comment, xml.Directive, xml.ProcInst:
- continue
- case xml.CharData:
- for _, c := range t {
- if !unicode.IsSpace(rune(c)) {
- return t, fmt.Errorf("unexpected non-empty xml.CharData")
- }
- }
- default:
- return t, nil
- }
- }
-}
-
-// TODO: the xml.Name isn't enough, enclosed elements matter too (e.g.
-// CardDAV's address-data)
-
-// 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
- if err := d.Skip(); err != nil {
- return err
- }
- *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
-type xmlError struct {
- XMLName xml.Name `xml:"DAV: error"`
- InnerXML []byte `xml:",innerxml"`
-}
-
-// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
-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"`
-}
-
-// http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
-type Response struct {
- Href []string
- Propstat []Propstat
- Status int
- XMLError string
- ResponseDescription string
-}
-
-// http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
-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
-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
-}
-
-func NewMultistatusWriter(w http.ResponseWriter) *MultistatusWriter {
- return &MultistatusWriter{w: w}
-}
-
-// 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 {
- rr := &response{
- Href: r.Href,
- Propstat: make([]propstat, 0, len(r.Propstat)),
- }
-
- for _, p := range r.Propstat {
- var xmlErr *xmlError
- if p.XMLError != "" {
- xmlErr = &xmlError{InnerXML: []byte(p.XMLError)}
- }
- rr.Propstat = append(rr.Propstat, propstat{
- Status: fmt.Sprintf("HTTP/1.1 %d %s", p.Status, StatusText(p.Status)),
- Prop: p.Props,
- ResponseDescription: p.ResponseDescription,
- Error: xmlErr,
- })
- }
-
- return w.write(rr)
-}
-
-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
-}
diff --git a/xml_test.go b/xml_test.go
deleted file mode 100644
index 68b0d60..0000000
--- a/xml_test.go
+++ /dev/null
@@ -1,904 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package webdav
-
-import (
- "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",
- "" +
- "\n" +
- " \n" +
- " \n" +
- " \n" +
- " no end tag \n" +
- " \n" +
- "",
- lockInfo{},
- http.StatusBadRequest,
- }, {
- "bad: invalid UTF-8",
- "" +
- "\n" +
- " \n" +
- " \n" +
- " \n" +
- " \xff \n" +
- " \n" +
- "",
- lockInfo{},
- http.StatusBadRequest,
- }, {
- "bad: unfinished XML #1",
- "" +
- "\n" +
- " \n" +
- " \n",
- lockInfo{},
- http.StatusBadRequest,
- }, {
- "bad: unfinished XML #2",
- "" +
- "\n" +
- " \n" +
- " \n" +
- " \n",
- lockInfo{},
- http.StatusBadRequest,
- }, {
- "good: empty",
- "",
- lockInfo{},
- 0,
- }, {
- "good: plain-text owner",
- "" +
- "\n" +
- " \n" +
- " \n" +
- " gopher\n" +
- "",
- lockInfo{
- XMLName: xml.Name{Space: "DAV:", Local: "lockinfo"},
- Exclusive: new(struct{}),
- Write: new(struct{}),
- Owner: owner{
- InnerXML: "gopher",
- },
- },
- 0,
- }, {
- "section 9.10.7",
- "" +
- "\n" +
- " \n" +
- " \n" +
- " \n" +
- " http://example.org/~ejw/contact.html\n" +
- " \n" +
- "",
- lockInfo{
- XMLName: xml.Name{Space: "DAV:", Local: "lockinfo"},
- Exclusive: new(struct{}),
- Write: new(struct{}),
- Owner: owner{
- InnerXML: "\n http://example.org/~ejw/contact.html\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: "" +
- "\n" +
- " \n" +
- "",
- 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: "" +
- "\n" +
- " \n" +
- "",
- wantPF: propfind{
- XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
- Allprop: new(struct{}),
- },
- }, {
- desc: "propfind: allprop followed by include",
- input: "" +
- "\n" +
- " \n" +
- " \n" +
- "",
- 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: "" +
- "\n" +
- " \n" +
- " \n" +
- "",
- wantPF: propfind{
- XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
- Allprop: new(struct{}),
- Include: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
- },
- }, {
- desc: "propfind: propfind",
- input: "" +
- "\n" +
- " \n" +
- "",
- wantPF: propfind{
- XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
- Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
- },
- }, {
- desc: "propfind: prop with ignored comments",
- input: "" +
- "\n" +
- " \n" +
- " \n" +
- " \n" +
- " \n" +
- "",
- wantPF: propfind{
- XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
- Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
- },
- }, {
- desc: "propfind: propfind with ignored whitespace",
- input: "" +
- "\n" +
- " \n" +
- "",
- 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: "" +
- "\n" +
- " foobar\n" +
- "",
- 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: "" +
- "\n" +
- " \n" +
- " *boss*\n" +
- "",
- 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: "" +
- "\n" +
- " " +
- " " +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: propname and prop",
- input: "" +
- "\n" +
- " \n" +
- " \n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: allprop and prop",
- input: "" +
- "\n" +
- " \n" +
- " \n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: empty propfind with ignored element (section A.4)",
- input: "" +
- "\n" +
- " \n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: empty prop",
- input: "" +
- "\n" +
- " \n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: prop with just chardata",
- input: "" +
- "\n" +
- " foo\n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "bad: interrupted prop",
- input: "" +
- "\n" +
- " \n",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "bad: malformed end element prop",
- input: "" +
- "\n" +
- " \n",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: property with chardata value",
- input: "" +
- "\n" +
- " bar\n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: property with whitespace value",
- input: "" +
- "\n" +
- " \n" +
- "",
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "propfind: bad: include without allprop",
- input: "" +
- "\n" +
- " \n" +
- "",
- 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: `` +
- `` +
- `` +
- ` ` +
- ` http://example.com/foo` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` HTTP/1.1 424 Failed Dependency` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` HTTP/1.1 409 Conflict` +
- ` ` +
- ` Copyright Owner cannot be deleted or altered.` +
- `` +
- ``,
- 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(``),
- },
- }},
- wantXML: `` +
- `` +
- `` +
- ` ` +
- ` http://example.com/foo` +
- ` HTTP/1.1 423 Locked` +
- ` ` +
- ` ` +
- ``,
- 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(`` +
- `` +
- `Box type A` +
- ``),
- }, {
- XMLName: xml.Name{Space: "http://ns.example.com/boxschema/", Local: "author"},
- InnerXML: []byte(`` +
- `` +
- `J.J. Johnson` +
- ``),
- }},
- 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: `` +
- `` +
- `` +
- ` ` +
- ` http://example.com/foo` +
- ` ` +
- ` ` +
- ` Box type A` +
- ` J.J. Johnson` +
- ` ` +
- ` HTTP/1.1 200 OK` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` HTTP/1.1 403 Forbidden` +
- ` The user does not have access to the DingALing property.` +
- ` ` +
- ` ` +
- ` There has been an access violation error.` +
- ``,
- 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: ``,
- 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: `` +
- `` +
- `` +
- ` ` +
- ` somevalue` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ``,
- 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: `` +
- `` +
- `` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ` ` +
- ``,
- wantPP: []Proppatch{{
- Props: []Property{{
- xml.Name{Space: "http://example.com/ns", Local: "foo"},
- "en",
- nil,
- }},
- }},
- }, {
- desc: "bad: remove with value",
- input: `` +
- `` +
- `` +
- ` ` +
- ` ` +
- ` ` +
- ` Jim Whitehead` +
- ` ` +
- ` ` +
- ` ` +
- ``,
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "bad: empty propertyupdate",
- input: `` +
- `` +
- ``,
- wantStatus: http.StatusBadRequest,
- }, {
- desc: "bad: empty prop",
- input: `` +
- `` +
- `` +
- ` ` +
- ` ` +
- ` ` +
- ``,
- 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: "foo",
- wantVal: "foo",
- }, {
- desc: "empty element",
- input: "",
- wantVal: "",
- }, {
- desc: "preserve namespace",
- input: ``,
- wantVal: ``,
- }, {
- desc: "preserve root element namespace",
- input: ``,
- wantVal: ``,
- }, {
- desc: "preserve whitespace",
- input: " \t ",
- wantVal: " \t ",
- }, {
- desc: "preserve mixed content",
- input: ` a `,
- wantVal: ` a `,
- }, {
- desc: "section 9.2",
- input: `` +
- `` +
- ` Jim Whitehead` +
- ` Roy Fielding` +
- ``,
- wantVal: `` +
- ` Jim Whitehead` +
- ` Roy Fielding`,
- }, {
- desc: "section 4.3.1 (mixed content)",
- input: `` +
- `` +
- ` Jane Doe` +
- ` ` +
- ` mailto:jane.doe@example.com` +
- ` http://www.example.com` +
- ` ` +
- ` Jane has been working way too long on the` +
- ` long-awaited revision of ]]>.` +
- ` ` +
- ``,
- wantVal: `` +
- ` Jane Doe` +
- ` ` +
- ` mailto:jane.doe@example.com` +
- ` http://www.example.com` +
- ` ` +
- ` Jane has been working way too long on the` +
- ` long-awaited revision of <RFC2518>.` +
- ` `,
- }}
-
- 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
-}