const (
    StatusMulti               = 207
    StatusUnprocessableEntity = 422
    StatusLocked              = 423
    StatusFailedDependency    = 424
    StatusInsufficientStorage = 507
)

Variables

var (
    // ErrConfirmationFailed is returned by a LockSystem's Confirm method.
    ErrConfirmationFailed = errors.New("webdav: confirmation failed")
    // ErrForbidden is returned by a LockSystem's Unlock method.
    ErrForbidden = errors.New("webdav: forbidden")
    // ErrLocked is returned by a LockSystem's Create, Refresh and Unlock methods.
    ErrLocked = errors.New("webdav: locked")
    // ErrNoSuchLock is returned by a LockSystem's Refresh and Unlock methods.
    ErrNoSuchLock = errors.New("webdav: no such lock")
)

func StatusText ¶

func StatusText(code int) string

type Condition ¶

Condition can match a WebDAV resource, based on a token or ETag. Exactly one of Token and ETag should be non-empty.

type Condition struct {
    Not   bool
    Token string
    ETag  string
}

type DeadPropsHolder ¶

DeadPropsHolder holds the dead properties of a resource.

Dead properties are those properties that are explicitly defined. In comparison, live properties, such as DAV:getcontentlength, are implicitly defined by the underlying resource, and cannot be explicitly overridden or removed. See the Terminology section of http://www.webdav.org/specs/rfc4918.html#rfc.section.3

There is a whitelist of the names of live properties. This package handles all live properties, and will only pass non-whitelisted names to the Patch method of DeadPropsHolder implementations.

type DeadPropsHolder interface {
    // DeadProps returns a copy of the dead properties held.
    DeadProps() (map[xml.Name]Property, error)

    // Patch patches the dead properties held.
    //
    // Patching is atomic; either all or no patches succeed. It returns (nil,
    // non-nil) if an internal server error occurred, otherwise the Propstats
    // collectively contain one Property for each proposed patch Property. If
    // all patches succeed, Patch returns a slice of length one and a Propstat
    // element with a 200 OK HTTP status code. If none succeed, for reasons
    // other than an internal server error, no Propstat has status 200 OK.
    //
    // For more details on when various HTTP status codes apply, see
    // http://www.webdav.org/specs/rfc4918.html#PROPPATCH-status
    Patch([]Proppatch) ([]Propstat, error)
}

type Dir ¶

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 (Dir) Mkdir ¶

func (d Dir) Mkdir(ctx context.Context, name string, perm os.FileMode) error

func (Dir) OpenFile ¶

func (d Dir) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (File, error)

func (Dir) RemoveAll ¶

func (d Dir) RemoveAll(ctx context.Context, name string) error

func (Dir) Rename ¶

func (d Dir) Rename(ctx context.Context, oldName, newName string) error

func (Dir) Stat ¶

func (d Dir) Stat(ctx context.Context, name string) (os.FileInfo, error)

type File ¶

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
}

type FileSystem ¶

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)
}

func NewMemFS ¶

func NewMemFS() FileSystem

NewMemFS returns a new in-memory FileSystem implementation.

type Handler ¶

type Handler struct {
    // Prefix is the URL path prefix to strip from WebDAV resource paths.
    Prefix string
    // FileSystem is the virtual file system.
    FileSystem FileSystem
    // LockSystem is the lock management system.
    LockSystem LockSystem
    // Logger is an optional error logger. If non-nil, it will be called
    // for all HTTP requests.
    Logger func(*http.Request, error)
}

func (*Handler) ServeHTTP ¶

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type LockDetails ¶

LockDetails are a lock's metadata.

type LockDetails struct {
    // Root is the root resource name being locked. For a zero-depth lock, the
    // root is the only resource being locked.
    Root string
    // Duration is the lock timeout. A negative duration means infinite.
    Duration time.Duration
    // OwnerXML is the verbatim <owner> XML given in a LOCK HTTP request.
    //
    // TODO: does the "verbatim" nature play well with XML namespaces?
    // Does the OwnerXML field need to have more structure? See
    // https://codereview.appspot.com/175140043/#msg2
    OwnerXML string
    // ZeroDepth is whether the lock has zero depth. If it does not have zero
    // depth, it has infinite depth.
    ZeroDepth bool
}

type LockSystem ¶

LockSystem manages access to a collection of named resources. The elements in a lock name are separated by slash ('/', U+002F) characters, regardless of host operating system convention.

type LockSystem interface {
    // Confirm confirms that the caller can claim all of the locks specified by
    // the given conditions, and that holding the union of all of those locks
    // gives exclusive access to all of the named resources. Up to two resources
    // can be named. Empty names are ignored.
    //
    // Exactly one of release and err will be non-nil. If release is non-nil,
    // all of the requested locks are held until release is called. Calling
    // release does not unlock the lock, in the WebDAV UNLOCK sense, but once
    // Confirm has confirmed that a lock claim is valid, that lock cannot be
    // Confirmed again until it has been released.
    //
    // If Confirm returns ErrConfirmationFailed then the Handler will continue
    // to try any other set of locks presented (a WebDAV HTTP request can
    // present more than one set of locks). If it returns any other non-nil
    // error, the Handler will write a "500 Internal Server Error" HTTP status.
    Confirm(now time.Time, name0, name1 string, conditions ...Condition) (release func(), err error)

    // Create creates a lock with the given depth, duration, owner and root
    // (name). The depth will either be negative (meaning infinite) or zero.
    //
    // If Create returns ErrLocked then the Handler will write a "423 Locked"
    // HTTP status. If it returns any other non-nil error, the Handler will
    // write a "500 Internal Server Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
    // when to use each error.
    //
    // The token returned identifies the created lock. It should be an absolute
    // URI as defined by RFC 3986, Section 4.3. In particular, it should not
    // contain whitespace.
    Create(now time.Time, details LockDetails) (token string, err error)

    // Refresh refreshes the lock with the given token.
    //
    // If Refresh returns ErrLocked then the Handler will write a "423 Locked"
    // HTTP Status. If Refresh returns ErrNoSuchLock then the Handler will write
    // a "412 Precondition Failed" HTTP Status. If it returns any other non-nil
    // error, the Handler will write a "500 Internal Server Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.10.6 for
    // when to use each error.
    Refresh(now time.Time, token string, duration time.Duration) (LockDetails, error)

    // Unlock unlocks the lock with the given token.
    //
    // If Unlock returns ErrForbidden then the Handler will write a "403
    // Forbidden" HTTP Status. If Unlock returns ErrLocked then the Handler
    // will write a "423 Locked" HTTP status. If Unlock returns ErrNoSuchLock
    // then the Handler will write a "409 Conflict" HTTP Status. If it returns
    // any other non-nil error, the Handler will write a "500 Internal Server
    // Error" HTTP status.
    //
    // See http://www.webdav.org/specs/rfc4918.html#rfc.section.9.11.1 for
    // when to use each error.
    Unlock(now time.Time, token string) error
}

func NewMemLS ¶

func NewMemLS() LockSystem

NewMemLS returns a new in-memory LockSystem.

type Property ¶

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"`
}

type Proppatch ¶

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
}

type Propstat ¶

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
}

Subdirectories

Name	Synopsis
..

Package webdav

Overview ▹

Overview ▾

Index ▹

Index ▾

Package files

Internal call graph ▹

Internal call graph ▾

Constants