mirror of https://github.com/Xhofe/alist
feat: webdav handle
Noah Hsu
parent
dd013ac0b2
commit
2b1726614b
|
|
@ -0,0 +1,26 @@
|
|||
package utils
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func ClientIP(r *http.Request) string {
|
||||
xForwardedFor := r.Header.Get("X-Forwarded-For")
|
||||
ip := strings.TrimSpace(strings.Split(xForwardedFor, ",")[0])
|
||||
if ip != "" {
|
||||
return ip
|
||||
}
|
||||
|
||||
ip = strings.TrimSpace(r.Header.Get("X-Real-Ip"))
|
||||
if ip != "" {
|
||||
return ip
|
||||
}
|
||||
|
||||
if ip, _, err := net.SplitHostPort(strings.TrimSpace(r.RemoteAddr)); err == nil {
|
||||
return ip
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
|
@ -10,8 +10,12 @@ import (
|
|||
|
||||
func GetBaseUrl(r *http.Request) string {
|
||||
baseUrl := setting.GetByKey(conf.BaseUrl)
|
||||
protocol := "http"
|
||||
if r.TLS != nil {
|
||||
protocol = "https"
|
||||
}
|
||||
if baseUrl == "" {
|
||||
baseUrl = fmt.Sprintf("//%s", r.Host)
|
||||
baseUrl = fmt.Sprintf("%s//%s", protocol, r.Host)
|
||||
}
|
||||
strings.TrimSuffix(baseUrl, "/")
|
||||
return baseUrl
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import (
|
|||
func Init(r *gin.Engine) {
|
||||
common.SecretKey = []byte(conf.Conf.JwtSecret)
|
||||
Cors(r)
|
||||
WebDav(r)
|
||||
|
||||
r.GET("/d/*path", middlewares.Down, controllers.Down)
|
||||
r.GET("/p/*path", middlewares.Down, controllers.Proxy)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,94 @@
|
|||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/alist-org/alist/v3/internal/db"
|
||||
"github.com/alist-org/alist/v3/internal/model"
|
||||
"github.com/alist-org/alist/v3/pkg/utils"
|
||||
"github.com/alist-org/alist/v3/server/webdav"
|
||||
"github.com/gin-gonic/gin"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
var handler *webdav.Handler
|
||||
|
||||
func init() {
|
||||
handler = &webdav.Handler{
|
||||
Prefix: "/dav",
|
||||
LockSystem: webdav.NewMemLS(),
|
||||
Logger: func(request *http.Request, err error) {
|
||||
log.Errorf("%s %s %+v", request.Method, request.URL.Path, err)
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func WebDav(r *gin.Engine) {
|
||||
dav := r.Group("/dav")
|
||||
dav.Use(WebDAVAuth)
|
||||
dav.Any("/*path", ServeWebDAV)
|
||||
dav.Any("", ServeWebDAV)
|
||||
dav.Handle("PROPFIND", "/*path", ServeWebDAV)
|
||||
dav.Handle("PROPFIND", "", ServeWebDAV)
|
||||
dav.Handle("MKCOL", "/*path", ServeWebDAV)
|
||||
dav.Handle("LOCK", "/*path", ServeWebDAV)
|
||||
dav.Handle("UNLOCK", "/*path", ServeWebDAV)
|
||||
dav.Handle("PROPPATCH", "/*path", ServeWebDAV)
|
||||
dav.Handle("COPY", "/*path", ServeWebDAV)
|
||||
dav.Handle("MOVE", "/*path", ServeWebDAV)
|
||||
}
|
||||
|
||||
func ServeWebDAV(c *gin.Context) {
|
||||
user := c.MustGet("user").(*model.User)
|
||||
ctx := context.WithValue(c.Request.Context(), "user", user)
|
||||
handler.ServeHTTP(c.Writer, c.Request.WithContext(ctx))
|
||||
}
|
||||
|
||||
func WebDAVAuth(c *gin.Context) {
|
||||
guest, _ := db.GetGuest()
|
||||
username, password, ok := c.Request.BasicAuth()
|
||||
if !ok {
|
||||
if c.Request.Method == "OPTIONS" {
|
||||
c.Set("user", guest)
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
c.Writer.Header()["WWW-Authenticate"] = []string{`Basic realm="alist"`}
|
||||
c.Status(http.StatusUnauthorized)
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
user, err := db.GetUserByName(username)
|
||||
if err != nil || user.ValidatePassword(password) != nil {
|
||||
if c.Request.Method == "OPTIONS" {
|
||||
c.Set("user", guest)
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusUnauthorized)
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
if !user.CanWebdavRead() {
|
||||
if c.Request.Method == "OPTIONS" {
|
||||
c.Set("user", guest)
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusForbidden)
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
if !user.CanWebdavWrite() && utils.SliceContains([]string{"PUT", "DELETE", "PROPPATCH", "MKCOL", "COPY", "MOVE"}, c.Request.Method) {
|
||||
if c.Request.Method == "OPTIONS" {
|
||||
c.Set("user", guest)
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
c.Status(http.StatusForbidden)
|
||||
c.Abort()
|
||||
return
|
||||
}
|
||||
c.Set("user", user)
|
||||
c.Next()
|
||||
}
|
||||
|
|
@ -6,16 +6,12 @@ package webdav
|
|||
|
||||
import (
|
||||
"context"
|
||||
"encoding/xml"
|
||||
"io"
|
||||
"github.com/alist-org/alist/v3/internal/db"
|
||||
"github.com/alist-org/alist/v3/internal/fs"
|
||||
"github.com/alist-org/alist/v3/internal/model"
|
||||
"net/http"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// slashClean is equivalent to but slightly more efficient than
|
||||
|
|
@ -27,737 +23,37 @@ func slashClean(name string) string {
|
|||
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 runtime.GOOS == "zos" {
|
||||
if flag&os.O_WRONLY != 0 {
|
||||
return nil, os.ErrPermission
|
||||
}
|
||||
} else {
|
||||
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()
|
||||
func moveFiles(ctx context.Context, src, dst string, overwrite bool) (status int, err error) {
|
||||
err = fs.Move(ctx, src, dst)
|
||||
if err != nil {
|
||||
return err
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
props := make([]Property, 0, len(m))
|
||||
for _, prop := range m {
|
||||
props = append(props, prop)
|
||||
}
|
||||
_, err = d.Patch([]Proppatch{{Props: props}})
|
||||
return err
|
||||
// TODO if there are no files copy, should return 204
|
||||
return http.StatusCreated, nil
|
||||
}
|
||||
|
||||
// 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)
|
||||
func copyFiles(ctx context.Context, src, dst string, overwrite bool) (status int, err error) {
|
||||
_, err = fs.Copy(ctx, src, dst)
|
||||
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
|
||||
// TODO if there are no files copy, should return 204
|
||||
return http.StatusCreated, 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.
|
||||
// walkFn returns path.SkipDir, walkFS will skip traversal of this node.
|
||||
func walkFS(ctx context.Context, depth int, name string, info model.Obj, walkFn func(reqPath string, info model.Obj, err error) error) error {
|
||||
// This implementation is based on Walk's code in the standard path/path package.
|
||||
err := walkFn(name, info, nil)
|
||||
if err != nil {
|
||||
if info.IsDir() && err == filepath.SkipDir {
|
||||
|
|
@ -771,27 +67,27 @@ func walkFS(ctx context.Context, fs FileSystem, depth int, name string, info os.
|
|||
if depth == 1 {
|
||||
depth = 0
|
||||
}
|
||||
|
||||
meta, _ := db.GetNearestMeta(name)
|
||||
// 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()
|
||||
objs, err := fs.List(context.WithValue(ctx, "meta", meta), name)
|
||||
//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)
|
||||
for _, fileInfo := range objs {
|
||||
filename := path.Join(name, fileInfo.GetName())
|
||||
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)
|
||||
err = walkFS(ctx, depth, filename, fileInfo, walkFn)
|
||||
if err != nil {
|
||||
if !fileInfo.IsDir() || err != filepath.SkipDir {
|
||||
return err
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -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",
|
||||
`<foo>`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no list after resource #2",
|
||||
`<foo> <bar> (a)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no list after resource #3",
|
||||
`<foo> (a) (b) <bar>`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: no-tag-list followed by tagged-list",
|
||||
`(a) (b) <foo> (c)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished list",
|
||||
`(a`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished ETag",
|
||||
`([b`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: unfinished Notted list",
|
||||
`(Not a`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"bad: double Not",
|
||||
`(Not Not a)`,
|
||||
ifHeader{},
|
||||
}, {
|
||||
"good: one list with a Token",
|
||||
`(a)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `a`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: one list with an ETag",
|
||||
`([a])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
ETag: `a`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: one list with three Nots",
|
||||
`(Not a Not b Not [d])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `a`,
|
||||
}, {
|
||||
Not: true,
|
||||
Token: `b`,
|
||||
}, {
|
||||
Not: true,
|
||||
ETag: `d`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: two lists",
|
||||
`(a) (b)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `a`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Token: `b`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"good: two Notted lists",
|
||||
`(Not a) (Not b)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `a`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `b`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.1",
|
||||
`<http://www.example.com/users/f/fielding/index.html>
|
||||
(<urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://www.example.com/users/f/fielding/index.html`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #1",
|
||||
`(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #2",
|
||||
`<http://example.com/locked/>
|
||||
(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://example.com/locked/`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 7.5.2 #3",
|
||||
`<http://example.com/locked/member>
|
||||
(<urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://example.com/locked/member`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:150852e2-3847-42d5-8cbe-0f4f296f26cf`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 9.9.6",
|
||||
`(<urn:uuid:fe184f2e-6eec-41d0-c765-01adc56e6bb4>)
|
||||
(<urn:uuid:e454f3f3-acdc-452a-56c7-00a5c91e4b77>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:fe184f2e-6eec-41d0-c765-01adc56e6bb4`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:e454f3f3-acdc-452a-56c7-00a5c91e4b77`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 9.10.8",
|
||||
`(<urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.6",
|
||||
`(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
["I am an ETag"])
|
||||
(["I am another ETag"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
ETag: `"I am an ETag"`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
ETag: `"I am another ETag"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.7",
|
||||
`(Not <urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
<urn:uuid:58f202ac-22cf-11d1-b12d-002035b29092>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
Token: `urn:uuid:58f202ac-22cf-11d1-b12d-002035b29092`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.8",
|
||||
`(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>)
|
||||
(Not <DAV:no-lock>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}},
|
||||
}, {
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
Token: `DAV:no-lock`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.9",
|
||||
`</resource1>
|
||||
(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>
|
||||
[W/"A weak ETag"]) (["strong ETag"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/resource1`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}, {
|
||||
ETag: `W/"A weak ETag"`,
|
||||
}},
|
||||
}, {
|
||||
resourceTag: `/resource1`,
|
||||
conditions: []Condition{{
|
||||
ETag: `"strong ETag"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.10",
|
||||
`<http://www.example.com/specs/>
|
||||
(<urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2>)`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `http://www.example.com/specs/`,
|
||||
conditions: []Condition{{
|
||||
Token: `urn:uuid:181d4fae-7d8c-11d0-a765-00a0c91e6bf2`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.11 #1",
|
||||
`</specs/rfc2518.doc> (["4217"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/specs/rfc2518.doc`,
|
||||
conditions: []Condition{{
|
||||
ETag: `"4217"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}, {
|
||||
"section 10.4.11 #2",
|
||||
`</specs/rfc2518.doc> (Not ["4217"])`,
|
||||
ifHeader{
|
||||
lists: []ifList{{
|
||||
resourceTag: `/specs/rfc2518.doc`,
|
||||
conditions: []Condition{{
|
||||
Not: true,
|
||||
ETag: `"4217"`,
|
||||
}},
|
||||
}},
|
||||
},
|
||||
}}
|
||||
|
||||
for _, tc := range testCases {
|
||||
got, ok := parseIfHeader(strings.Replace(tc.input, "\n", "", -1))
|
||||
if gotEmpty := reflect.DeepEqual(got, ifHeader{}); gotEmpty == ok {
|
||||
t.Errorf("%s: should be different: empty header == %t, ok == %t", tc.desc, gotEmpty, ok)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(got, tc.want) {
|
||||
t.Errorf("%s:\ngot %v\nwant %v", tc.desc, got, tc.want)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -10,11 +10,10 @@ import (
|
|||
"encoding/xml"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"github.com/alist-org/alist/v3/internal/model"
|
||||
"mime"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"path"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
|
|
@ -103,7 +102,7 @@ type DeadPropsHolder interface {
|
|||
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)
|
||||
findFn func(context.Context, LockSystem, string, model.Obj) (string, error)
|
||||
// dir is true if the property applies to directories.
|
||||
dir bool
|
||||
}{
|
||||
|
|
@ -166,25 +165,26 @@ var liveProps = map[xml.Name]struct {
|
|||
//
|
||||
// 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
|
||||
}
|
||||
func props(ctx context.Context, ls LockSystem, fi model.Obj, 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
|
||||
}
|
||||
}
|
||||
// ??? what is this for?
|
||||
//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}
|
||||
|
|
@ -196,7 +196,7 @@ func props(ctx context.Context, fs FileSystem, ls LockSystem, name string, pname
|
|||
}
|
||||
// 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)
|
||||
innerXML, err := prop.findFn(ctx, ls, fi.GetName(), fi)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -214,25 +214,26 @@ func props(ctx context.Context, fs FileSystem, ls LockSystem, name string, pname
|
|||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
func propnames(ctx context.Context, ls LockSystem, fi model.Obj) ([]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
|
||||
}
|
||||
}
|
||||
// ??? what is this for?
|
||||
//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 {
|
||||
|
|
@ -254,8 +255,8 @@ func propnames(ctx context.Context, fs FileSystem, ls LockSystem, name string) (
|
|||
// 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)
|
||||
func allprop(ctx context.Context, ls LockSystem, fi model.Obj, include []xml.Name) ([]Propstat, error) {
|
||||
pnames, err := propnames(ctx, ls, fi)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -269,12 +270,12 @@ func allprop(ctx context.Context, fs FileSystem, ls LockSystem, name string, inc
|
|||
pnames = append(pnames, pn)
|
||||
}
|
||||
}
|
||||
return props(ctx, fs, ls, name, pnames)
|
||||
return props(ctx, ls, fi, 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) {
|
||||
func patch(ctx context.Context, ls LockSystem, name string, patches []Proppatch) ([]Propstat, error) {
|
||||
conflict := false
|
||||
loop:
|
||||
for _, patch := range patches {
|
||||
|
|
@ -305,26 +306,29 @@ loop:
|
|||
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
|
||||
}
|
||||
// ------------------------------------------------------------
|
||||
//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}
|
||||
|
|
@ -356,26 +360,26 @@ func escapeXML(s string) string {
|
|||
return s
|
||||
}
|
||||
|
||||
func findResourceType(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
func findResourceType(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
if fi.IsDir() {
|
||||
return `<D:collection xmlns:D="DAV:"/>`, nil
|
||||
}
|
||||
return "", nil
|
||||
}
|
||||
|
||||
func findDisplayName(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
func findDisplayName(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
if slashClean(name) == "/" {
|
||||
// Hide the real name of a possibly prefixed root directory.
|
||||
return "", nil
|
||||
}
|
||||
return escapeXML(fi.Name()), nil
|
||||
return escapeXML(fi.GetName()), 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 findContentLength(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
return strconv.FormatInt(fi.GetSize(), 10), nil
|
||||
}
|
||||
|
||||
func findLastModified(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
func findLastModified(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
return fi.ModTime().UTC().Format(http.TimeFormat), nil
|
||||
}
|
||||
|
||||
|
|
@ -400,33 +404,34 @@ type ContentTyper interface {
|
|||
ContentType(ctx context.Context) (string, error)
|
||||
}
|
||||
|
||||
func findContentType(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
if do, ok := fi.(ContentTyper); ok {
|
||||
ctype, err := do.ContentType(ctx)
|
||||
if err != ErrNotImplemented {
|
||||
return ctype, err
|
||||
}
|
||||
}
|
||||
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer f.Close()
|
||||
func findContentType(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
//if do, ok := fi.(ContentTyper); ok {
|
||||
// ctype, err := do.ContentType(ctx)
|
||||
// if err != ErrNotImplemented {
|
||||
// return ctype, err
|
||||
// }
|
||||
//}
|
||||
//f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
|
||||
//if err != nil {
|
||||
// return "", err
|
||||
//}
|
||||
//defer f.Close()
|
||||
// This implementation is based on serveContent's code in the standard net/http package.
|
||||
ctype := mime.TypeByExtension(filepath.Ext(name))
|
||||
ctype := mime.TypeByExtension(path.Ext(name))
|
||||
if ctype != "" {
|
||||
return ctype, nil
|
||||
}
|
||||
return "application/octet-stream", 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
|
||||
//var buf [512]byte
|
||||
//n, err := io.ReadFull(f, buf[:])
|
||||
//if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
|
||||
// return "", err
|
||||
//}
|
||||
//ctype = http.DetectContentType(buf[:n])
|
||||
//// Rewind file.
|
||||
//_, err = f.Seek(0, os.SEEK_SET)
|
||||
//return ctype, err
|
||||
}
|
||||
|
||||
// ETager is an optional interface for the os.FileInfo objects
|
||||
|
|
@ -447,7 +452,7 @@ type ETager interface {
|
|||
ETag(ctx context.Context) (string, error)
|
||||
}
|
||||
|
||||
func findETag(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
func findETag(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
if do, ok := fi.(ETager); ok {
|
||||
etag, err := do.ETag(ctx)
|
||||
if err != ErrNotImplemented {
|
||||
|
|
@ -457,10 +462,10 @@ func findETag(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi
|
|||
// 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
|
||||
return fmt.Sprintf(`"%x%x"`, fi.ModTime().UnixNano(), fi.GetSize()), nil
|
||||
}
|
||||
|
||||
func findSupportedLock(ctx context.Context, fs FileSystem, ls LockSystem, name string, fi os.FileInfo) (string, error) {
|
||||
func findSupportedLock(ctx context.Context, ls LockSystem, name string, fi model.Obj) (string, error) {
|
||||
return `` +
|
||||
`<D:lockentry xmlns:D="DAV:">` +
|
||||
`<D:lockscope><D:exclusive/></D:lockscope>` +
|
||||
|
|
|
|||
|
|
@ -1,716 +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 (
|
||||
"context"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"sort"
|
||||
"testing"
|
||||
)
|
||||
|
||||
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().UTC().Format(http.TimeFormat))
|
||||
pst.Props[i] = p
|
||||
case xml.Name{Space: "DAV:", Local: "getetag"}:
|
||||
if fi.IsDir() {
|
||||
continue
|
||||
}
|
||||
etag, err := findETag(ctx, fs, ls, name, fi)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.InnerXML = []byte(etag)
|
||||
pst.Props[i] = p
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
const (
|
||||
lockEntry = `` +
|
||||
`<D:lockentry xmlns:D="DAV:">` +
|
||||
`<D:lockscope><D:exclusive/></D:lockscope>` +
|
||||
`<D:locktype><D:write/></D:locktype>` +
|
||||
`</D:lockentry>`
|
||||
statForbiddenError = `<D:cannot-modify-protected-property xmlns:D="DAV:"/>`
|
||||
)
|
||||
|
||||
type propOp struct {
|
||||
op string
|
||||
name string
|
||||
pnames []xml.Name
|
||||
patches []Proppatch
|
||||
wantPnames []xml.Name
|
||||
wantPropstats []Propstat
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
desc string
|
||||
noDeadProps bool
|
||||
buildfs []string
|
||||
propOp []propOp
|
||||
}{{
|
||||
desc: "propname",
|
||||
buildfs: []string{"mkdir /dir", "touch /file"},
|
||||
propOp: []propOp{{
|
||||
op: "propname",
|
||||
name: "/dir",
|
||||
wantPnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "DAV:", Local: "displayname"},
|
||||
{Space: "DAV:", Local: "supportedlock"},
|
||||
{Space: "DAV:", Local: "getlastmodified"},
|
||||
},
|
||||
}, {
|
||||
op: "propname",
|
||||
name: "/file",
|
||||
wantPnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "DAV:", Local: "displayname"},
|
||||
{Space: "DAV:", Local: "getcontentlength"},
|
||||
{Space: "DAV:", Local: "getlastmodified"},
|
||||
{Space: "DAV:", Local: "getcontenttype"},
|
||||
{Space: "DAV:", Local: "getetag"},
|
||||
{Space: "DAV:", Local: "supportedlock"},
|
||||
},
|
||||
}},
|
||||
}, {
|
||||
desc: "allprop dir and file",
|
||||
buildfs: []string{"mkdir /dir", "write /file foobarbaz"},
|
||||
propOp: []propOp{{
|
||||
op: "allprop",
|
||||
name: "/dir",
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(`<D:collection xmlns:D="DAV:"/>`),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("dir"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getlastmodified"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "supportedlock"},
|
||||
InnerXML: []byte(lockEntry),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "allprop",
|
||||
name: "/file",
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(""),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "displayname"},
|
||||
InnerXML: []byte("file"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontentlength"},
|
||||
InnerXML: []byte("9"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getlastmodified"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontenttype"},
|
||||
InnerXML: []byte("text/plain; charset=utf-8"),
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
InnerXML: nil, // Calculated during test.
|
||||
}, {
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "supportedlock"},
|
||||
InnerXML: []byte(lockEntry),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "allprop",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{
|
||||
{Space: "DAV:", Local: "resourcetype"},
|
||||
{Space: "foo", Local: "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{{Space: "DAV:", Local: "resourcetype"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusOK,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "resourcetype"},
|
||||
InnerXML: []byte(`<D:collection xmlns:D="DAV:"/>`),
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{{Space: "DAV:", Local: "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{{Space: "DAV:", Local: "getcontentlanguage"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getcontentlanguage"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/dir",
|
||||
pnames: []xml.Name{{Space: "DAV:", Local: "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{{Space: "DAV:", Local: "getetag"}},
|
||||
wantPropstats: []Propstat{{
|
||||
Status: http.StatusNotFound,
|
||||
Props: []Property{{
|
||||
XMLName: xml.Name{Space: "DAV:", Local: "getetag"},
|
||||
}},
|
||||
}},
|
||||
}, {
|
||||
op: "propfind",
|
||||
name: "/file",
|
||||
pnames: []xml.Name{{Space: "DAV:", Local: "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{{Space: "foo:", Local: "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) }
|
||||
|
||||
type overrideContentType struct {
|
||||
os.FileInfo
|
||||
contentType string
|
||||
err error
|
||||
}
|
||||
|
||||
func (o *overrideContentType) ContentType(ctx context.Context) (string, error) {
|
||||
return o.contentType, o.err
|
||||
}
|
||||
|
||||
func TestFindContentTypeOverride(t *testing.T) {
|
||||
fs, err := buildTestFS([]string{"touch /file"})
|
||||
if err != nil {
|
||||
t.Fatalf("cannot create test filesystem: %v", err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
fi, err := fs.Stat(ctx, "/file")
|
||||
if err != nil {
|
||||
t.Fatalf("cannot Stat /file: %v", err)
|
||||
}
|
||||
|
||||
// Check non overridden case
|
||||
originalContentType, err := findContentType(ctx, fs, nil, "/file", fi)
|
||||
if err != nil {
|
||||
t.Fatalf("findContentType /file failed: %v", err)
|
||||
}
|
||||
if originalContentType != "text/plain; charset=utf-8" {
|
||||
t.Fatalf("ContentType wrong want %q got %q", "text/plain; charset=utf-8", originalContentType)
|
||||
}
|
||||
|
||||
// Now try overriding the ContentType
|
||||
o := &overrideContentType{fi, "OverriddenContentType", nil}
|
||||
ContentType, err := findContentType(ctx, fs, nil, "/file", o)
|
||||
if err != nil {
|
||||
t.Fatalf("findContentType /file failed: %v", err)
|
||||
}
|
||||
if ContentType != o.contentType {
|
||||
t.Fatalf("ContentType wrong want %q got %q", o.contentType, ContentType)
|
||||
}
|
||||
|
||||
// Now return ErrNotImplemented and check we get the original content type
|
||||
o = &overrideContentType{fi, "OverriddenContentType", ErrNotImplemented}
|
||||
ContentType, err = findContentType(ctx, fs, nil, "/file", o)
|
||||
if err != nil {
|
||||
t.Fatalf("findContentType /file failed: %v", err)
|
||||
}
|
||||
if ContentType != originalContentType {
|
||||
t.Fatalf("ContentType wrong want %q got %q", originalContentType, ContentType)
|
||||
}
|
||||
}
|
||||
|
||||
type overrideETag struct {
|
||||
os.FileInfo
|
||||
eTag string
|
||||
err error
|
||||
}
|
||||
|
||||
func (o *overrideETag) ETag(ctx context.Context) (string, error) {
|
||||
return o.eTag, o.err
|
||||
}
|
||||
|
||||
func TestFindETagOverride(t *testing.T) {
|
||||
fs, err := buildTestFS([]string{"touch /file"})
|
||||
if err != nil {
|
||||
t.Fatalf("cannot create test filesystem: %v", err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
fi, err := fs.Stat(ctx, "/file")
|
||||
if err != nil {
|
||||
t.Fatalf("cannot Stat /file: %v", err)
|
||||
}
|
||||
|
||||
// Check non overridden case
|
||||
originalETag, err := findETag(ctx, fs, nil, "/file", fi)
|
||||
if err != nil {
|
||||
t.Fatalf("findETag /file failed: %v", err)
|
||||
}
|
||||
matchETag := regexp.MustCompile(`^"-?[0-9a-f]{6,}"$`)
|
||||
if !matchETag.MatchString(originalETag) {
|
||||
t.Fatalf("ETag wrong, wanted something matching %v got %q", matchETag, originalETag)
|
||||
}
|
||||
|
||||
// Now try overriding the ETag
|
||||
o := &overrideETag{fi, `"OverriddenETag"`, nil}
|
||||
ETag, err := findETag(ctx, fs, nil, "/file", o)
|
||||
if err != nil {
|
||||
t.Fatalf("findETag /file failed: %v", err)
|
||||
}
|
||||
if ETag != o.eTag {
|
||||
t.Fatalf("ETag wrong want %q got %q", o.eTag, ETag)
|
||||
}
|
||||
|
||||
// Now return ErrNotImplemented and check we get the original Etag
|
||||
o = &overrideETag{fi, `"OverriddenETag"`, ErrNotImplemented}
|
||||
ETag, err = findETag(ctx, fs, nil, "/file", o)
|
||||
if err != nil {
|
||||
t.Fatalf("findETag /file failed: %v", err)
|
||||
}
|
||||
if ETag != originalETag {
|
||||
t.Fatalf("ETag wrong want %q got %q", originalETag, ETag)
|
||||
}
|
||||
}
|
||||
|
|
@ -8,7 +8,12 @@ package webdav // import "golang.org/x/net/webdav"
|
|||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"github.com/alist-org/alist/v3/internal/errs"
|
||||
"github.com/alist-org/alist/v3/internal/fs"
|
||||
"github.com/alist-org/alist/v3/internal/model"
|
||||
"github.com/alist-org/alist/v3/internal/sign"
|
||||
"github.com/alist-org/alist/v3/pkg/utils"
|
||||
"github.com/alist-org/alist/v3/server/common"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
|
|
@ -20,8 +25,6 @@ import (
|
|||
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
|
||||
|
|
@ -41,9 +44,7 @@ func (h *Handler) stripPrefix(p string) (string, int, error) {
|
|||
|
||||
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
status, err := http.StatusBadRequest, errUnsupportedMethod
|
||||
if h.FileSystem == nil {
|
||||
status, err = http.StatusInternalServerError, errNoFileSystem
|
||||
} else if h.LockSystem == nil {
|
||||
if h.LockSystem == nil {
|
||||
status, err = http.StatusInternalServerError, errNoLockSystem
|
||||
} else {
|
||||
switch r.Method {
|
||||
|
|
@ -76,7 +77,7 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|||
w.Write([]byte(StatusText(status)))
|
||||
}
|
||||
}
|
||||
if h.Logger != nil {
|
||||
if h.Logger != nil && err != nil {
|
||||
h.Logger(r, err)
|
||||
}
|
||||
}
|
||||
|
|
@ -175,8 +176,10 @@ func (h *Handler) handleOptions(w http.ResponseWriter, r *http.Request) (status
|
|||
return status, err
|
||||
}
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
allow := "OPTIONS, LOCK, PUT, MKCOL"
|
||||
if fi, err := h.FileSystem.Stat(ctx, reqPath); err == nil {
|
||||
if fi, err := fs.Get(ctx, reqPath); err == nil {
|
||||
if fi.IsDir() {
|
||||
allow = "OPTIONS, LOCK, DELETE, PROPPATCH, COPY, MOVE, UNLOCK, PROPFIND"
|
||||
} else {
|
||||
|
|
@ -198,25 +201,41 @@ func (h *Handler) handleGetHeadPost(w http.ResponseWriter, r *http.Request) (sta
|
|||
}
|
||||
// TODO: check locks for read-only access??
|
||||
ctx := r.Context()
|
||||
f, err := h.FileSystem.OpenFile(ctx, reqPath, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
defer f.Close()
|
||||
fi, err := f.Stat()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
fi, err := fs.Get(ctx, reqPath)
|
||||
if err != nil {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
if fi.IsDir() {
|
||||
return http.StatusMethodNotAllowed, nil
|
||||
}
|
||||
etag, err := findETag(ctx, h.FileSystem, h.LockSystem, reqPath, fi)
|
||||
etag, err := findETag(ctx, h.LockSystem, reqPath, fi)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
w.Header().Set("ETag", etag)
|
||||
// Let ServeContent determine the Content-Type header.
|
||||
http.ServeContent(w, r, reqPath, fi.ModTime(), f)
|
||||
account, _ := fs.GetAccount(reqPath)
|
||||
if account.GetAccount().WebdavNative() {
|
||||
link, _, err := fs.Link(ctx, reqPath, model.LinkArgs{Header: r.Header})
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
err = common.Proxy(w, r, link, fi)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
} else if account.Config().MustProxy() || account.GetAccount().WebdavProxy() {
|
||||
u := fmt.Sprintf("%s/p%s?sign=%s", common.GetBaseUrl(r), reqPath, sign.Sign(path.Base(reqPath)))
|
||||
http.Redirect(w, r, u, 302)
|
||||
} else {
|
||||
link, _, err := fs.Link(ctx, reqPath, model.LinkArgs{IP: utils.ClientIP(r)})
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
http.Redirect(w, r, link.URL, 302)
|
||||
}
|
||||
return 0, nil
|
||||
}
|
||||
|
||||
|
|
@ -232,19 +251,20 @@ func (h *Handler) handleDelete(w http.ResponseWriter, r *http.Request) (status i
|
|||
defer release()
|
||||
|
||||
ctx := r.Context()
|
||||
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
// 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) {
|
||||
if _, err := fs.Get(ctx, reqPath); err != nil {
|
||||
if errs.IsObjectNotFound(err) {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
return http.StatusMethodNotAllowed, err
|
||||
}
|
||||
if err := h.FileSystem.RemoveAll(ctx, reqPath); err != nil {
|
||||
if err := fs.Remove(ctx, reqPath); err != nil {
|
||||
return http.StatusMethodNotAllowed, err
|
||||
}
|
||||
return http.StatusNoContent, nil
|
||||
|
|
@ -263,25 +283,30 @@ func (h *Handler) handlePut(w http.ResponseWriter, r *http.Request) (status int,
|
|||
// TODO(rost): Support the If-Match, If-None-Match headers? See bradfitz'
|
||||
// comments in http.checkEtag.
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
obj := model.Object{
|
||||
Name: path.Base(reqPath),
|
||||
Size: r.ContentLength,
|
||||
Modified: time.Now(),
|
||||
}
|
||||
stream := model.FileStream{
|
||||
Obj: obj,
|
||||
ReadCloser: r.Body,
|
||||
Mimetype: r.Header.Get("Content-Type"),
|
||||
}
|
||||
err = fs.PutDirectly(ctx, path.Dir(reqPath), stream)
|
||||
|
||||
f, err := h.FileSystem.OpenFile(ctx, reqPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
|
||||
if err != nil {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
_, copyErr := io.Copy(f, r.Body)
|
||||
fi, statErr := f.Stat()
|
||||
closeErr := f.Close()
|
||||
// TODO(rost): Returning 405 Method Not Allowed might not be appropriate.
|
||||
if copyErr != nil {
|
||||
return http.StatusMethodNotAllowed, copyErr
|
||||
if err != nil {
|
||||
return http.StatusMethodNotAllowed, err
|
||||
}
|
||||
if statErr != nil {
|
||||
return http.StatusMethodNotAllowed, statErr
|
||||
// TODO clear cache
|
||||
fi, err := fs.Get(ctx, reqPath)
|
||||
if err != nil {
|
||||
fi = obj
|
||||
}
|
||||
if closeErr != nil {
|
||||
return http.StatusMethodNotAllowed, closeErr
|
||||
}
|
||||
etag, err := findETag(ctx, h.FileSystem, h.LockSystem, reqPath, fi)
|
||||
etag, err := findETag(ctx, h.LockSystem, reqPath, fi)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
|
@ -301,11 +326,13 @@ func (h *Handler) handleMkcol(w http.ResponseWriter, r *http.Request) (status in
|
|||
defer release()
|
||||
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
|
||||
if r.ContentLength > 0 {
|
||||
return http.StatusUnsupportedMediaType, nil
|
||||
}
|
||||
if err := h.FileSystem.Mkdir(ctx, reqPath, 0777); err != nil {
|
||||
if err := fs.MakeDir(ctx, reqPath); err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
return http.StatusConflict, err
|
||||
}
|
||||
|
|
@ -345,6 +372,9 @@ func (h *Handler) handleCopyMove(w http.ResponseWriter, r *http.Request) (status
|
|||
}
|
||||
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
src = path.Join(user.BasePath, src)
|
||||
dst = path.Join(user.BasePath, dst)
|
||||
|
||||
if r.Method == "COPY" {
|
||||
// Section 7.5.1 says that a COPY only needs to lock the destination,
|
||||
|
|
@ -369,7 +399,7 @@ func (h *Handler) handleCopyMove(w http.ResponseWriter, r *http.Request) (status
|
|||
return http.StatusBadRequest, errInvalidDepth
|
||||
}
|
||||
}
|
||||
return copyFiles(ctx, h.FileSystem, src, dst, r.Header.Get("Overwrite") != "F", depth, 0)
|
||||
return copyFiles(ctx, src, dst, r.Header.Get("Overwrite") != "F")
|
||||
}
|
||||
|
||||
release, status, err := h.confirmLocks(r, src, dst)
|
||||
|
|
@ -386,7 +416,7 @@ func (h *Handler) handleCopyMove(w http.ResponseWriter, r *http.Request) (status
|
|||
return http.StatusBadRequest, errInvalidDepth
|
||||
}
|
||||
}
|
||||
return moveFiles(ctx, h.FileSystem, src, dst, r.Header.Get("Overwrite") == "T")
|
||||
return moveFiles(ctx, src, dst, r.Header.Get("Overwrite") == "T")
|
||||
}
|
||||
|
||||
func (h *Handler) handleLock(w http.ResponseWriter, r *http.Request) (retStatus int, retErr error) {
|
||||
|
|
@ -400,6 +430,7 @@ func (h *Handler) handleLock(w http.ResponseWriter, r *http.Request) (retStatus
|
|||
}
|
||||
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
token, ld, now, created := "", LockDetails{}, time.Now(), false
|
||||
if li == (lockInfo{}) {
|
||||
// An empty lockInfo means to refresh the lock.
|
||||
|
|
@ -434,6 +465,7 @@ func (h *Handler) handleLock(w http.ResponseWriter, r *http.Request) (retStatus
|
|||
}
|
||||
}
|
||||
reqPath, status, err := h.stripPrefix(r.URL.Path)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
if err != nil {
|
||||
return status, err
|
||||
}
|
||||
|
|
@ -456,16 +488,17 @@ func (h *Handler) handleLock(w http.ResponseWriter, r *http.Request) (retStatus
|
|||
}
|
||||
}()
|
||||
|
||||
// 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
|
||||
}
|
||||
// ??? Why create resource here?
|
||||
//// 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.
|
||||
|
|
@ -512,9 +545,11 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status
|
|||
return status, err
|
||||
}
|
||||
ctx := r.Context()
|
||||
fi, err := h.FileSystem.Stat(ctx, reqPath)
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
fi, err := fs.Get(ctx, reqPath)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
if errs.IsObjectNotFound(err) {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
return http.StatusMethodNotAllowed, err
|
||||
|
|
@ -533,13 +568,13 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status
|
|||
|
||||
mw := multistatusWriter{w: w}
|
||||
|
||||
walkFn := func(reqPath string, info os.FileInfo, err error) error {
|
||||
walkFn := func(reqPath string, info model.Obj, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var pstats []Propstat
|
||||
if pf.Propname != nil {
|
||||
pnames, err := propnames(ctx, h.FileSystem, h.LockSystem, reqPath)
|
||||
pnames, err := propnames(ctx, h.LockSystem, info)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -549,9 +584,9 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status
|
|||
}
|
||||
pstats = append(pstats, pstat)
|
||||
} else if pf.Allprop != nil {
|
||||
pstats, err = allprop(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop)
|
||||
pstats, err = allprop(ctx, h.LockSystem, info, pf.Prop)
|
||||
} else {
|
||||
pstats, err = props(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop)
|
||||
pstats, err = props(ctx, h.LockSystem, info, pf.Prop)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -563,7 +598,7 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status
|
|||
return mw.write(makePropstatResponse(href, pstats))
|
||||
}
|
||||
|
||||
walkErr := walkFS(ctx, h.FileSystem, depth, reqPath, fi, walkFn)
|
||||
walkErr := walkFS(ctx, depth, reqPath, fi, walkFn)
|
||||
closeErr := mw.close()
|
||||
if walkErr != nil {
|
||||
return http.StatusInternalServerError, walkErr
|
||||
|
|
@ -586,9 +621,11 @@ func (h *Handler) handleProppatch(w http.ResponseWriter, r *http.Request) (statu
|
|||
defer release()
|
||||
|
||||
ctx := r.Context()
|
||||
user := ctx.Value("user").(*model.User)
|
||||
reqPath = path.Join(user.BasePath, reqPath)
|
||||
|
||||
if _, err := h.FileSystem.Stat(ctx, reqPath); err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
if _, err := fs.Get(ctx, reqPath); err != nil {
|
||||
if errs.IsObjectNotFound(err) {
|
||||
return http.StatusNotFound, err
|
||||
}
|
||||
return http.StatusMethodNotAllowed, err
|
||||
|
|
@ -597,7 +634,7 @@ func (h *Handler) handleProppatch(w http.ResponseWriter, r *http.Request) (statu
|
|||
if err != nil {
|
||||
return status, err
|
||||
}
|
||||
pstats, err := patch(ctx, h.FileSystem, h.LockSystem, reqPath, patches)
|
||||
pstats, err := patch(ctx, h.LockSystem, reqPath, patches)
|
||||
if err != nil {
|
||||
return http.StatusInternalServerError, err
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,349 +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 (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TODO: add tests to check XML responses with the expected prefix path
|
||||
func TestPrefix(t *testing.T) {
|
||||
const dst, blah = "Destination", "blah blah blah"
|
||||
|
||||
// createLockBody comes from the example in Section 9.10.7.
|
||||
const createLockBody = `<?xml version="1.0" encoding="utf-8" ?>
|
||||
<D:lockinfo xmlns:D='DAV:'>
|
||||
<D:lockscope><D:exclusive/></D:lockscope>
|
||||
<D:locktype><D:write/></D:locktype>
|
||||
<D:owner>
|
||||
<D:href>http://example.org/~ejw/contact.html</D:href>
|
||||
</D:owner>
|
||||
</D:lockinfo>
|
||||
`
|
||||
|
||||
do := func(method, urlStr string, body string, wantStatusCode int, headers ...string) (http.Header, error) {
|
||||
var bodyReader io.Reader
|
||||
if body != "" {
|
||||
bodyReader = strings.NewReader(body)
|
||||
}
|
||||
req, err := http.NewRequest(method, urlStr, bodyReader)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for len(headers) >= 2 {
|
||||
req.Header.Add(headers[0], headers[1])
|
||||
headers = headers[2:]
|
||||
}
|
||||
res, err := http.DefaultTransport.RoundTrip(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer res.Body.Close()
|
||||
if res.StatusCode != wantStatusCode {
|
||||
return nil, fmt.Errorf("got status code %d, want %d", res.StatusCode, wantStatusCode)
|
||||
}
|
||||
return res.Header, nil
|
||||
}
|
||||
|
||||
prefixes := []string{
|
||||
"/",
|
||||
"/a/",
|
||||
"/a/b/",
|
||||
"/a/b/c/",
|
||||
}
|
||||
ctx := context.Background()
|
||||
for _, prefix := range prefixes {
|
||||
fs := NewMemFS()
|
||||
h := &Handler{
|
||||
FileSystem: fs,
|
||||
LockSystem: NewMemLS(),
|
||||
}
|
||||
mux := http.NewServeMux()
|
||||
if prefix != "/" {
|
||||
h.Prefix = prefix
|
||||
}
|
||||
mux.Handle(prefix, h)
|
||||
srv := httptest.NewServer(mux)
|
||||
defer srv.Close()
|
||||
|
||||
// The script is:
|
||||
// MKCOL /a
|
||||
// MKCOL /a/b
|
||||
// PUT /a/b/c
|
||||
// COPY /a/b/c /a/b/d
|
||||
// MKCOL /a/b/e
|
||||
// MOVE /a/b/d /a/b/e/f
|
||||
// LOCK /a/b/e/g
|
||||
// PUT /a/b/e/g
|
||||
// which should yield the (possibly stripped) filenames /a/b/c,
|
||||
// /a/b/e/f and /a/b/e/g, plus their parent directories.
|
||||
|
||||
wantA := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusMovedPermanently,
|
||||
"/a/b/": http.StatusNotFound,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a", "", wantA); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantB := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusMovedPermanently,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a/b", "", wantB); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a/b: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantC := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusMovedPermanently,
|
||||
}[prefix]
|
||||
if _, err := do("PUT", srv.URL+"/a/b/c", blah, wantC); err != nil {
|
||||
t.Errorf("prefix=%-9q PUT /a/b/c: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantD := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusMovedPermanently,
|
||||
}[prefix]
|
||||
if _, err := do("COPY", srv.URL+"/a/b/c", "", wantD, dst, srv.URL+"/a/b/d"); err != nil {
|
||||
t.Errorf("prefix=%-9q COPY /a/b/c /a/b/d: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantE := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MKCOL", srv.URL+"/a/b/e", "", wantE); err != nil {
|
||||
t.Errorf("prefix=%-9q MKCOL /a/b/e: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
wantF := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("MOVE", srv.URL+"/a/b/d", "", wantF, dst, srv.URL+"/a/b/e/f"); err != nil {
|
||||
t.Errorf("prefix=%-9q MOVE /a/b/d /a/b/e/f: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
var lockToken string
|
||||
wantG := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if h, err := do("LOCK", srv.URL+"/a/b/e/g", createLockBody, wantG); err != nil {
|
||||
t.Errorf("prefix=%-9q LOCK /a/b/e/g: %v", prefix, err)
|
||||
continue
|
||||
} else {
|
||||
lockToken = h.Get("Lock-Token")
|
||||
}
|
||||
|
||||
ifHeader := fmt.Sprintf("<%s/a/b/e/g> (%s)", srv.URL, lockToken)
|
||||
wantH := map[string]int{
|
||||
"/": http.StatusCreated,
|
||||
"/a/": http.StatusCreated,
|
||||
"/a/b/": http.StatusCreated,
|
||||
"/a/b/c/": http.StatusNotFound,
|
||||
}[prefix]
|
||||
if _, err := do("PUT", srv.URL+"/a/b/e/g", blah, wantH, "If", ifHeader); err != nil {
|
||||
t.Errorf("prefix=%-9q PUT /a/b/e/g: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
|
||||
got, err := find(ctx, nil, fs, "/")
|
||||
if err != nil {
|
||||
t.Errorf("prefix=%-9q find: %v", prefix, err)
|
||||
continue
|
||||
}
|
||||
sort.Strings(got)
|
||||
want := map[string][]string{
|
||||
"/": {"/", "/a", "/a/b", "/a/b/c", "/a/b/e", "/a/b/e/f", "/a/b/e/g"},
|
||||
"/a/": {"/", "/b", "/b/c", "/b/e", "/b/e/f", "/b/e/g"},
|
||||
"/a/b/": {"/", "/c", "/e", "/e/f", "/e/g"},
|
||||
"/a/b/c/": {"/"},
|
||||
}[prefix]
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("prefix=%-9q find:\ngot %v\nwant %v", prefix, got, want)
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEscapeXML(t *testing.T) {
|
||||
// These test cases aren't exhaustive, and there is more than one way to
|
||||
// escape e.g. a quot (as """ or """) or an apos. We presume that
|
||||
// the encoding/xml package tests xml.EscapeText more thoroughly. This test
|
||||
// here is just a sanity check for this package's escapeXML function, and
|
||||
// its attempt to provide a fast path (and avoid a bytes.Buffer allocation)
|
||||
// when escaping filenames is obviously a no-op.
|
||||
testCases := map[string]string{
|
||||
"": "",
|
||||
" ": " ",
|
||||
"&": "&",
|
||||
"*": "*",
|
||||
"+": "+",
|
||||
",": ",",
|
||||
"-": "-",
|
||||
".": ".",
|
||||
"/": "/",
|
||||
"0": "0",
|
||||
"9": "9",
|
||||
":": ":",
|
||||
"<": "<",
|
||||
">": ">",
|
||||
"A": "A",
|
||||
"_": "_",
|
||||
"a": "a",
|
||||
"~": "~",
|
||||
"\u0201": "\u0201",
|
||||
"&": "&amp;",
|
||||
"foo&<b/ar>baz": "foo&<b/ar>baz",
|
||||
}
|
||||
|
||||
for in, want := range testCases {
|
||||
if got := escapeXML(in); got != want {
|
||||
t.Errorf("in=%q: got %q, want %q", in, got, want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestFilenameEscape(t *testing.T) {
|
||||
hrefRe := regexp.MustCompile(`<D:href>([^<]*)</D:href>`)
|
||||
displayNameRe := regexp.MustCompile(`<D:displayname>([^<]*)</D:displayname>`)
|
||||
do := func(method, urlStr string) (string, string, error) {
|
||||
req, err := http.NewRequest(method, urlStr, nil)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
res, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
defer res.Body.Close()
|
||||
|
||||
b, err := ioutil.ReadAll(res.Body)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
hrefMatch := hrefRe.FindStringSubmatch(string(b))
|
||||
if len(hrefMatch) != 2 {
|
||||
return "", "", errors.New("D:href not found")
|
||||
}
|
||||
displayNameMatch := displayNameRe.FindStringSubmatch(string(b))
|
||||
if len(displayNameMatch) != 2 {
|
||||
return "", "", errors.New("D:displayname not found")
|
||||
}
|
||||
|
||||
return hrefMatch[1], displayNameMatch[1], nil
|
||||
}
|
||||
|
||||
testCases := []struct {
|
||||
name, wantHref, wantDisplayName string
|
||||
}{{
|
||||
name: `/foo%bar`,
|
||||
wantHref: `/foo%25bar`,
|
||||
wantDisplayName: `foo%bar`,
|
||||
}, {
|
||||
name: `/こんにちわ世界`,
|
||||
wantHref: `/%E3%81%93%E3%82%93%E3%81%AB%E3%81%A1%E3%82%8F%E4%B8%96%E7%95%8C`,
|
||||
wantDisplayName: `こんにちわ世界`,
|
||||
}, {
|
||||
name: `/Program Files/`,
|
||||
wantHref: `/Program%20Files/`,
|
||||
wantDisplayName: `Program Files`,
|
||||
}, {
|
||||
name: `/go+lang`,
|
||||
wantHref: `/go+lang`,
|
||||
wantDisplayName: `go+lang`,
|
||||
}, {
|
||||
name: `/go&lang`,
|
||||
wantHref: `/go&lang`,
|
||||
wantDisplayName: `go&lang`,
|
||||
}, {
|
||||
name: `/go<lang`,
|
||||
wantHref: `/go%3Clang`,
|
||||
wantDisplayName: `go<lang`,
|
||||
}, {
|
||||
name: `/`,
|
||||
wantHref: `/`,
|
||||
wantDisplayName: ``,
|
||||
}}
|
||||
ctx := context.Background()
|
||||
fs := NewMemFS()
|
||||
for _, tc := range testCases {
|
||||
if tc.name != "/" {
|
||||
if strings.HasSuffix(tc.name, "/") {
|
||||
if err := fs.Mkdir(ctx, tc.name, 0755); err != nil {
|
||||
t.Fatalf("name=%q: Mkdir: %v", tc.name, err)
|
||||
}
|
||||
} else {
|
||||
f, err := fs.OpenFile(ctx, tc.name, os.O_CREATE, 0644)
|
||||
if err != nil {
|
||||
t.Fatalf("name=%q: OpenFile: %v", tc.name, err)
|
||||
}
|
||||
f.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
srv := httptest.NewServer(&Handler{
|
||||
FileSystem: fs,
|
||||
LockSystem: NewMemLS(),
|
||||
})
|
||||
defer srv.Close()
|
||||
|
||||
u, err := url.Parse(srv.URL)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
u.Path = tc.name
|
||||
gotHref, gotDisplayName, err := do("PROPFIND", u.String())
|
||||
if err != nil {
|
||||
t.Errorf("name=%q: PROPFIND: %v", tc.name, err)
|
||||
continue
|
||||
}
|
||||
if gotHref != tc.wantHref {
|
||||
t.Errorf("name=%q: got href %q, want %q", tc.name, gotHref, tc.wantHref)
|
||||
}
|
||||
if gotDisplayName != tc.wantDisplayName {
|
||||
t.Errorf("name=%q: got dispayname %q, want %q", tc.name, gotDisplayName, tc.wantDisplayName)
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue