webdav/prop.go - net - Git at Google

 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package webdav

 import (
 	"encoding/xml"
 	"fmt"
 	"io"
 	"mime"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
 )

 // PropSystem manages the properties of named resources. It allows finding
 // and setting properties as defined in RFC 4918.
 //
 // The elements in a resource name are separated by slash ('/', U+002F)
 // characters, regardless of host operating system convention.
 type PropSystem interface {
 	// Find returns the status of properties named propnames for resource name.
 	//
 	// Each Propstat must have a unique status and each property name must
 	// only be part of one Propstat element.
 	Find(name string, propnames []xml.Name) ([]Propstat, error)

 	// TODO(nigeltao) merge Find and Allprop?

 	// Allprop returns the properties defined for resource name and the
 	// properties named in include. The returned Propstats are handled
 	// as in Find.
 	//
 	// Note that RFC 4918 defines 'allprop' to return the DAV: properties
 	// defined within the RFC plus dead properties. Other live properties
 	// should only be returned if they are named in 'include'.
 	//
 	// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
 	Allprop(name string, include []xml.Name) ([]Propstat, error)

 	// Propnames returns the property names defined for resource name.
 	Propnames(name string) ([]xml.Name, error)

 	// Patch patches the properties of resource name.
 	//
 	// If all patches can be applied without conflict, Patch returns a slice
 	// of length one and a Propstat element of status 200, naming all patched
 	// properties. In case of conflict, Patch returns an arbitrary long slice
 	// and no Propstat element must have status 200. In either case, properties
 	// in Propstat must not have values.
 	//
 	// Note that the WebDAV RFC requires either all patches to succeed or none.
 	Patch(name string, patches []Proppatch) ([]Propstat, error)

 	// TODO(rost) COPY/MOVE/DELETE.
 }

 // Proppatch describes a property update instruction as defined in RFC 4918.
 // See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPPATCH
 type Proppatch struct {
 	// Remove specifies whether this patch removes properties. If it does not
 	// remove them, it sets them.
 	Remove bool
 	// Props contains the properties to be set or removed.
 	Props []Property
 }

 // Propstat describes a XML propstat element as defined in RFC 4918.
 // See http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
 type Propstat struct {
 	// Props contains the properties for which Status applies.
 	Props []Property

 	// Status defines the HTTP status code of the properties in Prop.
 	// Allowed values include, but are not limited to the WebDAV status
 	// code extensions for HTTP/1.1.
 	// http://www.webdav.org/specs/rfc4918.html#status.code.extensions.to.http11
 	Status int

 	// XMLError contains the XML representation of the optional error element.
 	// XML content within this field must not rely on any predefined
 	// namespace declarations or prefixes. If empty, the XML error element
 	// is omitted.
 	XMLError string

 	// ResponseDescription contains the contents of the optional
 	// responsedescription field. If empty, the XML element is omitted.
 	ResponseDescription string
 }

 // memPS implements an in-memory PropSystem. It supports all of the mandatory
 // live properties of RFC 4918.
 type memPS struct {
 	fs FileSystem
 	ls LockSystem
 }

 // NewMemPS returns a new in-memory PropSystem implementation.
 func NewMemPS(fs FileSystem, ls LockSystem) PropSystem {
 	return &memPS{fs: fs, ls: ls}
 }

 // davProps contains all supported DAV: properties and their optional
 // propfind functions. A nil findFn indicates a hidden, protected property.
 // The dir field indicates if the property applies to directories in addition
 // to regular files.
 var davProps = map[xml.Name]struct {
 	findFn func(*memPS, string, os.FileInfo) (string, error)
 	dir    bool
 }{
 	xml.Name{Space: "DAV:", Local: "resourcetype"}: {
 		findFn: (*memPS).findResourceType,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "displayname"}: {
 		findFn: (*memPS).findDisplayName,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "getcontentlength"}: {
 		findFn: (*memPS).findContentLength,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "getlastmodified"}: {
 		findFn: (*memPS).findLastModified,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "creationdate"}: {
 		findFn: nil,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "getcontentlanguage"}: {
 		findFn: nil,
 		dir:    true,
 	},
 	xml.Name{Space: "DAV:", Local: "getcontenttype"}: {
 		findFn: (*memPS).findContentType,
 		dir:    true,
 	},
 	// memPS implements ETag as the concatenated hex values of a file's
 	// modification time and size. This is not a reliable synchronization
 	// mechanism for directories, so we do not advertise getetag for
 	// DAV collections.
 	xml.Name{Space: "DAV:", Local: "getetag"}: {
 		findFn: (*memPS).findETag,
 		dir:    false,
 	},

 	// TODO(nigeltao) Lock properties will be defined later.
 	// xml.Name{Space: "DAV:", Local: "lockdiscovery"}
 	// xml.Name{Space: "DAV:", Local: "supportedlock"}
 }

 func (ps *memPS) Find(name string, propnames []xml.Name) ([]Propstat, error) {
 	fi, err := ps.fs.Stat(name)
 	if err != nil {
 		return nil, err
 	}

 	pm := make(map[int]Propstat)
 	for _, pn := range propnames {
 		p := Property{XMLName: pn}
 		s := http.StatusNotFound
 		if prop := davProps[pn]; prop.findFn != nil && (prop.dir || !fi.IsDir()) {
 			xmlvalue, err := prop.findFn(ps, name, fi)
 			if err != nil {
 				return nil, err
 			}
 			s = http.StatusOK
 			p.InnerXML = []byte(xmlvalue)
 		}
 		pstat := pm[s]
 		pstat.Props = append(pstat.Props, p)
 		pm[s] = pstat
 	}

 	pstats := make([]Propstat, 0, len(pm))
 	for s, pstat := range pm {
 		pstat.Status = s
 		pstats = append(pstats, pstat)
 	}
 	return pstats, nil
 }

 func (ps *memPS) Propnames(name string) ([]xml.Name, error) {
 	fi, err := ps.fs.Stat(name)
 	if err != nil {
 		return nil, err
 	}
 	propnames := make([]xml.Name, 0, len(davProps))
 	for pn, prop := range davProps {
 		if prop.findFn != nil && (prop.dir || !fi.IsDir()) {
 			propnames = append(propnames, pn)
 		}
 	}
 	return propnames, nil
 }

 func (ps *memPS) Allprop(name string, include []xml.Name) ([]Propstat, error) {
 	propnames, err := ps.Propnames(name)
 	if err != nil {
 		return nil, err
 	}
 	// Add names from include if they are not already covered in propnames.
 	nameset := make(map[xml.Name]bool)
 	for _, pn := range propnames {
 		nameset[pn] = true
 	}
 	for _, pn := range include {
 		if !nameset[pn] {
 			propnames = append(propnames, pn)
 		}
 	}
 	return ps.Find(name, propnames)
 }

 func (ps *memPS) Patch(name string, patches []Proppatch) ([]Propstat, error) {
 	// TODO(rost): Support to patch "dead" DAV properties in the next CL.
 	pstat := Propstat{Status: http.StatusForbidden}
 	for _, patch := range patches {
 		for _, p := range patch.Props {
 			pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName})
 		}
 	}
 	return []Propstat{pstat}, nil
 }

 func (ps *memPS) findResourceType(name string, fi os.FileInfo) (string, error) {
 	if fi.IsDir() {
 		return `<collection xmlns="DAV:"/>`, nil
 	}
 	return "", nil
 }

 func (ps *memPS) findDisplayName(name string, fi os.FileInfo) (string, error) {
 	if slashClean(name) == "/" {
 		// Hide the real name of a possibly prefixed root directory.
 		return "", nil
 	}
 	return fi.Name(), nil
 }

 func (ps *memPS) findContentLength(name string, fi os.FileInfo) (string, error) {
 	return strconv.FormatInt(fi.Size(), 10), nil
 }

 func (ps *memPS) findLastModified(name string, fi os.FileInfo) (string, error) {
 	return fi.ModTime().Format(http.TimeFormat), nil
 }

 func (ps *memPS) findContentType(name string, fi os.FileInfo) (string, error) {
 	f, err := ps.fs.OpenFile(name, os.O_RDONLY, 0)
 	if err != nil {
 		return "", err
 	}
 	defer f.Close()
 	// This implementation is based on serveContent's code in the standard net/http package.
 	ctype := mime.TypeByExtension(filepath.Ext(name))
 	if ctype == "" {
 		// Read a chunk to decide between utf-8 text and binary.
 		var buf [512]byte
 		n, _ := io.ReadFull(f, buf[:])
 		ctype = http.DetectContentType(buf[:n])
 		// Rewind file.
 		_, err = f.Seek(0, os.SEEK_SET)
 	}
 	return ctype, err
 }

 func (ps *memPS) findETag(name string, fi os.FileInfo) (string, error) {
 	return detectETag(fi), nil
 }

 // detectETag determines the ETag for the file described by fi.
 func detectETag(fi os.FileInfo) string {
 	// 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())
 }
	// Copyright 2015 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package webdav

	import (
	"encoding/xml"
	"fmt"
	"io"
	"mime"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	)

	// PropSystem manages the properties of named resources. It allows finding
	// and setting properties as defined in RFC 4918.
	//
	// The elements in a resource name are separated by slash ('/', U+002F)
	// characters, regardless of host operating system convention.
	type PropSystem interface {
	// Find returns the status of properties named propnames for resource name.
	//
	// Each Propstat must have a unique status and each property name must
	// only be part of one Propstat element.
	Find(name string, propnames []xml.Name) ([]Propstat, error)

	// TODO(nigeltao) merge Find and Allprop?

	// Allprop returns the properties defined for resource name and the
	// properties named in include. The returned Propstats are handled
	// as in Find.
	//
	// Note that RFC 4918 defines 'allprop' to return the DAV: properties
	// defined within the RFC plus dead properties. Other live properties
	// should only be returned if they are named in 'include'.
	//
	// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
	Allprop(name string, include []xml.Name) ([]Propstat, error)

	// Propnames returns the property names defined for resource name.
	Propnames(name string) ([]xml.Name, error)

	// Patch patches the properties of resource name.
	//
	// If all patches can be applied without conflict, Patch returns a slice
	// of length one and a Propstat element of status 200, naming all patched
	// properties. In case of conflict, Patch returns an arbitrary long slice
	// and no Propstat element must have status 200. In either case, properties
	// in Propstat must not have values.
	//
	// Note that the WebDAV RFC requires either all patches to succeed or none.
	Patch(name string, patches []Proppatch) ([]Propstat, error)

	// TODO(rost) COPY/MOVE/DELETE.
	}

	// Proppatch describes a property update instruction as defined in RFC 4918.
	// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPPATCH
	type Proppatch struct {
	// Remove specifies whether this patch removes properties. If it does not
	// remove them, it sets them.
	Remove bool
	// Props contains the properties to be set or removed.
	Props []Property
	}

	// Propstat describes a XML propstat element as defined in RFC 4918.
	// See http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
	type Propstat struct {
	// Props contains the properties for which Status applies.
	Props []Property

	// Status defines the HTTP status code of the properties in Prop.
	// Allowed values include, but are not limited to the WebDAV status
	// code extensions for HTTP/1.1.
	// http://www.webdav.org/specs/rfc4918.html#status.code.extensions.to.http11
	Status int

	// XMLError contains the XML representation of the optional error element.
	// XML content within this field must not rely on any predefined
	// namespace declarations or prefixes. If empty, the XML error element
	// is omitted.
	XMLError string

	// ResponseDescription contains the contents of the optional
	// responsedescription field. If empty, the XML element is omitted.
	ResponseDescription string
	}

	// memPS implements an in-memory PropSystem. It supports all of the mandatory
	// live properties of RFC 4918.
	type memPS struct {
	fs FileSystem
	ls LockSystem
	}

	// NewMemPS returns a new in-memory PropSystem implementation.
	func NewMemPS(fs FileSystem, ls LockSystem) PropSystem {
	return &memPS{fs: fs, ls: ls}
	}

	// davProps contains all supported DAV: properties and their optional
	// propfind functions. A nil findFn indicates a hidden, protected property.
	// The dir field indicates if the property applies to directories in addition
	// to regular files.
	var davProps = map[xml.Name]struct {
	findFn func(*memPS, string, os.FileInfo) (string, error)
	dir bool
	}{
	xml.Name{Space: "DAV:", Local: "resourcetype"}: {
	findFn: (*memPS).findResourceType,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "displayname"}: {
	findFn: (*memPS).findDisplayName,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "getcontentlength"}: {
	findFn: (*memPS).findContentLength,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "getlastmodified"}: {
	findFn: (*memPS).findLastModified,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "creationdate"}: {
	findFn: nil,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "getcontentlanguage"}: {
	findFn: nil,
	dir: true,
	},
	xml.Name{Space: "DAV:", Local: "getcontenttype"}: {
	findFn: (*memPS).findContentType,
	dir: true,
	},
	// memPS implements ETag as the concatenated hex values of a file's
	// modification time and size. This is not a reliable synchronization
	// mechanism for directories, so we do not advertise getetag for
	// DAV collections.
	xml.Name{Space: "DAV:", Local: "getetag"}: {
	findFn: (*memPS).findETag,
	dir: false,
	},

	// TODO(nigeltao) Lock properties will be defined later.
	// xml.Name{Space: "DAV:", Local: "lockdiscovery"}
	// xml.Name{Space: "DAV:", Local: "supportedlock"}
	}

	func (ps *memPS) Find(name string, propnames []xml.Name) ([]Propstat, error) {
	fi, err := ps.fs.Stat(name)
	if err != nil {
	return nil, err
	}

	pm := make(map[int]Propstat)
	for _, pn := range propnames {
	p := Property{XMLName: pn}
	s := http.StatusNotFound
	if prop := davProps[pn]; prop.findFn != nil && (prop.dir \|\| !fi.IsDir()) {
	xmlvalue, err := prop.findFn(ps, name, fi)
	if err != nil {
	return nil, err
	}
	s = http.StatusOK
	p.InnerXML = []byte(xmlvalue)
	}
	pstat := pm[s]
	pstat.Props = append(pstat.Props, p)
	pm[s] = pstat
	}

	pstats := make([]Propstat, 0, len(pm))
	for s, pstat := range pm {
	pstat.Status = s
	pstats = append(pstats, pstat)
	}
	return pstats, nil
	}

	func (ps *memPS) Propnames(name string) ([]xml.Name, error) {
	fi, err := ps.fs.Stat(name)
	if err != nil {
	return nil, err
	}
	propnames := make([]xml.Name, 0, len(davProps))
	for pn, prop := range davProps {
	if prop.findFn != nil && (prop.dir \|\| !fi.IsDir()) {
	propnames = append(propnames, pn)
	}
	}
	return propnames, nil
	}

	func (ps *memPS) Allprop(name string, include []xml.Name) ([]Propstat, error) {
	propnames, err := ps.Propnames(name)
	if err != nil {
	return nil, err
	}
	// Add names from include if they are not already covered in propnames.
	nameset := make(map[xml.Name]bool)
	for _, pn := range propnames {
	nameset[pn] = true
	}
	for _, pn := range include {
	if !nameset[pn] {
	propnames = append(propnames, pn)
	}
	}
	return ps.Find(name, propnames)
	}

	func (ps *memPS) Patch(name string, patches []Proppatch) ([]Propstat, error) {
	// TODO(rost): Support to patch "dead" DAV properties in the next CL.
	pstat := Propstat{Status: http.StatusForbidden}
	for _, patch := range patches {
	for _, p := range patch.Props {
	pstat.Props = append(pstat.Props, Property{XMLName: p.XMLName})
	}
	}
	return []Propstat{pstat}, nil
	}

	func (ps *memPS) findResourceType(name string, fi os.FileInfo) (string, error) {
	if fi.IsDir() {
	return `<collection xmlns="DAV:"/>`, nil
	}
	return "", nil
	}

	func (ps *memPS) findDisplayName(name string, fi os.FileInfo) (string, error) {
	if slashClean(name) == "/" {
	// Hide the real name of a possibly prefixed root directory.
	return "", nil
	}
	return fi.Name(), nil
	}

	func (ps *memPS) findContentLength(name string, fi os.FileInfo) (string, error) {
	return strconv.FormatInt(fi.Size(), 10), nil
	}

	func (ps *memPS) findLastModified(name string, fi os.FileInfo) (string, error) {
	return fi.ModTime().Format(http.TimeFormat), nil
	}

	func (ps *memPS) findContentType(name string, fi os.FileInfo) (string, error) {
	f, err := ps.fs.OpenFile(name, os.O_RDONLY, 0)
	if err != nil {
	return "", err
	}
	defer f.Close()
	// This implementation is based on serveContent's code in the standard net/http package.
	ctype := mime.TypeByExtension(filepath.Ext(name))
	if ctype == "" {
	// Read a chunk to decide between utf-8 text and binary.
	var buf [512]byte
	n, _ := io.ReadFull(f, buf[:])
	ctype = http.DetectContentType(buf[:n])
	// Rewind file.
	_, err = f.Seek(0, os.SEEK_SET)
	}
	return ctype, err
	}

	func (ps *memPS) findETag(name string, fi os.FileInfo) (string, error) {
	return detectETag(fi), nil
	}

	// detectETag determines the ETag for the file described by fi.
	func detectETag(fi os.FileInfo) string {
	// 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())
	}