vendor/golang.org/x/net/webdav/xml.go - apidVerifyApiKey - Git at Google

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

 package webdav

 // The XML encoding is covered by Section 14.
 // http://www.webdav.org/specs/rfc4918.html#xml.element.definitions

 import (
 	"bytes"
 	"encoding/xml"
 	"fmt"
 	"io"
 	"net/http"
 	"time"

 	// As of https://go-review.googlesource.com/#/c/12772/ which was submitted
 	// in July 2015, this package uses an internal fork of the standard
 	// library's encoding/xml package, due to changes in the way namespaces
 	// were encoded. Such changes were introduced in the Go 1.5 cycle, but were
 	// rolled back in response to https://github.com/golang/go/issues/11841
 	//
 	// However, this package's exported API, specifically the Property and
 	// DeadPropsHolder types, need to refer to the standard library's version
 	// of the xml.Name type, as code that imports this package cannot refer to
 	// the internal version.
 	//
 	// This file therefore imports both the internal and external versions, as
 	// ixml and xml, and converts between them.
 	//
 	// In the long term, this package should use the standard library's version
 	// only, and the internal fork deleted, once
 	// https://github.com/golang/go/issues/13400 is resolved.
 	ixml "golang.org/x/net/webdav/internal/xml"
 )

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_lockinfo
 type lockInfo struct {
 	XMLName   ixml.Name `xml:"lockinfo"`
 	Exclusive *struct{} `xml:"lockscope>exclusive"`
 	Shared    *struct{} `xml:"lockscope>shared"`
 	Write     *struct{} `xml:"locktype>write"`
 	Owner     owner     `xml:"owner"`
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_owner
 type owner struct {
 	InnerXML string `xml:",innerxml"`
 }

 func readLockInfo(r io.Reader) (li lockInfo, status int, err error) {
 	c := &countingReader{r: r}
 	if err = ixml.NewDecoder(c).Decode(&li); err != nil {
 		if err == io.EOF {
 			if c.n == 0 {
 				// An empty body means to refresh the lock.
 				// http://www.webdav.org/specs/rfc4918.html#refreshing-locks
 				return lockInfo{}, 0, nil
 			}
 			err = errInvalidLockInfo
 		}
 		return lockInfo{}, http.StatusBadRequest, err
 	}
 	// We only support exclusive (non-shared) write locks. In practice, these are
 	// the only types of locks that seem to matter.
 	if li.Exclusive == nil || li.Shared != nil || li.Write == nil {
 		return lockInfo{}, http.StatusNotImplemented, errUnsupportedLockInfo
 	}
 	return li, 0, nil
 }

 type countingReader struct {
 	n int
 	r io.Reader
 }

 func (c *countingReader) Read(p []byte) (int, error) {
 	n, err := c.r.Read(p)
 	c.n += n
 	return n, err
 }

 func writeLockInfo(w io.Writer, token string, ld LockDetails) (int, error) {
 	depth := "infinity"
 	if ld.ZeroDepth {
 		depth = "0"
 	}
 	timeout := ld.Duration / time.Second
 	return fmt.Fprintf(w, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
 		"<D:prop xmlns:D=\"DAV:\"><D:lockdiscovery><D:activelock>\n"+
 		"	<D:locktype><D:write/></D:locktype>\n"+
 		"	<D:lockscope><D:exclusive/></D:lockscope>\n"+
 		"	<D:depth>%s</D:depth>\n"+
 		"	<D:owner>%s</D:owner>\n"+
 		"	<D:timeout>Second-%d</D:timeout>\n"+
 		"	<D:locktoken><D:href>%s</D:href></D:locktoken>\n"+
 		"	<D:lockroot><D:href>%s</D:href></D:lockroot>\n"+
 		"</D:activelock></D:lockdiscovery></D:prop>",
 		depth, ld.OwnerXML, timeout, escape(token), escape(ld.Root),
 	)
 }

 func escape(s string) string {
 	for i := 0; i < len(s); i++ {
 		switch s[i] {
 		case '"', '&', '\'', '<', '>':
 			b := bytes.NewBuffer(nil)
 			ixml.EscapeText(b, []byte(s))
 			return b.String()
 		}
 	}
 	return s
 }

 // Next returns the next token, if any, in the XML stream of d.
 // RFC 4918 requires to ignore comments, processing instructions
 // and directives.
 // http://www.webdav.org/specs/rfc4918.html#property_values
 // http://www.webdav.org/specs/rfc4918.html#xml-extensibility
 func next(d *ixml.Decoder) (ixml.Token, error) {
 	for {
 		t, err := d.Token()
 		if err != nil {
 			return t, err
 		}
 		switch t.(type) {
 		case ixml.Comment, ixml.Directive, ixml.ProcInst:
 			continue
 		default:
 			return t, nil
 		}
 	}
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind)
 type propfindProps []xml.Name

 // UnmarshalXML appends the property names enclosed within start to pn.
 //
 // It returns an error if start does not contain any properties or if
 // properties contain values. Character data between properties is ignored.
 func (pn *propfindProps) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error {
 	for {
 		t, err := next(d)
 		if err != nil {
 			return err
 		}
 		switch t.(type) {
 		case ixml.EndElement:
 			if len(*pn) == 0 {
 				return fmt.Errorf("%s must not be empty", start.Name.Local)
 			}
 			return nil
 		case ixml.StartElement:
 			name := t.(ixml.StartElement).Name
 			t, err = next(d)
 			if err != nil {
 				return err
 			}
 			if _, ok := t.(ixml.EndElement); !ok {
 				return fmt.Errorf("unexpected token %T", t)
 			}
 			*pn = append(*pn, xml.Name(name))
 		}
 	}
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_propfind
 type propfind struct {
 	XMLName  ixml.Name     `xml:"DAV: propfind"`
 	Allprop  *struct{}     `xml:"DAV: allprop"`
 	Propname *struct{}     `xml:"DAV: propname"`
 	Prop     propfindProps `xml:"DAV: prop"`
 	Include  propfindProps `xml:"DAV: include"`
 }

 func readPropfind(r io.Reader) (pf propfind, status int, err error) {
 	c := countingReader{r: r}
 	if err = ixml.NewDecoder(&c).Decode(&pf); err != nil {
 		if err == io.EOF {
 			if c.n == 0 {
 				// An empty body means to propfind allprop.
 				// http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
 				return propfind{Allprop: new(struct{})}, 0, nil
 			}
 			err = errInvalidPropfind
 		}
 		return propfind{}, http.StatusBadRequest, err
 	}

 	if pf.Allprop == nil && pf.Include != nil {
 		return propfind{}, http.StatusBadRequest, errInvalidPropfind
 	}
 	if pf.Allprop != nil && (pf.Prop != nil || pf.Propname != nil) {
 		return propfind{}, http.StatusBadRequest, errInvalidPropfind
 	}
 	if pf.Prop != nil && pf.Propname != nil {
 		return propfind{}, http.StatusBadRequest, errInvalidPropfind
 	}
 	if pf.Propname == nil && pf.Allprop == nil && pf.Prop == nil {
 		return propfind{}, http.StatusBadRequest, errInvalidPropfind
 	}
 	return pf, 0, nil
 }

 // Property represents a single DAV resource property as defined in RFC 4918.
 // See http://www.webdav.org/specs/rfc4918.html#data.model.for.resource.properties
 type Property struct {
 	// XMLName is the fully qualified name that identifies this property.
 	XMLName xml.Name

 	// Lang is an optional xml:lang attribute.
 	Lang string `xml:"xml:lang,attr,omitempty"`

 	// InnerXML contains the XML representation of the property value.
 	// See http://www.webdav.org/specs/rfc4918.html#property_values
 	//
 	// Property values of complex type or mixed-content must have fully
 	// expanded XML namespaces or be self-contained with according
 	// XML namespace declarations. They must not rely on any XML
 	// namespace declarations within the scope of the XML document,
 	// even including the DAV: namespace.
 	InnerXML []byte `xml:",innerxml"`
 }

 // ixmlProperty is the same as the Property type except it holds an ixml.Name
 // instead of an xml.Name.
 type ixmlProperty struct {
 	XMLName  ixml.Name
 	Lang     string `xml:"xml:lang,attr,omitempty"`
 	InnerXML []byte `xml:",innerxml"`
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_error
 // See multistatusWriter for the "D:" namespace prefix.
 type xmlError struct {
 	XMLName  ixml.Name `xml:"D:error"`
 	InnerXML []byte    `xml:",innerxml"`
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
 // See multistatusWriter for the "D:" namespace prefix.
 type propstat struct {
 	Prop                []Property `xml:"D:prop>_ignored_"`
 	Status              string     `xml:"D:status"`
 	Error               *xmlError  `xml:"D:error"`
 	ResponseDescription string     `xml:"D:responsedescription,omitempty"`
 }

 // ixmlPropstat is the same as the propstat type except it holds an ixml.Name
 // instead of an xml.Name.
 type ixmlPropstat struct {
 	Prop                []ixmlProperty `xml:"D:prop>_ignored_"`
 	Status              string         `xml:"D:status"`
 	Error               *xmlError      `xml:"D:error"`
 	ResponseDescription string         `xml:"D:responsedescription,omitempty"`
 }

 // MarshalXML prepends the "D:" namespace prefix on properties in the DAV: namespace
 // before encoding. See multistatusWriter.
 func (ps propstat) MarshalXML(e *ixml.Encoder, start ixml.StartElement) error {
 	// Convert from a propstat to an ixmlPropstat.
 	ixmlPs := ixmlPropstat{
 		Prop:                make([]ixmlProperty, len(ps.Prop)),
 		Status:              ps.Status,
 		Error:               ps.Error,
 		ResponseDescription: ps.ResponseDescription,
 	}
 	for k, prop := range ps.Prop {
 		ixmlPs.Prop[k] = ixmlProperty{
 			XMLName:  ixml.Name(prop.XMLName),
 			Lang:     prop.Lang,
 			InnerXML: prop.InnerXML,
 		}
 	}

 	for k, prop := range ixmlPs.Prop {
 		if prop.XMLName.Space == "DAV:" {
 			prop.XMLName = ixml.Name{Space: "", Local: "D:" + prop.XMLName.Local}
 			ixmlPs.Prop[k] = prop
 		}
 	}
 	// Distinct type to avoid infinite recursion of MarshalXML.
 	type newpropstat ixmlPropstat
 	return e.EncodeElement(newpropstat(ixmlPs), start)
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
 // See multistatusWriter for the "D:" namespace prefix.
 type response struct {
 	XMLName             ixml.Name  `xml:"D:response"`
 	Href                []string   `xml:"D:href"`
 	Propstat            []propstat `xml:"D:propstat"`
 	Status              string     `xml:"D:status,omitempty"`
 	Error               *xmlError  `xml:"D:error"`
 	ResponseDescription string     `xml:"D:responsedescription,omitempty"`
 }

 // MultistatusWriter marshals one or more Responses into a XML
 // multistatus response.
 // See http://www.webdav.org/specs/rfc4918.html#ELEMENT_multistatus
 // TODO(rsto, mpl): As a workaround, the "D:" namespace prefix, defined as
 // "DAV:" on this element, is prepended on the nested response, as well as on all
 // its nested elements. All property names in the DAV: namespace are prefixed as
 // well. This is because some versions of Mini-Redirector (on windows 7) ignore
 // elements with a default namespace (no prefixed namespace). A less intrusive fix
 // should be possible after golang.org/cl/11074. See https://golang.org/issue/11177
 type multistatusWriter struct {
 	// ResponseDescription contains the optional responsedescription
 	// of the multistatus XML element. Only the latest content before
 	// close will be emitted. Empty response descriptions are not
 	// written.
 	responseDescription string

 	w   http.ResponseWriter
 	enc *ixml.Encoder
 }

 // Write validates and emits a DAV response as part of a multistatus response
 // element.
 //
 // It sets the HTTP status code of its underlying http.ResponseWriter to 207
 // (Multi-Status) and populates the Content-Type header. If r is the
 // first, valid response to be written, Write prepends the XML representation
 // of r with a multistatus tag. Callers must call close after the last response
 // has been written.
 func (w *multistatusWriter) write(r *response) error {
 	switch len(r.Href) {
 	case 0:
 		return errInvalidResponse
 	case 1:
 		if len(r.Propstat) > 0 != (r.Status == "") {
 			return errInvalidResponse
 		}
 	default:
 		if len(r.Propstat) > 0 || r.Status == "" {
 			return errInvalidResponse
 		}
 	}
 	err := w.writeHeader()
 	if err != nil {
 		return err
 	}
 	return w.enc.Encode(r)
 }

 // writeHeader writes a XML multistatus start element on w's underlying
 // http.ResponseWriter and returns the result of the write operation.
 // After the first write attempt, writeHeader becomes a no-op.
 func (w *multistatusWriter) writeHeader() error {
 	if w.enc != nil {
 		return nil
 	}
 	w.w.Header().Add("Content-Type", "text/xml; charset=utf-8")
 	w.w.WriteHeader(StatusMulti)
 	_, err := fmt.Fprintf(w.w, `<?xml version="1.0" encoding="UTF-8"?>`)
 	if err != nil {
 		return err
 	}
 	w.enc = ixml.NewEncoder(w.w)
 	return w.enc.EncodeToken(ixml.StartElement{
 		Name: ixml.Name{
 			Space: "DAV:",
 			Local: "multistatus",
 		},
 		Attr: []ixml.Attr{{
 			Name:  ixml.Name{Space: "xmlns", Local: "D"},
 			Value: "DAV:",
 		}},
 	})
 }

 // Close completes the marshalling of the multistatus response. It returns
 // an error if the multistatus response could not be completed. If both the
 // return value and field enc of w are nil, then no multistatus response has
 // been written.
 func (w *multistatusWriter) close() error {
 	if w.enc == nil {
 		return nil
 	}
 	var end []ixml.Token
 	if w.responseDescription != "" {
 		name := ixml.Name{Space: "DAV:", Local: "responsedescription"}
 		end = append(end,
 			ixml.StartElement{Name: name},
 			ixml.CharData(w.responseDescription),
 			ixml.EndElement{Name: name},
 		)
 	}
 	end = append(end, ixml.EndElement{
 		Name: ixml.Name{Space: "DAV:", Local: "multistatus"},
 	})
 	for _, t := range end {
 		err := w.enc.EncodeToken(t)
 		if err != nil {
 			return err
 		}
 	}
 	return w.enc.Flush()
 }

 var xmlLangName = ixml.Name{Space: "http://www.w3.org/XML/1998/namespace", Local: "lang"}

 func xmlLang(s ixml.StartElement, d string) string {
 	for _, attr := range s.Attr {
 		if attr.Name == xmlLangName {
 			return attr.Value
 		}
 	}
 	return d
 }

 type xmlValue []byte

 func (v *xmlValue) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error {
 	// The XML value of a property can be arbitrary, mixed-content XML.
 	// To make sure that the unmarshalled value contains all required
 	// namespaces, we encode all the property value XML tokens into a
 	// buffer. This forces the encoder to redeclare any used namespaces.
 	var b bytes.Buffer
 	e := ixml.NewEncoder(&b)
 	for {
 		t, err := next(d)
 		if err != nil {
 			return err
 		}
 		if e, ok := t.(ixml.EndElement); ok && e.Name == start.Name {
 			break
 		}
 		if err = e.EncodeToken(t); err != nil {
 			return err
 		}
 	}
 	err := e.Flush()
 	if err != nil {
 		return err
 	}
 	*v = b.Bytes()
 	return nil
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for proppatch)
 type proppatchProps []Property

 // UnmarshalXML appends the property names and values enclosed within start
 // to ps.
 //
 // An xml:lang attribute that is defined either on the DAV:prop or property
 // name XML element is propagated to the property's Lang field.
 //
 // UnmarshalXML returns an error if start does not contain any properties or if
 // property values contain syntactically incorrect XML.
 func (ps *proppatchProps) UnmarshalXML(d *ixml.Decoder, start ixml.StartElement) error {
 	lang := xmlLang(start, "")
 	for {
 		t, err := next(d)
 		if err != nil {
 			return err
 		}
 		switch elem := t.(type) {
 		case ixml.EndElement:
 			if len(*ps) == 0 {
 				return fmt.Errorf("%s must not be empty", start.Name.Local)
 			}
 			return nil
 		case ixml.StartElement:
 			p := Property{
 				XMLName: xml.Name(t.(ixml.StartElement).Name),
 				Lang:    xmlLang(t.(ixml.StartElement), lang),
 			}
 			err = d.DecodeElement(((*xmlValue)(&p.InnerXML)), &elem)
 			if err != nil {
 				return err
 			}
 			*ps = append(*ps, p)
 		}
 	}
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_set
 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_remove
 type setRemove struct {
 	XMLName ixml.Name
 	Lang    string         `xml:"xml:lang,attr,omitempty"`
 	Prop    proppatchProps `xml:"DAV: prop"`
 }

 // http://www.webdav.org/specs/rfc4918.html#ELEMENT_propertyupdate
 type propertyupdate struct {
 	XMLName   ixml.Name   `xml:"DAV: propertyupdate"`
 	Lang      string      `xml:"xml:lang,attr,omitempty"`
 	SetRemove []setRemove `xml:",any"`
 }

 func readProppatch(r io.Reader) (patches []Proppatch, status int, err error) {
 	var pu propertyupdate
 	if err = ixml.NewDecoder(r).Decode(&pu); err != nil {
 		return nil, http.StatusBadRequest, err
 	}
 	for _, op := range pu.SetRemove {
 		remove := false
 		switch op.XMLName {
 		case ixml.Name{Space: "DAV:", Local: "set"}:
 			// No-op.
 		case ixml.Name{Space: "DAV:", Local: "remove"}:
 			for _, p := range op.Prop {
 				if len(p.InnerXML) > 0 {
 					return nil, http.StatusBadRequest, errInvalidProppatch
 				}
 			}
 			remove = true
 		default:
 			return nil, http.StatusBadRequest, errInvalidProppatch
 		}
 		patches = append(patches, Proppatch{Remove: remove, Props: op.Prop})
 	}
 	return patches, 0, nil
 }
	// Copyright 2014 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package webdav

	// The XML encoding is covered by Section 14.
	// http://www.webdav.org/specs/rfc4918.html#xml.element.definitions

	import (
	"bytes"
	"encoding/xml"
	"fmt"
	"io"
	"net/http"
	"time"

	// As of https://go-review.googlesource.com/#/c/12772/ which was submitted
	// in July 2015, this package uses an internal fork of the standard
	// library's encoding/xml package, due to changes in the way namespaces
	// were encoded. Such changes were introduced in the Go 1.5 cycle, but were
	// rolled back in response to https://github.com/golang/go/issues/11841
	//
	// However, this package's exported API, specifically the Property and
	// DeadPropsHolder types, need to refer to the standard library's version
	// of the xml.Name type, as code that imports this package cannot refer to
	// the internal version.
	//
	// This file therefore imports both the internal and external versions, as
	// ixml and xml, and converts between them.
	//
	// In the long term, this package should use the standard library's version
	// only, and the internal fork deleted, once
	// https://github.com/golang/go/issues/13400 is resolved.
	ixml "golang.org/x/net/webdav/internal/xml"
	)

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_lockinfo
	type lockInfo struct {
	XMLName ixml.Name `xml:"lockinfo"`
	Exclusive *struct{} `xml:"lockscope>exclusive"`
	Shared *struct{} `xml:"lockscope>shared"`
	Write *struct{} `xml:"locktype>write"`
	Owner owner `xml:"owner"`
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_owner
	type owner struct {
	InnerXML string `xml:",innerxml"`
	}

	func readLockInfo(r io.Reader) (li lockInfo, status int, err error) {
	c := &countingReader{r: r}
	if err = ixml.NewDecoder(c).Decode(&li); err != nil {
	if err == io.EOF {
	if c.n == 0 {
	// An empty body means to refresh the lock.
	// http://www.webdav.org/specs/rfc4918.html#refreshing-locks
	return lockInfo{}, 0, nil
	}
	err = errInvalidLockInfo
	}
	return lockInfo{}, http.StatusBadRequest, err
	}
	// We only support exclusive (non-shared) write locks. In practice, these are
	// the only types of locks that seem to matter.
	if li.Exclusive == nil \|\| li.Shared != nil \|\| li.Write == nil {
	return lockInfo{}, http.StatusNotImplemented, errUnsupportedLockInfo
	}
	return li, 0, nil
	}

	type countingReader struct {
	n int
	r io.Reader
	}

	func (c *countingReader) Read(p []byte) (int, error) {
	n, err := c.r.Read(p)
	c.n += n
	return n, err
	}

	func writeLockInfo(w io.Writer, token string, ld LockDetails) (int, error) {
	depth := "infinity"
	if ld.ZeroDepth {
	depth = "0"
	}
	timeout := ld.Duration / time.Second
	return fmt.Fprintf(w, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"+
	"<D:prop xmlns:D=\"DAV:\"><D:lockdiscovery><D:activelock>\n"+
	" <D:locktype><D:write/></D:locktype>\n"+
	" <D:lockscope><D:exclusive/></D:lockscope>\n"+
	" <D:depth>%s</D:depth>\n"+
	" <D:owner>%s</D:owner>\n"+
	" <D:timeout>Second-%d</D:timeout>\n"+
	" <D:locktoken><D:href>%s</D:href></D:locktoken>\n"+
	" <D:lockroot><D:href>%s</D:href></D:lockroot>\n"+
	"</D:activelock></D:lockdiscovery></D:prop>",
	depth, ld.OwnerXML, timeout, escape(token), escape(ld.Root),
	)
	}

	func escape(s string) string {
	for i := 0; i < len(s); i++ {
	switch s[i] {
	case '"', '&', '\'', '<', '>':
	b := bytes.NewBuffer(nil)
	ixml.EscapeText(b, []byte(s))
	return b.String()
	}
	}
	return s
	}

	// Next returns the next token, if any, in the XML stream of d.
	// RFC 4918 requires to ignore comments, processing instructions
	// and directives.
	// http://www.webdav.org/specs/rfc4918.html#property_values
	// http://www.webdav.org/specs/rfc4918.html#xml-extensibility
	func next(d *ixml.Decoder) (ixml.Token, error) {
	for {
	t, err := d.Token()
	if err != nil {
	return t, err
	}
	switch t.(type) {
	case ixml.Comment, ixml.Directive, ixml.ProcInst:
	continue
	default:
	return t, nil
	}
	}
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind)
	type propfindProps []xml.Name

	// UnmarshalXML appends the property names enclosed within start to pn.
	//
	// It returns an error if start does not contain any properties or if
	// properties contain values. Character data between properties is ignored.
	func (pn propfindProps) UnmarshalXML(d ixml.Decoder, start ixml.StartElement) error {
	for {
	t, err := next(d)
	if err != nil {
	return err
	}
	switch t.(type) {
	case ixml.EndElement:
	if len(*pn) == 0 {
	return fmt.Errorf("%s must not be empty", start.Name.Local)
	}
	return nil
	case ixml.StartElement:
	name := t.(ixml.StartElement).Name
	t, err = next(d)
	if err != nil {
	return err
	}
	if _, ok := t.(ixml.EndElement); !ok {
	return fmt.Errorf("unexpected token %T", t)
	}
	pn = append(pn, xml.Name(name))
	}
	}
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propfind
	type propfind struct {
	XMLName ixml.Name `xml:"DAV: propfind"`
	Allprop *struct{} `xml:"DAV: allprop"`
	Propname *struct{} `xml:"DAV: propname"`
	Prop propfindProps `xml:"DAV: prop"`
	Include propfindProps `xml:"DAV: include"`
	}

	func readPropfind(r io.Reader) (pf propfind, status int, err error) {
	c := countingReader{r: r}
	if err = ixml.NewDecoder(&c).Decode(&pf); err != nil {
	if err == io.EOF {
	if c.n == 0 {
	// An empty body means to propfind allprop.
	// http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND
	return propfind{Allprop: new(struct{})}, 0, nil
	}
	err = errInvalidPropfind
	}
	return propfind{}, http.StatusBadRequest, err
	}

	if pf.Allprop == nil && pf.Include != nil {
	return propfind{}, http.StatusBadRequest, errInvalidPropfind
	}
	if pf.Allprop != nil && (pf.Prop != nil \|\| pf.Propname != nil) {
	return propfind{}, http.StatusBadRequest, errInvalidPropfind
	}
	if pf.Prop != nil && pf.Propname != nil {
	return propfind{}, http.StatusBadRequest, errInvalidPropfind
	}
	if pf.Propname == nil && pf.Allprop == nil && pf.Prop == nil {
	return propfind{}, http.StatusBadRequest, errInvalidPropfind
	}
	return pf, 0, nil
	}

	// Property represents a single DAV resource property as defined in RFC 4918.
	// See http://www.webdav.org/specs/rfc4918.html#data.model.for.resource.properties
	type Property struct {
	// XMLName is the fully qualified name that identifies this property.
	XMLName xml.Name

	// Lang is an optional xml:lang attribute.
	Lang string `xml:"xml:lang,attr,omitempty"`

	// InnerXML contains the XML representation of the property value.
	// See http://www.webdav.org/specs/rfc4918.html#property_values
	//
	// Property values of complex type or mixed-content must have fully
	// expanded XML namespaces or be self-contained with according
	// XML namespace declarations. They must not rely on any XML
	// namespace declarations within the scope of the XML document,
	// even including the DAV: namespace.
	InnerXML []byte `xml:",innerxml"`
	}

	// ixmlProperty is the same as the Property type except it holds an ixml.Name
	// instead of an xml.Name.
	type ixmlProperty struct {
	XMLName ixml.Name
	Lang string `xml:"xml:lang,attr,omitempty"`
	InnerXML []byte `xml:",innerxml"`
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_error
	// See multistatusWriter for the "D:" namespace prefix.
	type xmlError struct {
	XMLName ixml.Name `xml:"D:error"`
	InnerXML []byte `xml:",innerxml"`
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propstat
	// See multistatusWriter for the "D:" namespace prefix.
	type propstat struct {
	Prop []Property `xml:"D:prop>_ignored_"`
	Status string `xml:"D:status"`
	Error *xmlError `xml:"D:error"`
	ResponseDescription string `xml:"D:responsedescription,omitempty"`
	}

	// ixmlPropstat is the same as the propstat type except it holds an ixml.Name
	// instead of an xml.Name.
	type ixmlPropstat struct {
	Prop []ixmlProperty `xml:"D:prop>_ignored_"`
	Status string `xml:"D:status"`
	Error *xmlError `xml:"D:error"`
	ResponseDescription string `xml:"D:responsedescription,omitempty"`
	}

	// MarshalXML prepends the "D:" namespace prefix on properties in the DAV: namespace
	// before encoding. See multistatusWriter.
	func (ps propstat) MarshalXML(e *ixml.Encoder, start ixml.StartElement) error {
	// Convert from a propstat to an ixmlPropstat.
	ixmlPs := ixmlPropstat{
	Prop: make([]ixmlProperty, len(ps.Prop)),
	Status: ps.Status,
	Error: ps.Error,
	ResponseDescription: ps.ResponseDescription,
	}
	for k, prop := range ps.Prop {
	ixmlPs.Prop[k] = ixmlProperty{
	XMLName: ixml.Name(prop.XMLName),
	Lang: prop.Lang,
	InnerXML: prop.InnerXML,
	}
	}

	for k, prop := range ixmlPs.Prop {
	if prop.XMLName.Space == "DAV:" {
	prop.XMLName = ixml.Name{Space: "", Local: "D:" + prop.XMLName.Local}
	ixmlPs.Prop[k] = prop
	}
	}
	// Distinct type to avoid infinite recursion of MarshalXML.
	type newpropstat ixmlPropstat
	return e.EncodeElement(newpropstat(ixmlPs), start)
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_response
	// See multistatusWriter for the "D:" namespace prefix.
	type response struct {
	XMLName ixml.Name `xml:"D:response"`
	Href []string `xml:"D:href"`
	Propstat []propstat `xml:"D:propstat"`
	Status string `xml:"D:status,omitempty"`
	Error *xmlError `xml:"D:error"`
	ResponseDescription string `xml:"D:responsedescription,omitempty"`
	}

	// MultistatusWriter marshals one or more Responses into a XML
	// multistatus response.
	// See http://www.webdav.org/specs/rfc4918.html#ELEMENT_multistatus
	// TODO(rsto, mpl): As a workaround, the "D:" namespace prefix, defined as
	// "DAV:" on this element, is prepended on the nested response, as well as on all
	// its nested elements. All property names in the DAV: namespace are prefixed as
	// well. This is because some versions of Mini-Redirector (on windows 7) ignore
	// elements with a default namespace (no prefixed namespace). A less intrusive fix
	// should be possible after golang.org/cl/11074. See https://golang.org/issue/11177
	type multistatusWriter struct {
	// ResponseDescription contains the optional responsedescription
	// of the multistatus XML element. Only the latest content before
	// close will be emitted. Empty response descriptions are not
	// written.
	responseDescription string

	w http.ResponseWriter
	enc *ixml.Encoder
	}

	// Write validates and emits a DAV response as part of a multistatus response
	// element.
	//
	// It sets the HTTP status code of its underlying http.ResponseWriter to 207
	// (Multi-Status) and populates the Content-Type header. If r is the
	// first, valid response to be written, Write prepends the XML representation
	// of r with a multistatus tag. Callers must call close after the last response
	// has been written.
	func (w multistatusWriter) write(r response) error {
	switch len(r.Href) {
	case 0:
	return errInvalidResponse
	case 1:
	if len(r.Propstat) > 0 != (r.Status == "") {
	return errInvalidResponse
	}
	default:
	if len(r.Propstat) > 0 \|\| r.Status == "" {
	return errInvalidResponse
	}
	}
	err := w.writeHeader()
	if err != nil {
	return err
	}
	return w.enc.Encode(r)
	}

	// writeHeader writes a XML multistatus start element on w's underlying
	// http.ResponseWriter and returns the result of the write operation.
	// After the first write attempt, writeHeader becomes a no-op.
	func (w *multistatusWriter) writeHeader() error {
	if w.enc != nil {
	return nil
	}
	w.w.Header().Add("Content-Type", "text/xml; charset=utf-8")
	w.w.WriteHeader(StatusMulti)
	_, err := fmt.Fprintf(w.w, `<?xml version="1.0" encoding="UTF-8"?>`)
	if err != nil {
	return err
	}
	w.enc = ixml.NewEncoder(w.w)
	return w.enc.EncodeToken(ixml.StartElement{
	Name: ixml.Name{
	Space: "DAV:",
	Local: "multistatus",
	},
	Attr: []ixml.Attr{{
	Name: ixml.Name{Space: "xmlns", Local: "D"},
	Value: "DAV:",
	}},
	})
	}

	// Close completes the marshalling of the multistatus response. It returns
	// an error if the multistatus response could not be completed. If both the
	// return value and field enc of w are nil, then no multistatus response has
	// been written.
	func (w *multistatusWriter) close() error {
	if w.enc == nil {
	return nil
	}
	var end []ixml.Token
	if w.responseDescription != "" {
	name := ixml.Name{Space: "DAV:", Local: "responsedescription"}
	end = append(end,
	ixml.StartElement{Name: name},
	ixml.CharData(w.responseDescription),
	ixml.EndElement{Name: name},
	)
	}
	end = append(end, ixml.EndElement{
	Name: ixml.Name{Space: "DAV:", Local: "multistatus"},
	})
	for _, t := range end {
	err := w.enc.EncodeToken(t)
	if err != nil {
	return err
	}
	}
	return w.enc.Flush()
	}

	var xmlLangName = ixml.Name{Space: "http://www.w3.org/XML/1998/namespace", Local: "lang"}

	func xmlLang(s ixml.StartElement, d string) string {
	for _, attr := range s.Attr {
	if attr.Name == xmlLangName {
	return attr.Value
	}
	}
	return d
	}

	type xmlValue []byte

	func (v xmlValue) UnmarshalXML(d ixml.Decoder, start ixml.StartElement) error {
	// The XML value of a property can be arbitrary, mixed-content XML.
	// To make sure that the unmarshalled value contains all required
	// namespaces, we encode all the property value XML tokens into a
	// buffer. This forces the encoder to redeclare any used namespaces.
	var b bytes.Buffer
	e := ixml.NewEncoder(&b)
	for {
	t, err := next(d)
	if err != nil {
	return err
	}
	if e, ok := t.(ixml.EndElement); ok && e.Name == start.Name {
	break
	}
	if err = e.EncodeToken(t); err != nil {
	return err
	}
	}
	err := e.Flush()
	if err != nil {
	return err
	}
	*v = b.Bytes()
	return nil
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for proppatch)
	type proppatchProps []Property

	// UnmarshalXML appends the property names and values enclosed within start
	// to ps.
	//
	// An xml:lang attribute that is defined either on the DAV:prop or property
	// name XML element is propagated to the property's Lang field.
	//
	// UnmarshalXML returns an error if start does not contain any properties or if
	// property values contain syntactically incorrect XML.
	func (ps proppatchProps) UnmarshalXML(d ixml.Decoder, start ixml.StartElement) error {
	lang := xmlLang(start, "")
	for {
	t, err := next(d)
	if err != nil {
	return err
	}
	switch elem := t.(type) {
	case ixml.EndElement:
	if len(*ps) == 0 {
	return fmt.Errorf("%s must not be empty", start.Name.Local)
	}
	return nil
	case ixml.StartElement:
	p := Property{
	XMLName: xml.Name(t.(ixml.StartElement).Name),
	Lang: xmlLang(t.(ixml.StartElement), lang),
	}
	err = d.DecodeElement(((*xmlValue)(&p.InnerXML)), &elem)
	if err != nil {
	return err
	}
	ps = append(ps, p)
	}
	}
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_set
	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_remove
	type setRemove struct {
	XMLName ixml.Name
	Lang string `xml:"xml:lang,attr,omitempty"`
	Prop proppatchProps `xml:"DAV: prop"`
	}

	// http://www.webdav.org/specs/rfc4918.html#ELEMENT_propertyupdate
	type propertyupdate struct {
	XMLName ixml.Name `xml:"DAV: propertyupdate"`
	Lang string `xml:"xml:lang,attr,omitempty"`
	SetRemove []setRemove `xml:",any"`
	}

	func readProppatch(r io.Reader) (patches []Proppatch, status int, err error) {
	var pu propertyupdate
	if err = ixml.NewDecoder(r).Decode(&pu); err != nil {
	return nil, http.StatusBadRequest, err
	}
	for _, op := range pu.SetRemove {
	remove := false
	switch op.XMLName {
	case ixml.Name{Space: "DAV:", Local: "set"}:
	// No-op.
	case ixml.Name{Space: "DAV:", Local: "remove"}:
	for _, p := range op.Prop {
	if len(p.InnerXML) > 0 {
	return nil, http.StatusBadRequest, errInvalidProppatch
	}
	}
	remove = true
	default:
	return nil, http.StatusBadRequest, errInvalidProppatch
	}
	patches = append(patches, Proppatch{Remove: remove, Props: op.Prop})
	}
	return patches, 0, nil
	}