carddav: add support for REPORT addressbook-multiget, fixes #2

This commit is contained in:
emersion 2017-09-11 19:10:12 +02:00
parent 777948e9c1
commit 0581850864
No known key found for this signature in database
GPG Key ID: 0FDE7BE0E88F5E48
8 changed files with 516 additions and 338 deletions

View File

@ -5,12 +5,9 @@ package carddav
import ( import (
"bytes" "bytes"
"encoding/xml" "encoding/xml"
"errors"
"net/http" "net/http"
"net/url"
"os" "os"
"strconv"
"strings"
"time"
"github.com/emersion/go-vcard" "github.com/emersion/go-vcard"
"github.com/emersion/go-webdav" "github.com/emersion/go-webdav"
@ -19,310 +16,7 @@ import (
"log" "log"
) )
var ( var addressDataName = xml.Name{Space: "urn:ietf:params:xml:ns:carddav", Local: "address-data"}
errNotYetImplemented = errors.New("not yet implemented")
errUnsupported = errors.New("unsupported")
)
const nsDAV = "DAV:"
var (
resourcetype = xml.Name{Space: nsDAV, Local: "resourcetype"}
displayname = xml.Name{Space: nsDAV, Local: "displayname"}
getcontenttype = xml.Name{Space: nsDAV, Local: "getcontenttype"}
)
const nsCardDAV = "urn:ietf:params:xml:ns:carddav"
var (
addressBookDescription = xml.Name{Space: nsCardDAV, Local: "addressbook-description"}
addressBookSupportedAddressData = xml.Name{Space: nsCardDAV, Local: "supported-address-data"}
addressBookMaxResourceSize = xml.Name{Space: nsCardDAV, Local: "max-resource-size"}
addressBookHomeSet = xml.Name{Space: nsCardDAV, Local: "addressbook-home-set"}
)
type fileInfo struct {
name string
size int64
mode os.FileMode
modTime time.Time
}
func (fi *fileInfo) Name() string {
return fi.name
}
func (fi *fileInfo) Size() int64 {
return fi.size
}
func (fi *fileInfo) Mode() os.FileMode {
return fi.mode
}
func (fi *fileInfo) ModTime() time.Time {
return fi.modTime
}
func (fi *fileInfo) IsDir() bool {
return fi.mode.IsDir()
}
func (fi *fileInfo) Sys() interface{} {
return nil
}
type file struct {
*bytes.Reader
fs *fileSystem
name string
ao AddressObject
}
func (f *file) Close() error {
return nil
}
func (f *file) Read(b []byte) (int, error) {
if f.Reader == nil {
card, err := f.ao.Card()
if err != nil {
return 0, err
}
var b bytes.Buffer
if err := vcard.NewEncoder(&b).Encode(card); err != nil {
return 0, err
}
f.Reader = bytes.NewReader(b.Bytes())
}
return f.Reader.Read(b)
}
func (f *file) Write(b []byte) (int, error) {
return 0, errUnsupported
}
func (f *file) Seek(offset int64, whence int) (int64, error) {
if f.Reader == nil {
if _, err := f.Read(nil); err != nil {
return 0, err
}
}
return f.Reader.Seek(offset, whence)
}
func (f *file) Readdir(count int) ([]os.FileInfo, error) {
return nil, errUnsupported
}
func (f *file) Stat() (os.FileInfo, error) {
info, err := f.ao.Stat()
if info != nil || err != nil {
return info, err
}
return &fileInfo{
name: f.name,
mode: os.ModePerm,
}, nil
}
// TODO: getcontenttype for file
type dir struct {
fs *fileSystem
name string
files []os.FileInfo
n int
}
func (d *dir) Close() error {
return nil
}
func (d *dir) Read(b []byte) (int, error) {
return 0, errUnsupported
}
func (d *dir) Write(b []byte) (int, error) {
return 0, errUnsupported
}
func (d *dir) Seek(offset int64, whence int) (int64, error) {
return 0, errUnsupported
}
func (d *dir) Readdir(count int) ([]os.FileInfo, error) {
if d.files == nil {
aos, err := d.fs.ab.ListAddressObjects()
if err != nil {
return nil, err
}
d.files = make([]os.FileInfo, len(aos))
for i, ao := range aos {
f := &file{
fs: d.fs,
name: ao.ID() + ".vcf",
ao: ao,
}
info, err := f.Stat()
if err != nil {
return nil, err
}
d.files[i] = info
}
}
if count == 0 {
count = len(d.files) - d.n
}
if d.n >= len(d.files) {
return nil, nil
}
from := d.n
d.n += count
if d.n > len(d.files) {
d.n = len(d.files)
}
return d.files[from:d.n], nil
}
func (d *dir) Stat() (os.FileInfo, error) {
return &fileInfo{
name: d.name,
mode: os.ModeDir | os.ModePerm,
}, nil
}
func (d *dir) DeadProps() (map[xml.Name]webdav.Property, error) {
info, err := d.fs.ab.Info()
if err != nil {
return nil, err
}
return map[xml.Name]webdav.Property{
resourcetype: webdav.Property{
XMLName: resourcetype,
InnerXML: []byte(`<collection xmlns="DAV:"/><addressbook xmlns="urn:ietf:params:xml:ns:carddav"/>`),
},
displayname: webdav.Property{
XMLName: displayname,
InnerXML: []byte(info.Name),
},
addressBookDescription: webdav.Property{
XMLName: addressBookDescription,
InnerXML: []byte(info.Description),
},
addressBookSupportedAddressData: webdav.Property{
XMLName: addressBookSupportedAddressData,
InnerXML: []byte(`<address-data-type xmlns="urn:ietf:params:xml:ns:carddav" content-type="text/vcard" version="3.0"/>` +
`<address-data-type xmlns="urn:ietf:params:xml:ns:carddav" content-type="text/vcard" version="4.0"/>`),
},
addressBookMaxResourceSize: webdav.Property{
XMLName: addressBookMaxResourceSize,
InnerXML: []byte(strconv.Itoa(info.MaxResourceSize)),
},
addressBookHomeSet: webdav.Property{
XMLName: addressBookHomeSet,
InnerXML: []byte(`<href xmlns="DAV:">/</href>`),
},
}, nil
}
func (d *dir) Patch([]webdav.Proppatch) ([]webdav.Propstat, error) {
return nil, errUnsupported
}
type fileSystem struct {
ab AddressBook
}
func (fs *fileSystem) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
return errNotYetImplemented
}
func (fs *fileSystem) addressObjectID(name string) string {
return strings.TrimRight(strings.TrimLeft(name, "/"), ".vcf")
}
func (fs *fileSystem) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
if name == "/" {
return &dir{
fs: fs,
name: name,
}, nil
}
id := fs.addressObjectID(name)
ao, err := fs.ab.GetAddressObject(id)
if err != nil {
return nil, err
}
return &file{
fs: fs,
name: name,
ao: ao,
}, nil
}
func (fs *fileSystem) RemoveAll(ctx context.Context, name string) error {
return errNotYetImplemented
}
func (fs *fileSystem) Rename(ctx context.Context, oldName, newName string) error {
return errNotYetImplemented
}
func (fs *fileSystem) Stat(ctx context.Context, name string) (os.FileInfo, error) {
if name == "/" {
return &fileInfo{
name: name,
mode: os.ModeDir | os.ModePerm,
}, nil
}
id := fs.addressObjectID(name)
ao, err := fs.ab.GetAddressObject(id)
if err != nil {
return nil, err
}
info, err := ao.Stat()
if info != nil || err != nil {
return info, err
}
return &fileInfo{
name: name,
mode: os.ModePerm,
}, nil
}
type Handler struct {
webdav *webdav.Handler
}
func NewHandler(ab AddressBook) *Handler {
return &Handler{&webdav.Handler{
FileSystem: &fileSystem{ab},
Logger: func(req *http.Request, err error) {
if err != nil {
log.Println("ERROR", req, err)
}
},
}}
}
type responseWriter struct { type responseWriter struct {
http.ResponseWriter http.ResponseWriter
@ -333,11 +27,162 @@ func (w responseWriter) Write(b []byte) (int, error) {
return w.ResponseWriter.Write(b) return w.ResponseWriter.Write(b)
} }
func (h *Handler) ServeHTTP(resp http.ResponseWriter, req *http.Request) { type Handler struct {
log.Printf("%+v\n", req) ab AddressBook
if req.Method == http.MethodOptions { webdav *webdav.Handler
resp.Header().Add("DAV", "addressbook")
} }
//h.webdav.ServeHTTP(resp, req)
h.webdav.ServeHTTP(responseWriter{resp}, req) func NewHandler(ab AddressBook) *Handler {
return &Handler{
ab: ab,
webdav: &webdav.Handler{
FileSystem: &fileSystem{ab},
Logger: func(req *http.Request, err error) {
if err != nil {
log.Println("ERROR", req, err)
}
},
},
}
}
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
log.Printf("%+v\n", r)
if r.Method == http.MethodOptions {
w.Header().Add("DAV", "addressbook")
}
w = responseWriter{w}
switch r.Method {
case "REPORT":
status, _ := h.handleReport(w, r)
if status != 0 {
w.WriteHeader(status)
}
case "OPTIONS":
w.Header().Add("Allow", "REPORT")
fallthrough
default:
h.webdav.ServeHTTP(w, r)
}
}
func (h *Handler) handleReport(w http.ResponseWriter, r *http.Request) (int, error) {
var mg addressbookMultiget
if err := xml.NewDecoder(r.Body).Decode(&mg); err != nil {
return http.StatusBadRequest, err
}
log.Printf("%#v\n", mg)
mw := webdav.NewMultistatusWriter(w)
defer mw.Close()
if len(mg.Href) == 0 {
mg.Href = []string{r.URL.Path}
}
for _, href := range mg.Href {
pstats, status, _ := multiget(r.Context(), h.webdav.FileSystem, h.webdav.LockSystem, href, []xml.Name(mg.Prop), mg.Allprop != nil)
// TODO: error handling
resp := &webdav.Response{
Href: []string{(&url.URL{Path: href}).EscapedPath()},
Status: status,
Propstat: pstats,
}
if err := mw.Write(resp); err != nil {
return http.StatusInternalServerError, err
}
}
return 0, nil
}
func multiget(ctx context.Context, fs webdav.FileSystem, ls webdav.LockSystem, name string, pnames []xml.Name, allprop bool) ([]webdav.Propstat, int, error) {
wantAddressData := false
for i, pname := range pnames {
if pname == addressDataName {
pnames = append(pnames[:i], pnames[i+1:]...)
wantAddressData = true
break
}
}
var pstats []webdav.Propstat
var err error
if allprop {
wantAddressData = true
pstats, err = webdav.Allprop(ctx, fs, ls, name, pnames)
} else {
pstats, err = webdav.Props(ctx, fs, ls, name, pnames)
}
if err != nil {
return pstats, http.StatusInternalServerError, err
}
// TODO: locking stuff
f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
if err != nil {
return nil, http.StatusNotFound, err
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return nil, http.StatusNotFound, err
}
if wantAddressData {
if fi.IsDir() {
// TODO
return nil, http.StatusNotFound, err
}
prop, status, _ := addressdata(f.(*file).ao)
if status == 0 {
status = http.StatusOK
}
inserted := false
for i, pstat := range pstats {
if pstat.Status == status {
pstats[i].Props = append(pstat.Props, prop)
inserted = true
break
}
}
if !inserted {
pstats = append(pstats, webdav.Propstat{
Props: []webdav.Property{prop},
Status: status,
})
}
}
return pstats, 0, nil
}
func addressdata(ao AddressObject) (webdav.Property, int, error) {
prop := webdav.Property{XMLName: addressDataName}
card, err := ao.Card()
if err != nil {
return prop, http.StatusInternalServerError, err
}
// TODO: restrict to requested props
var b bytes.Buffer
if err := vcard.NewEncoder(&b).Encode(card); err != nil {
return prop, http.StatusInternalServerError, err
}
var escaped bytes.Buffer
if err := xml.EscapeText(&escaped, b.Bytes()); err != nil {
return prop, http.StatusInternalServerError, err
}
prop.InnerXML = escaped.Bytes()
return prop, 0, nil
} }

307
carddav/fs.go Normal file
View File

@ -0,0 +1,307 @@
// Package carddav provides a CardDAV server implementation, as defined in
// RFC 6352.
package carddav
import (
"bytes"
"encoding/xml"
"errors"
"os"
"strconv"
"strings"
"time"
"github.com/emersion/go-vcard"
"github.com/emersion/go-webdav"
"golang.org/x/net/context"
)
var (
errNotYetImplemented = errors.New("not yet implemented")
errUnsupported = errors.New("unsupported")
)
const nsDAV = "DAV:"
var (
resourcetype = xml.Name{Space: nsDAV, Local: "resourcetype"}
displayname = xml.Name{Space: nsDAV, Local: "displayname"}
getcontenttype = xml.Name{Space: nsDAV, Local: "getcontenttype"}
)
const nsCardDAV = "urn:ietf:params:xml:ns:carddav"
var (
addressBookDescription = xml.Name{Space: nsCardDAV, Local: "addressbook-description"}
addressBookSupportedAddressData = xml.Name{Space: nsCardDAV, Local: "supported-address-data"}
addressBookMaxResourceSize = xml.Name{Space: nsCardDAV, Local: "max-resource-size"}
addressBookHomeSet = xml.Name{Space: nsCardDAV, Local: "addressbook-home-set"}
)
type fileInfo struct {
name string
size int64
mode os.FileMode
modTime time.Time
}
func (fi *fileInfo) Name() string {
return fi.name
}
func (fi *fileInfo) Size() int64 {
return fi.size
}
func (fi *fileInfo) Mode() os.FileMode {
return fi.mode
}
func (fi *fileInfo) ModTime() time.Time {
return fi.modTime
}
func (fi *fileInfo) IsDir() bool {
return fi.mode.IsDir()
}
func (fi *fileInfo) Sys() interface{} {
return nil
}
type file struct {
*bytes.Reader
fs *fileSystem
name string
ao AddressObject
}
func (f *file) Close() error {
return nil
}
func (f *file) Read(b []byte) (int, error) {
if f.Reader == nil {
card, err := f.ao.Card()
if err != nil {
return 0, err
}
var b bytes.Buffer
if err := vcard.NewEncoder(&b).Encode(card); err != nil {
return 0, err
}
f.Reader = bytes.NewReader(b.Bytes())
}
return f.Reader.Read(b)
}
func (f *file) Write(b []byte) (int, error) {
return 0, errUnsupported
}
func (f *file) Seek(offset int64, whence int) (int64, error) {
if f.Reader == nil {
if _, err := f.Read(nil); err != nil {
return 0, err
}
}
return f.Reader.Seek(offset, whence)
}
func (f *file) Readdir(count int) ([]os.FileInfo, error) {
return nil, errUnsupported
}
func (f *file) Stat() (os.FileInfo, error) {
info, err := f.ao.Stat()
if info != nil || err != nil {
return info, err
}
return &fileInfo{
name: f.name,
mode: os.ModePerm,
}, nil
}
// TODO: getcontenttype for file
type dir struct {
fs *fileSystem
name string
files []os.FileInfo
n int
}
func (d *dir) Close() error {
return nil
}
func (d *dir) Read(b []byte) (int, error) {
return 0, errUnsupported
}
func (d *dir) Write(b []byte) (int, error) {
return 0, errUnsupported
}
func (d *dir) Seek(offset int64, whence int) (int64, error) {
return 0, errUnsupported
}
func (d *dir) Readdir(count int) ([]os.FileInfo, error) {
if d.files == nil {
aos, err := d.fs.ab.ListAddressObjects()
if err != nil {
return nil, err
}
d.files = make([]os.FileInfo, len(aos))
for i, ao := range aos {
f := &file{
fs: d.fs,
name: ao.ID() + ".vcf",
ao: ao,
}
info, err := f.Stat()
if err != nil {
return nil, err
}
d.files[i] = info
}
}
if count == 0 {
count = len(d.files) - d.n
}
if d.n >= len(d.files) {
return nil, nil
}
from := d.n
d.n += count
if d.n > len(d.files) {
d.n = len(d.files)
}
return d.files[from:d.n], nil
}
func (d *dir) Stat() (os.FileInfo, error) {
return &fileInfo{
name: d.name,
mode: os.ModeDir | os.ModePerm,
}, nil
}
func (d *dir) DeadProps() (map[xml.Name]webdav.Property, error) {
info, err := d.fs.ab.Info()
if err != nil {
return nil, err
}
return map[xml.Name]webdav.Property{
resourcetype: webdav.Property{
XMLName: resourcetype,
InnerXML: []byte(`<collection xmlns="DAV:"/><addressbook xmlns="urn:ietf:params:xml:ns:carddav"/>`),
},
displayname: webdav.Property{
XMLName: displayname,
InnerXML: []byte(info.Name),
},
addressBookDescription: webdav.Property{
XMLName: addressBookDescription,
InnerXML: []byte(info.Description),
},
addressBookSupportedAddressData: webdav.Property{
XMLName: addressBookSupportedAddressData,
InnerXML: []byte(`<address-data-type xmlns="urn:ietf:params:xml:ns:carddav" content-type="text/vcard" version="3.0"/>` +
`<address-data-type xmlns="urn:ietf:params:xml:ns:carddav" content-type="text/vcard" version="4.0"/>`),
},
addressBookMaxResourceSize: webdav.Property{
XMLName: addressBookMaxResourceSize,
InnerXML: []byte(strconv.Itoa(info.MaxResourceSize)),
},
addressBookHomeSet: webdav.Property{
XMLName: addressBookHomeSet,
InnerXML: []byte(`<href xmlns="DAV:">/</href>`),
},
}, nil
}
func (d *dir) Patch([]webdav.Proppatch) ([]webdav.Propstat, error) {
return nil, errUnsupported
}
type fileSystem struct {
ab AddressBook
}
func (fs *fileSystem) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
return errNotYetImplemented
}
func (fs *fileSystem) addressObjectID(name string) string {
return strings.TrimRight(strings.TrimLeft(name, "/"), ".vcf")
}
func (fs *fileSystem) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
if name == "/" {
return &dir{
fs: fs,
name: name,
}, nil
}
id := fs.addressObjectID(name)
ao, err := fs.ab.GetAddressObject(id)
if err != nil {
return nil, err
}
return &file{
fs: fs,
name: name,
ao: ao,
}, nil
}
func (fs *fileSystem) RemoveAll(ctx context.Context, name string) error {
return errNotYetImplemented
}
func (fs *fileSystem) Rename(ctx context.Context, oldName, newName string) error {
return errNotYetImplemented
}
func (fs *fileSystem) Stat(ctx context.Context, name string) (os.FileInfo, error) {
if name == "/" {
return &fileInfo{
name: name,
mode: os.ModeDir | os.ModePerm,
}, nil
}
id := fs.addressObjectID(name)
ao, err := fs.ab.GetAddressObject(id)
if err != nil {
return nil, err
}
info, err := ao.Stat()
if info != nil || err != nil {
return info, err
}
return &fileInfo{
name: name,
mode: os.ModePerm,
}, nil
}

24
carddav/xml.go Normal file
View File

@ -0,0 +1,24 @@
package carddav
import (
"encoding/xml"
"github.com/emersion/go-webdav"
)
// https://tools.ietf.org/html/rfc6352#section-10.7
type addressbookMultiget struct {
XMLName xml.Name `xml:"urn:ietf:params:xml:ns:carddav addressbook-multiget"`
Allprop *struct{} `xml:"DAV: allprop"`
Propname *struct{} `xml:"DAV: propname"`
Prop webdav.PropfindProps `xml:"DAV: prop"`
Href []string `xml:"DAV: href"`
}
// TODO
type addressData struct {
XMLName xml.Name `xml:"urn:ietf:params:xml:ns:carddav address-data"`
ContentType string `xml:"content-type,attr"`
Version string `xml:"version,attr"`
Prop []string `xml:"prop>name,attr"`
}

View File

@ -160,13 +160,11 @@ var liveProps = map[xml.Name]struct {
}, },
} }
// TODO(nigeltao) merge props and allprop?
// Props returns the status of the properties named pnames for resource name. // Props returns the status of the properties named pnames for resource name.
// //
// Each Propstat has a unique status and each property name will only be part // Each Propstat has a unique status and each property name will only be part
// of one Propstat element. // of one Propstat element.
func props(ctx context.Context, fs FileSystem, ls LockSystem, name string, pnames []xml.Name) ([]Propstat, error) { 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) f, err := fs.OpenFile(ctx, name, os.O_RDONLY, 0)
if err != nil { if err != nil {
return nil, err return nil, err
@ -254,7 +252,7 @@ func propnames(ctx context.Context, fs FileSystem, ls LockSystem, name string) (
// returned if they are named in 'include'. // returned if they are named in 'include'.
// //
// See http://www.webdav.org/specs/rfc4918.html#METHOD_PROPFIND // 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) { func Allprop(ctx context.Context, fs FileSystem, ls LockSystem, name string, include []xml.Name) ([]Propstat, error) {
pnames, err := propnames(ctx, fs, ls, name) pnames, err := propnames(ctx, fs, ls, name)
if err != nil { if err != nil {
return nil, err return nil, err
@ -269,7 +267,7 @@ func allprop(ctx context.Context, fs FileSystem, ls LockSystem, name string, inc
pnames = append(pnames, pn) pnames = append(pnames, pn)
} }
} }
return props(ctx, fs, ls, name, pnames) return Props(ctx, fs, ls, name, pnames)
} }
// Patch patches the properties of resource name. The return values are // Patch patches the properties of resource name. The return values are

View File

@ -534,9 +534,9 @@ func TestMemPS(t *testing.T) {
} }
continue continue
case "allprop": case "allprop":
propstats, err = allprop(ctx, fs, ls, op.name, op.pnames) propstats, err = Allprop(ctx, fs, ls, op.name, op.pnames)
case "propfind": case "propfind":
propstats, err = props(ctx, fs, ls, op.name, op.pnames) propstats, err = Props(ctx, fs, ls, op.name, op.pnames)
case "proppatch": case "proppatch":
propstats, err = patch(ctx, fs, ls, op.name, op.patches) propstats, err = patch(ctx, fs, ls, op.name, op.patches)
default: default:

View File

@ -577,9 +577,9 @@ func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) (status
} }
pstats = append(pstats, pstat) pstats = append(pstats, pstat)
} else if pf.Allprop != nil { } else if pf.Allprop != nil {
pstats, err = allprop(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop) pstats, err = Allprop(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop)
} else { } else {
pstats, err = props(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop) pstats, err = Props(ctx, h.FileSystem, h.LockSystem, reqPath, pf.Prop)
} }
if err != nil { if err != nil {
return err return err

18
xml.go
View File

@ -115,13 +115,13 @@ func next(d *xml.Decoder) (xml.Token, error) {
} }
// http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind) // http://www.webdav.org/specs/rfc4918.html#ELEMENT_prop (for propfind)
type propfindProps []xml.Name type PropfindProps []xml.Name
// UnmarshalXML appends the property names enclosed within start to pn. // UnmarshalXML appends the property names enclosed within start to pn.
// //
// It returns an error if start does not contain any properties or if // It returns an error if start does not contain any properties or if
// properties contain values. Character data between properties is ignored. // properties contain values. Character data between properties is ignored.
func (pn *propfindProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { func (pn *PropfindProps) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
for { for {
t, err := next(d) t, err := next(d)
if err != nil { if err != nil {
@ -152,8 +152,8 @@ type propfind struct {
XMLName xml.Name `xml:"DAV: propfind"` XMLName xml.Name `xml:"DAV: propfind"`
Allprop *struct{} `xml:"DAV: allprop"` Allprop *struct{} `xml:"DAV: allprop"`
Propname *struct{} `xml:"DAV: propname"` Propname *struct{} `xml:"DAV: propname"`
Prop propfindProps `xml:"DAV: prop"` Prop PropfindProps `xml:"DAV: prop"`
Include propfindProps `xml:"DAV: include"` Include PropfindProps `xml:"DAV: include"`
} }
func readPropfind(r io.Reader) (pf propfind, status int, err error) { func readPropfind(r io.Reader) (pf propfind, status int, err error) {
@ -246,12 +246,16 @@ type MultistatusWriter struct {
// of the multistatus XML element. Only the latest content before // of the multistatus XML element. Only the latest content before
// close will be emitted. Empty response descriptions are not // close will be emitted. Empty response descriptions are not
// written. // written.
responseDescription string ResponseDescription string
w http.ResponseWriter w http.ResponseWriter
enc *xml.Encoder enc *xml.Encoder
} }
func NewMultistatusWriter(w http.ResponseWriter) *MultistatusWriter {
return &MultistatusWriter{w: w}
}
// Write validates and emits a DAV response as part of a multistatus response // Write validates and emits a DAV response as part of a multistatus response
// element. // element.
// //
@ -337,11 +341,11 @@ func (w *MultistatusWriter) Close() error {
return nil return nil
} }
var end []xml.Token var end []xml.Token
if w.responseDescription != "" { if w.ResponseDescription != "" {
name := xml.Name{Space: "DAV:", Local: "responsedescription"} name := xml.Name{Space: "DAV:", Local: "responsedescription"}
end = append(end, end = append(end,
xml.StartElement{Name: name}, xml.StartElement{Name: name},
xml.CharData(w.responseDescription), xml.CharData(w.ResponseDescription),
xml.EndElement{Name: name}, xml.EndElement{Name: name},
) )
} }

View File

@ -175,7 +175,7 @@ func TestReadPropfind(t *testing.T) {
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Allprop: new(struct{}), Allprop: new(struct{}),
Include: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Include: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: include followed by allprop", desc: "propfind: include followed by allprop",
@ -187,7 +187,7 @@ func TestReadPropfind(t *testing.T) {
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Allprop: new(struct{}), Allprop: new(struct{}),
Include: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Include: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: propfind", desc: "propfind: propfind",
@ -197,7 +197,7 @@ func TestReadPropfind(t *testing.T) {
"</A:propfind>", "</A:propfind>",
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: prop with ignored comments", desc: "propfind: prop with ignored comments",
@ -210,7 +210,7 @@ func TestReadPropfind(t *testing.T) {
"</A:propfind>", "</A:propfind>",
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: propfind with ignored whitespace", desc: "propfind: propfind with ignored whitespace",
@ -220,7 +220,7 @@ func TestReadPropfind(t *testing.T) {
"</A:propfind>", "</A:propfind>",
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: propfind with ignored mixed-content", desc: "propfind: propfind with ignored mixed-content",
@ -230,7 +230,7 @@ func TestReadPropfind(t *testing.T) {
"</A:propfind>", "</A:propfind>",
wantPF: propfind{ wantPF: propfind{
XMLName: xml.Name{Space: "DAV:", Local: "propfind"}, XMLName: xml.Name{Space: "DAV:", Local: "propfind"},
Prop: propfindProps{xml.Name{Space: "DAV:", Local: "displayname"}}, Prop: PropfindProps{xml.Name{Space: "DAV:", Local: "displayname"}},
}, },
}, { }, {
desc: "propfind: propname with ignored element (section A.4)", desc: "propfind: propname with ignored element (section A.4)",
@ -564,7 +564,7 @@ func TestMultistatusWriter(t *testing.T) {
loop: loop:
for _, tc := range testCases { for _, tc := range testCases {
rec := httptest.NewRecorder() rec := httptest.NewRecorder()
w := MultistatusWriter{w: rec, responseDescription: tc.respdesc} w := MultistatusWriter{w: rec, ResponseDescription: tc.respdesc}
if tc.writeHeader { if tc.writeHeader {
if err := w.writeHeader(); err != nil { if err := w.writeHeader(); err != nil {
t.Errorf("%s: got writeHeader error %v, want nil", tc.desc, err) t.Errorf("%s: got writeHeader error %v, want nil", tc.desc, err)