diff --git a/drivers/all.go b/drivers/all.go
index 8a91e582..740ea350 100644
--- a/drivers/all.go
+++ b/drivers/all.go
@@ -15,6 +15,7 @@ import (
_ "github.com/alist-org/alist/v3/drivers/teambition"
_ "github.com/alist-org/alist/v3/drivers/uss"
_ "github.com/alist-org/alist/v3/drivers/virtual"
+ _ "github.com/alist-org/alist/v3/drivers/webdav"
)
// All do nothing,just for import
diff --git a/drivers/webdav/driver.go b/drivers/webdav/driver.go
new file mode 100644
index 00000000..13a3d8fe
--- /dev/null
+++ b/drivers/webdav/driver.go
@@ -0,0 +1,130 @@
+package webdav
+
+import (
+ "context"
+ "net/http"
+ "os"
+ "path"
+ "time"
+
+ "github.com/alist-org/alist/v3/internal/driver"
+ "github.com/alist-org/alist/v3/internal/errs"
+ "github.com/alist-org/alist/v3/internal/model"
+ "github.com/alist-org/alist/v3/pkg/cron"
+ "github.com/alist-org/alist/v3/pkg/gowebdav"
+ "github.com/alist-org/alist/v3/pkg/utils"
+)
+
+type WebDav struct {
+ model.Storage
+ Addition
+ client *gowebdav.Client
+ cron *cron.Cron
+}
+
+func (d *WebDav) Config() driver.Config {
+ return config
+}
+
+func (d *WebDav) GetAddition() driver.Additional {
+ return d.Addition
+}
+
+func (d *WebDav) Init(ctx context.Context, storage model.Storage) error {
+ d.Storage = storage
+ err := utils.Json.UnmarshalFromString(d.Storage.Addition, &d.Addition)
+ if err != nil {
+ return err
+ }
+ err = d.setClient()
+ if err == nil {
+ d.cron = cron.NewCron(time.Hour * 12)
+ d.cron.Do(func() {
+ _ = d.setClient()
+ })
+ }
+ return err
+}
+
+func (d *WebDav) Drop(ctx context.Context) error {
+ if d.cron != nil {
+ d.cron.Stop()
+ }
+ return nil
+}
+
+func (d *WebDav) List(ctx context.Context, dir model.Obj, args model.ListArgs) ([]model.Obj, error) {
+ files, err := d.client.ReadDir(dir.GetPath())
+ if err != nil {
+ return nil, err
+ }
+ return utils.SliceConvert(files, func(src os.FileInfo) (model.Obj, error) {
+ return &model.Object{
+ Name: src.Name(),
+ Size: src.Size(),
+ Modified: src.ModTime(),
+ IsFolder: src.IsDir(),
+ }, nil
+ })
+}
+
+//func (d *WebDav) Get(ctx context.Context, path string) (model.Obj, error) {
+// // this is optional
+// return nil, errs.NotImplement
+//}
+
+func (d *WebDav) Link(ctx context.Context, file model.Obj, args model.LinkArgs) (*model.Link, error) {
+ callback := func(r *http.Request) {
+ if args.Header.Get("Range") != "" {
+ r.Header.Set("Range", args.Header.Get("Range"))
+ }
+ if args.Header.Get("If-Range") != "" {
+ r.Header.Set("If-Range", args.Header.Get("If-Range"))
+ }
+ }
+ reader, header, err := d.client.ReadStream(file.GetPath(), callback)
+ if err != nil {
+ return nil, err
+ }
+ link := &model.Link{Data: reader}
+ if header.Get("Content-Range") != "" {
+ link.Status = 206
+ link.Header = header
+ }
+ return link, nil
+}
+
+func (d *WebDav) MakeDir(ctx context.Context, parentDir model.Obj, dirName string) error {
+ return d.client.MkdirAll(path.Join(parentDir.GetPath(), dirName), 0644)
+}
+
+func (d *WebDav) Move(ctx context.Context, srcObj, dstDir model.Obj) error {
+ return d.client.Rename(srcObj.GetPath(), path.Join(dstDir.GetPath(), srcObj.GetName()), true)
+}
+
+func (d *WebDav) Rename(ctx context.Context, srcObj model.Obj, newName string) error {
+ return d.client.Rename(srcObj.GetPath(), path.Join(path.Dir(srcObj.GetPath()), newName), true)
+}
+
+func (d *WebDav) Copy(ctx context.Context, srcObj, dstDir model.Obj) error {
+ return d.client.Copy(srcObj.GetPath(), path.Join(dstDir.GetPath(), srcObj.GetName()), true)
+}
+
+func (d *WebDav) Remove(ctx context.Context, obj model.Obj) error {
+ return d.client.RemoveAll(obj.GetPath())
+}
+
+func (d *WebDav) Put(ctx context.Context, dstDir model.Obj, stream model.FileStreamer, up driver.UpdateProgress) error {
+ callback := func(r *http.Request) {
+ r.Header.Set("Content-Type", stream.GetMimetype())
+ r.ContentLength = stream.GetSize()
+ }
+ err := d.client.WriteStream(path.Join(dstDir.GetPath(), stream.GetName()), stream, 0644, callback)
+ return err
+}
+
+func (d *WebDav) Other(ctx context.Context, args model.OtherArgs) (interface{}, error) {
+ return nil, errs.NotSupport
+}
+
+var _ driver.Driver = (*WebDav)(nil)
diff --git a/drivers/webdav/meta.go b/drivers/webdav/meta.go
new file mode 100644
index 00000000..a34faf3a
--- /dev/null
+++ b/drivers/webdav/meta.go
@@ -0,0 +1,29 @@
+package webdav
+
+import (
+ "github.com/alist-org/alist/v3/internal/driver"
+ "github.com/alist-org/alist/v3/internal/op"
+)
+
+type Addition struct {
+ Vendor string `json:"vendor" type:"select" options:"sharepoint,other" default:"other"`
+ Address string `json:"address" required:"true"`
+ Username string `json:"username" required:"true"`
+ Password string `json:"password" required:"true"`
+ driver.RootPath
+}
+
+var config = driver.Config{
+ Name: "WebDav",
+ LocalSort: true,
+ OnlyLocal: true,
+ DefaultRoot: "/",
+}
+
+func New() driver.Driver {
+ return &WebDav{}
+}
+
+func init() {
+ op.RegisterDriver(config, New)
+}
diff --git a/drivers/webdav/odrvcookie/cookie.go b/drivers/webdav/odrvcookie/cookie.go
new file mode 100644
index 00000000..bcd4f3b2
--- /dev/null
+++ b/drivers/webdav/odrvcookie/cookie.go
@@ -0,0 +1,46 @@
+package odrvcookie
+
+import (
+ "net/http"
+
+ "github.com/alist-org/alist/v3/pkg/cookie"
+)
+
+//type SpCookie struct {
+// Cookie string
+// expire time.Time
+//}
+//
+//func (sp SpCookie) IsExpire() bool {
+// return time.Now().After(sp.expire)
+//}
+//
+//var cookiesMap = struct {
+// sync.Mutex
+// m map[string]*SpCookie
+//}{m: make(map[string]*SpCookie)}
+
+func GetCookie(username, password, siteUrl string) (string, error) {
+ //cookiesMap.Lock()
+ //defer cookiesMap.Unlock()
+ //spCookie, ok := cookiesMap.m[username]
+ //if ok {
+ // if !spCookie.IsExpire() {
+ // log.Debugln("sp use old cookie.")
+ // return spCookie.Cookie, nil
+ // }
+ //}
+ //log.Debugln("fetch new cookie")
+ ca := New(username, password, siteUrl)
+ tokenConf, err := ca.Cookies()
+ if err != nil {
+ return "", err
+ }
+ return cookie.ToString([]*http.Cookie{&tokenConf.RtFa, &tokenConf.FedAuth}), nil
+ //spCookie = &SpCookie{
+ // Cookie: cookie.ToString([]*http.Cookie{&tokenConf.RtFa, &tokenConf.FedAuth}),
+ // expire: time.Now().Add(time.Hour * 12),
+ //}
+ //cookiesMap.m[username] = spCookie
+ //return spCookie.Cookie, nil
+}
diff --git a/drivers/webdav/odrvcookie/fetch.go b/drivers/webdav/odrvcookie/fetch.go
new file mode 100644
index 00000000..142e934b
--- /dev/null
+++ b/drivers/webdav/odrvcookie/fetch.go
@@ -0,0 +1,206 @@
+// Package odrvcookie can fetch authentication cookies for a sharepoint webdav endpoint
+package odrvcookie
+
+import (
+ "bytes"
+ "encoding/xml"
+ "fmt"
+ "html/template"
+ "net/http"
+ "net/http/cookiejar"
+ "net/url"
+ "strings"
+ "time"
+
+ "golang.org/x/net/publicsuffix"
+)
+
+// CookieAuth hold the authentication information
+// These are username and password as well as the authentication endpoint
+type CookieAuth struct {
+ user string
+ pass string
+ endpoint string
+}
+
+// CookieResponse contains the requested cookies
+type CookieResponse struct {
+ RtFa http.Cookie
+ FedAuth http.Cookie
+}
+
+// SuccessResponse hold a response from the sharepoint webdav
+type SuccessResponse struct {
+ XMLName xml.Name `xml:"Envelope"`
+ Succ SuccessResponseBody `xml:"Body"`
+}
+
+// SuccessResponseBody is the body of a success response, it holds the token
+type SuccessResponseBody struct {
+ XMLName xml.Name
+ Type string `xml:"RequestSecurityTokenResponse>TokenType"`
+ Created time.Time `xml:"RequestSecurityTokenResponse>Lifetime>Created"`
+ Expires time.Time `xml:"RequestSecurityTokenResponse>Lifetime>Expires"`
+ Token string `xml:"RequestSecurityTokenResponse>RequestedSecurityToken>BinarySecurityToken"`
+}
+
+// reqString is a template that gets populated with the user data in order to retrieve a "BinarySecurityToken"
+const reqString = `
+
+http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue
+
+http://www.w3.org/2005/08/addressing/anonymous
+
+{{ .LoginUrl }}
+
+
+ {{ .Username }}
+ {{ .Password }}
+
+
+
+
+
+
+
+ {{ .Address }}
+
+
+http://schemas.xmlsoap.org/ws/2005/05/identity/NoProofKey
+http://schemas.xmlsoap.org/ws/2005/02/trust/Issue
+urn:oasis:names:tc:SAML:1.0:assertion
+
+
+`
+
+// New creates a new CookieAuth struct
+func New(pUser, pPass, pEndpoint string) CookieAuth {
+ retStruct := CookieAuth{
+ user: pUser,
+ pass: pPass,
+ endpoint: pEndpoint,
+ }
+
+ return retStruct
+}
+
+// Cookies creates a CookieResponse. It fetches the auth token and then
+// retrieves the Cookies
+func (ca *CookieAuth) Cookies() (CookieResponse, error) {
+ spToken, err := ca.getSPToken()
+ if err != nil {
+ return CookieResponse{}, err
+ }
+ return ca.getSPCookie(spToken)
+}
+
+func (ca *CookieAuth) getSPCookie(conf *SuccessResponse) (CookieResponse, error) {
+ spRoot, err := url.Parse(ca.endpoint)
+ if err != nil {
+ return CookieResponse{}, err
+ }
+
+ u, err := url.Parse("https://" + spRoot.Host + "/_forms/default.aspx?wa=wsignin1.0")
+ if err != nil {
+ return CookieResponse{}, err
+ }
+
+ // To authenticate with davfs or anything else we need two cookies (rtFa and FedAuth)
+ // In order to get them we use the token we got earlier and a cookieJar
+ jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+ if err != nil {
+ return CookieResponse{}, err
+ }
+
+ client := &http.Client{
+ Jar: jar,
+ }
+
+ // Send the previously aquired Token as a Post parameter
+ if _, err = client.Post(u.String(), "text/xml", strings.NewReader(conf.Succ.Token)); err != nil {
+ return CookieResponse{}, err
+ }
+
+ cookieResponse := CookieResponse{}
+ for _, cookie := range jar.Cookies(u) {
+ if (cookie.Name == "rtFa") || (cookie.Name == "FedAuth") {
+ switch cookie.Name {
+ case "rtFa":
+ cookieResponse.RtFa = *cookie
+ case "FedAuth":
+ cookieResponse.FedAuth = *cookie
+ }
+ }
+ }
+ return cookieResponse, err
+}
+
+var loginUrlsMap = map[string]string{
+ "com": "https://login.microsoftonline.com",
+ "cn": "https://login.chinacloudapi.cn",
+ "us": "https://login.microsoftonline.us",
+ "de": "https://login.microsoftonline.de",
+}
+
+func getLoginUrl(endpoint string) (string, error) {
+ spRoot, err := url.Parse(endpoint)
+ if err != nil {
+ return "", err
+ }
+ domains := strings.Split(spRoot.Host, ".")
+ tld := domains[len(domains)-1]
+ loginUrl, ok := loginUrlsMap[tld]
+ if !ok {
+ return "", fmt.Errorf("tld %s is not supported", tld)
+ }
+ return loginUrl + "/extSTS.srf", nil
+}
+
+func (ca *CookieAuth) getSPToken() (*SuccessResponse, error) {
+ loginUrl, err := getLoginUrl(ca.endpoint)
+ if err != nil {
+ return nil, err
+ }
+ reqData := map[string]string{
+ "Username": ca.user,
+ "Password": ca.pass,
+ "Address": ca.endpoint,
+ "LoginUrl": loginUrl,
+ }
+
+ t := template.Must(template.New("authXML").Parse(reqString))
+
+ buf := &bytes.Buffer{}
+ if err := t.Execute(buf, reqData); err != nil {
+ return nil, err
+ }
+
+ // Execute the first request which gives us an auth token for the sharepoint service
+ // With this token we can authenticate on the login page and save the returned cookies
+ req, err := http.NewRequest("POST", loginUrl, buf)
+ if err != nil {
+ return nil, err
+ }
+
+ client := &http.Client{}
+ resp, err := client.Do(req)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ respBuf := bytes.Buffer{}
+ respBuf.ReadFrom(resp.Body)
+ s := respBuf.Bytes()
+
+ var conf SuccessResponse
+ err = xml.Unmarshal(s, &conf)
+ if err != nil {
+ return nil, err
+ }
+
+ return &conf, err
+}
diff --git a/drivers/webdav/types.go b/drivers/webdav/types.go
new file mode 100644
index 00000000..0541cc2d
--- /dev/null
+++ b/drivers/webdav/types.go
@@ -0,0 +1 @@
+package webdav
diff --git a/drivers/webdav/util.go b/drivers/webdav/util.go
new file mode 100644
index 00000000..b279491b
--- /dev/null
+++ b/drivers/webdav/util.go
@@ -0,0 +1,31 @@
+package webdav
+
+import (
+ "net/http"
+
+ "github.com/alist-org/alist/v3/drivers/webdav/odrvcookie"
+ "github.com/alist-org/alist/v3/pkg/gowebdav"
+)
+
+// do others that not defined in Driver interface
+
+func (d *WebDav) isSharepoint() bool {
+ return d.Vendor == "sharepoint"
+}
+
+func (d *WebDav) setClient() error {
+ c := gowebdav.NewClient(d.Address, d.Username, d.Password)
+ if d.isSharepoint() {
+ cookie, err := odrvcookie.GetCookie(d.Username, d.Password, d.Address)
+ if err == nil {
+ c.SetInterceptor(func(method string, rq *http.Request) {
+ rq.Header.Del("Authorization")
+ rq.Header.Set("Cookie", cookie)
+ })
+ } else {
+ return err
+ }
+ }
+ d.client = c
+ return nil
+}
diff --git a/internal/op/driver.go b/internal/op/driver.go
index 35cd21c2..2a545679 100644
--- a/internal/op/driver.go
+++ b/internal/op/driver.go
@@ -144,7 +144,7 @@ func getAdditionalItems(t reflect.Type, defaultRoot string) []driver.Item {
if tag.Get("type") != "" {
item.Type = tag.Get("type")
}
- if item.Name == "root_folder" && item.Default == "" {
+ if (item.Name == "root_folder_id" || item.Name == "root_folder_path") && item.Default == "" {
item.Default = defaultRoot
}
// set default type to string
diff --git a/pkg/gowebdav/.gitignore b/pkg/gowebdav/.gitignore
new file mode 100644
index 00000000..394b2f5f
--- /dev/null
+++ b/pkg/gowebdav/.gitignore
@@ -0,0 +1,21 @@
+# Folders to ignore
+/src
+/bin
+/pkg
+/gowebdav
+/.idea
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+.vscode/
\ No newline at end of file
diff --git a/pkg/gowebdav/.travis.yml b/pkg/gowebdav/.travis.yml
new file mode 100644
index 00000000..76bfb654
--- /dev/null
+++ b/pkg/gowebdav/.travis.yml
@@ -0,0 +1,10 @@
+language: go
+
+go:
+ - "1.x"
+
+install:
+ - go get ./...
+
+script:
+ - go test -v --short ./...
\ No newline at end of file
diff --git a/pkg/gowebdav/LICENSE b/pkg/gowebdav/LICENSE
new file mode 100644
index 00000000..a7cd4420
--- /dev/null
+++ b/pkg/gowebdav/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2014, Studio B12 GmbH
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+ may be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/pkg/gowebdav/Makefile b/pkg/gowebdav/Makefile
new file mode 100644
index 00000000..c6a0062c
--- /dev/null
+++ b/pkg/gowebdav/Makefile
@@ -0,0 +1,33 @@
+BIN := gowebdav
+SRC := $(wildcard *.go) cmd/gowebdav/main.go
+
+all: test cmd
+
+cmd: ${BIN}
+
+${BIN}: ${SRC}
+ go build -o $@ ./cmd/gowebdav
+
+test:
+ go test -v --short ./...
+
+api:
+ @sed '/^## API$$/,$$d' -i README.md
+ @echo '## API' >> README.md
+ @godoc2md github.com/studio-b12/gowebdav | sed '/^$$/N;/^\n$$/D' |\
+ sed '2d' |\
+ sed 's/\/src\/github.com\/studio-b12\/gowebdav\//https:\/\/github.com\/studio-b12\/gowebdav\/blob\/master\//g' |\
+ sed 's/\/src\/target\//https:\/\/github.com\/studio-b12\/gowebdav\/blob\/master\//g' |\
+ sed 's/^#/##/g' >> README.md
+
+check:
+ gofmt -w -s $(SRC)
+ @echo
+ gocyclo -over 15 .
+ @echo
+ golint ./...
+
+clean:
+ @rm -f ${BIN}
+
+.PHONY: all cmd clean test api check
diff --git a/pkg/gowebdav/README.md b/pkg/gowebdav/README.md
new file mode 100644
index 00000000..31d9fe7b
--- /dev/null
+++ b/pkg/gowebdav/README.md
@@ -0,0 +1,564 @@
+# GoWebDAV
+
+[](https://travis-ci.org/studio-b12/gowebdav)
+[](https://godoc.org/github.com/studio-b12/gowebdav)
+[](https://goreportcard.com/report/github.com/studio-b12/gowebdav)
+
+A golang WebDAV client library.
+
+## Main features
+`gowebdav` library allows to perform following actions on the remote WebDAV server:
+* [create path](#create-path-on-a-webdav-server)
+* [get files list](#get-files-list)
+* [download file](#download-file-to-byte-array)
+* [upload file](#upload-file-from-byte-array)
+* [get information about specified file/folder](#get-information-about-specified-filefolder)
+* [move file to another location](#move-file-to-another-location)
+* [copy file to another location](#copy-file-to-another-location)
+* [delete file](#delete-file)
+
+## Usage
+
+First of all you should create `Client` instance using `NewClient()` function:
+
+```go
+root := "https://webdav.mydomain.me"
+user := "user"
+password := "password"
+
+c := gowebdav.NewClient(root, user, password)
+```
+
+After you can use this `Client` to perform actions, described below.
+
+**NOTICE:** we will not check errors in examples, to focus you on the `gowebdav` library's code, but you should do it in your code!
+
+### Create path on a WebDAV server
+```go
+err := c.Mkdir("folder", 0644)
+```
+In case you want to create several folders you can use `c.MkdirAll()`:
+```go
+err := c.MkdirAll("folder/subfolder/subfolder2", 0644)
+```
+
+### Get files list
+```go
+files, _ := c.ReadDir("folder/subfolder")
+for _, file := range files {
+ //notice that [file] has os.FileInfo type
+ fmt.Println(file.Name())
+}
+```
+
+### Download file to byte array
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+bytes, _ := c.Read(webdavFilePath)
+ioutil.WriteFile(localFilePath, bytes, 0644)
+```
+
+### Download file via reader
+Also you can use `c.ReadStream()` method:
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+reader, _ := c.ReadStream(webdavFilePath)
+
+file, _ := os.Create(localFilePath)
+defer file.Close()
+
+io.Copy(file, reader)
+```
+
+### Upload file from byte array
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+bytes, _ := ioutil.ReadFile(localFilePath)
+
+c.Write(webdavFilePath, bytes, 0644)
+```
+
+### Upload file via writer
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+file, _ := os.Open(localFilePath)
+defer file.Close()
+
+c.WriteStream(webdavFilePath, file, 0644)
+```
+
+### Get information about specified file/folder
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+
+info := c.Stat(webdavFilePath)
+//notice that [info] has os.FileInfo type
+fmt.Println(info)
+```
+
+### Move file to another location
+```go
+oldPath := "folder/subfolder/file.txt"
+newPath := "folder/subfolder/moved.txt"
+isOverwrite := true
+
+c.Rename(oldPath, newPath, isOverwrite)
+```
+
+### Copy file to another location
+```go
+oldPath := "folder/subfolder/file.txt"
+newPath := "folder/subfolder/file-copy.txt"
+isOverwrite := true
+
+c.Copy(oldPath, newPath, isOverwrite)
+```
+
+### Delete file
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+
+c.Remove(webdavFilePath)
+```
+
+## Links
+
+More details about WebDAV server you can read from following resources:
+
+* [RFC 4918 - HTTP Extensions for Web Distributed Authoring and Versioning (WebDAV)](https://tools.ietf.org/html/rfc4918)
+* [RFC 5689 - Extended MKCOL for Web Distributed Authoring and Versioning (WebDAV)](https://tools.ietf.org/html/rfc5689)
+* [RFC 2616 - HTTP/1.1 Status Code Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html "HTTP/1.1 Status Code Definitions")
+* [WebDav: Next Generation Collaborative Web Authoring By Lisa Dusseaul](https://books.google.de/books?isbn=0130652083 "WebDav: Next Generation Collaborative Web Authoring By Lisa Dusseault")
+
+**NOTICE**: RFC 2518 is obsoleted by RFC 4918 in June 2007
+
+## Contributing
+All contributing are welcome. If you have any suggestions or find some bug - please create an Issue to let us make this project better. We appreciate your help!
+
+## License
+This library is distributed under the BSD 3-Clause license found in the [LICENSE](https://github.com/studio-b12/gowebdav/blob/master/LICENSE) file.
+## API
+
+`import "github.com/studio-b12/gowebdav"`
+
+* [Overview](#pkg-overview)
+* [Index](#pkg-index)
+* [Examples](#pkg-examples)
+* [Subdirectories](#pkg-subdirectories)
+
+### Overview
+Package gowebdav is a WebDAV client library with a command line tool
+included.
+
+### Index
+* [func FixSlash(s string) string](#FixSlash)
+* [func FixSlashes(s string) string](#FixSlashes)
+* [func Join(path0 string, path1 string) string](#Join)
+* [func PathEscape(path string) string](#PathEscape)
+* [func ReadConfig(uri, netrc string) (string, string)](#ReadConfig)
+* [func String(r io.Reader) string](#String)
+* [type Authenticator](#Authenticator)
+* [type BasicAuth](#BasicAuth)
+ * [func (b *BasicAuth) Authorize(req *http.Request, method string, path string)](#BasicAuth.Authorize)
+ * [func (b *BasicAuth) Pass() string](#BasicAuth.Pass)
+ * [func (b *BasicAuth) Type() string](#BasicAuth.Type)
+ * [func (b *BasicAuth) User() string](#BasicAuth.User)
+* [type Client](#Client)
+ * [func NewClient(uri, user, pw string) *Client](#NewClient)
+ * [func (c *Client) Connect() error](#Client.Connect)
+ * [func (c *Client) Copy(oldpath, newpath string, overwrite bool) error](#Client.Copy)
+ * [func (c *Client) Mkdir(path string, _ os.FileMode) error](#Client.Mkdir)
+ * [func (c *Client) MkdirAll(path string, _ os.FileMode) error](#Client.MkdirAll)
+ * [func (c *Client) Read(path string) ([]byte, error)](#Client.Read)
+ * [func (c *Client) ReadDir(path string) ([]os.FileInfo, error)](#Client.ReadDir)
+ * [func (c *Client) ReadStream(path string) (io.ReadCloser, error)](#Client.ReadStream)
+ * [func (c *Client) ReadStreamRange(path string, offset, length int64) (io.ReadCloser, error)](#Client.ReadStreamRange)
+ * [func (c *Client) Remove(path string) error](#Client.Remove)
+ * [func (c *Client) RemoveAll(path string) error](#Client.RemoveAll)
+ * [func (c *Client) Rename(oldpath, newpath string, overwrite bool) error](#Client.Rename)
+ * [func (c *Client) SetHeader(key, value string)](#Client.SetHeader)
+ * [func (c *Client) SetInterceptor(interceptor func(method string, rq *http.Request))](#Client.SetInterceptor)
+ * [func (c *Client) SetTimeout(timeout time.Duration)](#Client.SetTimeout)
+ * [func (c *Client) SetTransport(transport http.RoundTripper)](#Client.SetTransport)
+ * [func (c *Client) Stat(path string) (os.FileInfo, error)](#Client.Stat)
+ * [func (c *Client) Write(path string, data []byte, _ os.FileMode) error](#Client.Write)
+ * [func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error](#Client.WriteStream)
+* [type DigestAuth](#DigestAuth)
+ * [func (d *DigestAuth) Authorize(req *http.Request, method string, path string)](#DigestAuth.Authorize)
+ * [func (d *DigestAuth) Pass() string](#DigestAuth.Pass)
+ * [func (d *DigestAuth) Type() string](#DigestAuth.Type)
+ * [func (d *DigestAuth) User() string](#DigestAuth.User)
+* [type File](#File)
+ * [func (f File) ContentType() string](#File.ContentType)
+ * [func (f File) ETag() string](#File.ETag)
+ * [func (f File) IsDir() bool](#File.IsDir)
+ * [func (f File) ModTime() time.Time](#File.ModTime)
+ * [func (f File) Mode() os.FileMode](#File.Mode)
+ * [func (f File) Name() string](#File.Name)
+ * [func (f File) Path() string](#File.Path)
+ * [func (f File) Size() int64](#File.Size)
+ * [func (f File) String() string](#File.String)
+ * [func (f File) Sys() interface{}](#File.Sys)
+* [type NoAuth](#NoAuth)
+ * [func (n *NoAuth) Authorize(req *http.Request, method string, path string)](#NoAuth.Authorize)
+ * [func (n *NoAuth) Pass() string](#NoAuth.Pass)
+ * [func (n *NoAuth) Type() string](#NoAuth.Type)
+ * [func (n *NoAuth) User() string](#NoAuth.User)
+
+##### Examples
+* [PathEscape](#example_PathEscape)
+
+##### Package files
+[basicAuth.go](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go) [client.go](https://github.com/studio-b12/gowebdav/blob/master/client.go) [digestAuth.go](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go) [doc.go](https://github.com/studio-b12/gowebdav/blob/master/doc.go) [file.go](https://github.com/studio-b12/gowebdav/blob/master/file.go) [netrc.go](https://github.com/studio-b12/gowebdav/blob/master/netrc.go) [requests.go](https://github.com/studio-b12/gowebdav/blob/master/requests.go) [utils.go](https://github.com/studio-b12/gowebdav/blob/master/utils.go)
+
+### func [FixSlash](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=707:737#L45)
+``` go
+func FixSlash(s string) string
+```
+FixSlash appends a trailing / to our string
+
+### func [FixSlashes](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=859:891#L53)
+``` go
+func FixSlashes(s string) string
+```
+FixSlashes appends and prepends a / if they are missing
+
+### func [Join](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=992:1036#L62)
+``` go
+func Join(path0 string, path1 string) string
+```
+Join joins two paths
+
+### func [PathEscape](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=506:541#L36)
+``` go
+func PathEscape(path string) string
+```
+PathEscape escapes all segments of a given path
+
+### func [ReadConfig](https://github.com/studio-b12/gowebdav/blob/master/netrc.go?s=428:479#L27)
+``` go
+func ReadConfig(uri, netrc string) (string, string)
+```
+ReadConfig reads login and password configuration from ~/.netrc
+machine foo.com login username password 123456
+
+### func [String](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=1166:1197#L67)
+``` go
+func String(r io.Reader) string
+```
+String pulls a string out of our io.Reader
+
+### type [Authenticator](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=388:507#L29)
+``` go
+type Authenticator interface {
+ Type() string
+ User() string
+ Pass() string
+ Authorize(*http.Request, string, string)
+}
+```
+Authenticator stub
+
+### type [BasicAuth](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=106:157#L9)
+``` go
+type BasicAuth struct {
+ // contains filtered or unexported fields
+}
+```
+BasicAuth structure holds our credentials
+
+#### func (\*BasicAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=473:549#L30)
+``` go
+func (b *BasicAuth) Authorize(req *http.Request, method string, path string)
+```
+Authorize the current request
+
+#### func (\*BasicAuth) [Pass](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=388:421#L25)
+``` go
+func (b *BasicAuth) Pass() string
+```
+Pass holds the BasicAuth password
+
+#### func (\*BasicAuth) [Type](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=201:234#L15)
+``` go
+func (b *BasicAuth) Type() string
+```
+Type identifies the BasicAuthenticator
+
+#### func (\*BasicAuth) [User](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=297:330#L20)
+``` go
+func (b *BasicAuth) User() string
+```
+User holds the BasicAuth username
+
+### type [Client](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=172:364#L18)
+``` go
+type Client struct {
+ // contains filtered or unexported fields
+}
+```
+Client defines our structure
+
+#### func [NewClient](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1019:1063#L62)
+``` go
+func NewClient(uri, user, pw string) *Client
+```
+NewClient creates a new instance of client
+
+#### func (\*Client) [Connect](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1843:1875#L87)
+``` go
+func (c *Client) Connect() error
+```
+Connect connects to our dav server
+
+#### func (\*Client) [Copy](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6702:6770#L313)
+``` go
+func (c *Client) Copy(oldpath, newpath string, overwrite bool) error
+```
+Copy copies a file from A to B
+
+#### func (\*Client) [Mkdir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5793:5849#L272)
+``` go
+func (c *Client) Mkdir(path string, _ os.FileMode) error
+```
+Mkdir makes a directory
+
+#### func (\*Client) [MkdirAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6028:6087#L283)
+``` go
+func (c *Client) MkdirAll(path string, _ os.FileMode) error
+```
+MkdirAll like mkdir -p, but for webdav
+
+#### func (\*Client) [Read](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6876:6926#L318)
+``` go
+func (c *Client) Read(path string) ([]byte, error)
+```
+Read reads the contents of a remote file
+
+#### func (\*Client) [ReadDir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=2869:2929#L130)
+``` go
+func (c *Client) ReadDir(path string) ([]os.FileInfo, error)
+```
+ReadDir reads the contents of a remote directory
+
+#### func (\*Client) [ReadStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=7237:7300#L336)
+``` go
+func (c *Client) ReadStream(path string) (io.ReadCloser, error)
+```
+ReadStream reads the stream for a given path
+
+#### func (\*Client) [ReadStreamRange](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=8049:8139#L358)
+``` go
+func (c *Client) ReadStreamRange(path string, offset, length int64) (io.ReadCloser, error)
+```
+ReadStreamRange reads the stream representing a subset of bytes for a given path,
+utilizing HTTP Range Requests if the server supports it.
+The range is expressed as offset from the start of the file and length, for example
+offset=10, length=10 will return bytes 10 through 19.
+
+If the server does not support partial content requests and returns full content instead,
+this function will emulate the behavior by skipping `offset` bytes and limiting the result
+to `length`.
+
+#### func (\*Client) [Remove](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5299:5341#L249)
+``` go
+func (c *Client) Remove(path string) error
+```
+Remove removes a remote file
+
+#### func (\*Client) [RemoveAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5407:5452#L254)
+``` go
+func (c *Client) RemoveAll(path string) error
+```
+RemoveAll removes remote files
+
+#### func (\*Client) [Rename](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6536:6606#L308)
+``` go
+func (c *Client) Rename(oldpath, newpath string, overwrite bool) error
+```
+Rename moves a file from A to B
+
+#### func (\*Client) [SetHeader](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1235:1280#L67)
+``` go
+func (c *Client) SetHeader(key, value string)
+```
+SetHeader lets us set arbitrary headers for a given client
+
+#### func (\*Client) [SetInterceptor](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1387:1469#L72)
+``` go
+func (c *Client) SetInterceptor(interceptor func(method string, rq *http.Request))
+```
+SetInterceptor lets us set an arbitrary interceptor for a given client
+
+#### func (\*Client) [SetTimeout](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1571:1621#L77)
+``` go
+func (c *Client) SetTimeout(timeout time.Duration)
+```
+SetTimeout exposes the ability to set a time limit for requests
+
+#### func (\*Client) [SetTransport](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1714:1772#L82)
+``` go
+func (c *Client) SetTransport(transport http.RoundTripper)
+```
+SetTransport exposes the ability to define custom transports
+
+#### func (\*Client) [Stat](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=4255:4310#L197)
+``` go
+func (c *Client) Stat(path string) (os.FileInfo, error)
+```
+Stat returns the file stats for a specified path
+
+#### func (\*Client) [Write](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=9051:9120#L388)
+``` go
+func (c *Client) Write(path string, data []byte, _ os.FileMode) error
+```
+Write writes data to a given path
+
+#### func (\*Client) [WriteStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=9476:9556#L411)
+``` go
+func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error
+```
+WriteStream writes a stream
+
+### type [DigestAuth](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=157:254#L14)
+``` go
+type DigestAuth struct {
+ // contains filtered or unexported fields
+}
+```
+DigestAuth structure holds our credentials
+
+#### func (\*DigestAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=577:654#L36)
+``` go
+func (d *DigestAuth) Authorize(req *http.Request, method string, path string)
+```
+Authorize the current request
+
+#### func (\*DigestAuth) [Pass](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=491:525#L31)
+``` go
+func (d *DigestAuth) Pass() string
+```
+Pass holds the DigestAuth password
+
+#### func (\*DigestAuth) [Type](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=299:333#L21)
+``` go
+func (d *DigestAuth) Type() string
+```
+Type identifies the DigestAuthenticator
+
+#### func (\*DigestAuth) [User](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=398:432#L26)
+``` go
+func (d *DigestAuth) User() string
+```
+User holds the DigestAuth username
+
+### type [File](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=93:253#L10)
+``` go
+type File struct {
+ // contains filtered or unexported fields
+}
+```
+File is our structure for a given file
+
+#### func (File) [ContentType](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=476:510#L31)
+``` go
+func (f File) ContentType() string
+```
+ContentType returns the content type of a file
+
+#### func (File) [ETag](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=929:956#L56)
+``` go
+func (f File) ETag() string
+```
+ETag returns the ETag of a file
+
+#### func (File) [IsDir](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=1035:1061#L61)
+``` go
+func (f File) IsDir() bool
+```
+IsDir let us see if a given file is a directory or not
+
+#### func (File) [ModTime](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=836:869#L51)
+``` go
+func (f File) ModTime() time.Time
+```
+ModTime returns the modified time of a file
+
+#### func (File) [Mode](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=665:697#L41)
+``` go
+func (f File) Mode() os.FileMode
+```
+Mode will return the mode of a given file
+
+#### func (File) [Name](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=378:405#L26)
+``` go
+func (f File) Name() string
+```
+Name returns the name of a file
+
+#### func (File) [Path](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=295:322#L21)
+``` go
+func (f File) Path() string
+```
+Path returns the full path of a file
+
+#### func (File) [Size](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=573:599#L36)
+``` go
+func (f File) Size() int64
+```
+Size returns the size of a file
+
+#### func (File) [String](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=1183:1212#L71)
+``` go
+func (f File) String() string
+```
+String lets us see file information
+
+#### func (File) [Sys](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=1095:1126#L66)
+``` go
+func (f File) Sys() interface{}
+```
+Sys ????
+
+### type [NoAuth](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=551:599#L37)
+``` go
+type NoAuth struct {
+ // contains filtered or unexported fields
+}
+```
+NoAuth structure holds our credentials
+
+#### func (\*NoAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=894:967#L58)
+``` go
+func (n *NoAuth) Authorize(req *http.Request, method string, path string)
+```
+Authorize the current request
+
+#### func (\*NoAuth) [Pass](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=812:842#L53)
+``` go
+func (n *NoAuth) Pass() string
+```
+Pass returns the current password
+
+#### func (\*NoAuth) [Type](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=638:668#L43)
+``` go
+func (n *NoAuth) Type() string
+```
+Type identifies the authenticator
+
+#### func (\*NoAuth) [User](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=724:754#L48)
+``` go
+func (n *NoAuth) User() string
+```
+User returns the current user
+
+- - -
+Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md)
diff --git a/pkg/gowebdav/basicAuth.go b/pkg/gowebdav/basicAuth.go
new file mode 100644
index 00000000..bdb86da5
--- /dev/null
+++ b/pkg/gowebdav/basicAuth.go
@@ -0,0 +1,34 @@
+package gowebdav
+
+import (
+ "encoding/base64"
+ "net/http"
+)
+
+// BasicAuth structure holds our credentials
+type BasicAuth struct {
+ user string
+ pw string
+}
+
+// Type identifies the BasicAuthenticator
+func (b *BasicAuth) Type() string {
+ return "BasicAuth"
+}
+
+// User holds the BasicAuth username
+func (b *BasicAuth) User() string {
+ return b.user
+}
+
+// Pass holds the BasicAuth password
+func (b *BasicAuth) Pass() string {
+ return b.pw
+}
+
+// Authorize the current request
+func (b *BasicAuth) Authorize(req *http.Request, method string, path string) {
+ a := b.user + ":" + b.pw
+ auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(a))
+ req.Header.Set("Authorization", auth)
+}
diff --git a/pkg/gowebdav/client.go b/pkg/gowebdav/client.go
new file mode 100644
index 00000000..0197dccc
--- /dev/null
+++ b/pkg/gowebdav/client.go
@@ -0,0 +1,447 @@
+package gowebdav
+
+import (
+ "bytes"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net/http"
+ "net/url"
+ "os"
+ pathpkg "path"
+ "strings"
+ "sync"
+ "time"
+)
+
+// Client defines our structure
+type Client struct {
+ root string
+ headers http.Header
+ interceptor func(method string, rq *http.Request)
+ c *http.Client
+
+ authMutex sync.Mutex
+ auth Authenticator
+}
+
+// Authenticator stub
+type Authenticator interface {
+ Type() string
+ User() string
+ Pass() string
+ Authorize(*http.Request, string, string)
+}
+
+// NoAuth structure holds our credentials
+type NoAuth struct {
+ user string
+ pw string
+}
+
+// Type identifies the authenticator
+func (n *NoAuth) Type() string {
+ return "NoAuth"
+}
+
+// User returns the current user
+func (n *NoAuth) User() string {
+ return n.user
+}
+
+// Pass returns the current password
+func (n *NoAuth) Pass() string {
+ return n.pw
+}
+
+// Authorize the current request
+func (n *NoAuth) Authorize(req *http.Request, method string, path string) {
+}
+
+// NewClient creates a new instance of client
+func NewClient(uri, user, pw string) *Client {
+ return &Client{FixSlash(uri), make(http.Header), nil, &http.Client{}, sync.Mutex{}, &NoAuth{user, pw}}
+}
+
+// SetHeader lets us set arbitrary headers for a given client
+func (c *Client) SetHeader(key, value string) {
+ c.headers.Add(key, value)
+}
+
+// SetInterceptor lets us set an arbitrary interceptor for a given client
+func (c *Client) SetInterceptor(interceptor func(method string, rq *http.Request)) {
+ c.interceptor = interceptor
+}
+
+// SetTimeout exposes the ability to set a time limit for requests
+func (c *Client) SetTimeout(timeout time.Duration) {
+ c.c.Timeout = timeout
+}
+
+// SetTransport exposes the ability to define custom transports
+func (c *Client) SetTransport(transport http.RoundTripper) {
+ c.c.Transport = transport
+}
+
+// Connect connects to our dav server
+func (c *Client) Connect() error {
+ rs, err := c.options("/")
+ if err != nil {
+ return err
+ }
+
+ err = rs.Body.Close()
+ if err != nil {
+ return err
+ }
+
+ if rs.StatusCode != 200 {
+ return newPathError("Connect", c.root, rs.StatusCode)
+ }
+
+ return nil
+}
+
+type props struct {
+ Status string `xml:"DAV: status"`
+ Name string `xml:"DAV: prop>displayname,omitempty"`
+ Type xml.Name `xml:"DAV: prop>resourcetype>collection,omitempty"`
+ Size string `xml:"DAV: prop>getcontentlength,omitempty"`
+ ContentType string `xml:"DAV: prop>getcontenttype,omitempty"`
+ ETag string `xml:"DAV: prop>getetag,omitempty"`
+ Modified string `xml:"DAV: prop>getlastmodified,omitempty"`
+}
+
+type response struct {
+ Href string `xml:"DAV: href"`
+ Props []props `xml:"DAV: propstat"`
+}
+
+func getProps(r *response, status string) *props {
+ for _, prop := range r.Props {
+ if strings.Contains(prop.Status, status) {
+ return &prop
+ }
+ }
+ return nil
+}
+
+// ReadDir reads the contents of a remote directory
+func (c *Client) ReadDir(path string) ([]os.FileInfo, error) {
+ path = FixSlashes(path)
+ files := make([]os.FileInfo, 0)
+ skipSelf := true
+ parse := func(resp interface{}) error {
+ r := resp.(*response)
+
+ if skipSelf {
+ skipSelf = false
+ if p := getProps(r, "200"); p != nil && p.Type.Local == "collection" {
+ r.Props = nil
+ return nil
+ }
+ return newPathError("ReadDir", path, 405)
+ }
+
+ if p := getProps(r, "200"); p != nil {
+ f := new(File)
+ if ps, err := url.PathUnescape(r.Href); err == nil {
+ f.name = pathpkg.Base(ps)
+ } else {
+ f.name = p.Name
+ }
+ f.path = path + f.name
+ f.modified = parseModified(&p.Modified)
+ f.etag = p.ETag
+ f.contentType = p.ContentType
+
+ if p.Type.Local == "collection" {
+ f.path += "/"
+ f.size = 0
+ f.isdir = true
+ } else {
+ f.size = parseInt64(&p.Size)
+ f.isdir = false
+ }
+
+ files = append(files, *f)
+ }
+
+ r.Props = nil
+ return nil
+ }
+
+ err := c.propfind(path, false,
+ `
+
+
+
+
+
+
+
+
+ `,
+ &response{},
+ parse)
+
+ if err != nil {
+ if _, ok := err.(*os.PathError); !ok {
+ err = newPathErrorErr("ReadDir", path, err)
+ }
+ }
+ return files, err
+}
+
+// Stat returns the file stats for a specified path
+func (c *Client) Stat(path string) (os.FileInfo, error) {
+ var f *File
+ parse := func(resp interface{}) error {
+ r := resp.(*response)
+ if p := getProps(r, "200"); p != nil && f == nil {
+ f = new(File)
+ f.name = p.Name
+ f.path = path
+ f.etag = p.ETag
+ f.contentType = p.ContentType
+
+ if p.Type.Local == "collection" {
+ if !strings.HasSuffix(f.path, "/") {
+ f.path += "/"
+ }
+ f.size = 0
+ f.modified = time.Unix(0, 0)
+ f.isdir = true
+ } else {
+ f.size = parseInt64(&p.Size)
+ f.modified = parseModified(&p.Modified)
+ f.isdir = false
+ }
+ }
+
+ r.Props = nil
+ return nil
+ }
+
+ err := c.propfind(path, true,
+ `
+
+
+
+
+
+
+
+
+ `,
+ &response{},
+ parse)
+
+ if err != nil {
+ if _, ok := err.(*os.PathError); !ok {
+ err = newPathErrorErr("ReadDir", path, err)
+ }
+ }
+ return f, err
+}
+
+// Remove removes a remote file
+func (c *Client) Remove(path string) error {
+ return c.RemoveAll(path)
+}
+
+// RemoveAll removes remote files
+func (c *Client) RemoveAll(path string) error {
+ rs, err := c.req("DELETE", path, nil, nil)
+ if err != nil {
+ return newPathError("Remove", path, 400)
+ }
+ err = rs.Body.Close()
+ if err != nil {
+ return err
+ }
+
+ if rs.StatusCode == 200 || rs.StatusCode == 204 || rs.StatusCode == 404 {
+ return nil
+ }
+
+ return newPathError("Remove", path, rs.StatusCode)
+}
+
+// Mkdir makes a directory
+func (c *Client) Mkdir(path string, _ os.FileMode) (err error) {
+ path = FixSlashes(path)
+ status, err := c.mkcol(path)
+ if err != nil {
+ return
+ }
+ if status == 201 {
+ return nil
+ }
+
+ return newPathError("Mkdir", path, status)
+}
+
+// MkdirAll like mkdir -p, but for webdav
+func (c *Client) MkdirAll(path string, _ os.FileMode) (err error) {
+ path = FixSlashes(path)
+ status, err := c.mkcol(path)
+ if err != nil {
+ return
+ }
+ if status == 201 {
+ return nil
+ }
+ if status == 409 {
+ paths := strings.Split(path, "/")
+ sub := "/"
+ for _, e := range paths {
+ if e == "" {
+ continue
+ }
+ sub += e + "/"
+ status, err = c.mkcol(sub)
+ if err != nil {
+ return
+ }
+ if status != 201 {
+ return newPathError("MkdirAll", sub, status)
+ }
+ }
+ return nil
+ }
+
+ return newPathError("MkdirAll", path, status)
+}
+
+// Rename moves a file from A to B
+func (c *Client) Rename(oldpath, newpath string, overwrite bool) error {
+ return c.copymove("MOVE", oldpath, newpath, overwrite)
+}
+
+// Copy copies a file from A to B
+func (c *Client) Copy(oldpath, newpath string, overwrite bool) error {
+ return c.copymove("COPY", oldpath, newpath, overwrite)
+}
+
+// Read reads the contents of a remote file
+func (c *Client) Read(path string) ([]byte, error) {
+ var stream io.ReadCloser
+ var err error
+
+ if stream, _, err = c.ReadStream(path, nil); err != nil {
+ return nil, err
+ }
+ defer stream.Close()
+
+ buf := new(bytes.Buffer)
+ _, err = buf.ReadFrom(stream)
+ if err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+// ReadStream reads the stream for a given path
+func (c *Client) ReadStream(path string, callback func(rq *http.Request)) (io.ReadCloser, http.Header, error) {
+ rs, err := c.req("GET", path, nil, callback)
+ if err != nil {
+ return nil, nil, newPathErrorErr("ReadStream", path, err)
+ }
+
+ if rs.StatusCode < 400 {
+ return rs.Body, rs.Header, nil
+ }
+
+ rs.Body.Close()
+ return nil, nil, newPathError("ReadStream", path, rs.StatusCode)
+}
+
+// ReadStreamRange reads the stream representing a subset of bytes for a given path,
+// utilizing HTTP Range Requests if the server supports it.
+// The range is expressed as offset from the start of the file and length, for example
+// offset=10, length=10 will return bytes 10 through 19.
+//
+// If the server does not support partial content requests and returns full content instead,
+// this function will emulate the behavior by skipping `offset` bytes and limiting the result
+// to `length`.
+func (c *Client) ReadStreamRange(path string, offset, length int64) (io.ReadCloser, error) {
+ rs, err := c.req("GET", path, nil, func(r *http.Request) {
+ r.Header.Add("Range", fmt.Sprintf("bytes=%v-%v", offset, offset+length-1))
+ })
+ if err != nil {
+ return nil, newPathErrorErr("ReadStreamRange", path, err)
+ }
+
+ if rs.StatusCode == http.StatusPartialContent {
+ // server supported partial content, return as-is.
+ return rs.Body, nil
+ }
+
+ // server returned success, but did not support partial content, so we have the whole
+ // stream in rs.Body
+ if rs.StatusCode == 200 {
+ // discard first 'offset' bytes.
+ if _, err := io.Copy(io.Discard, io.LimitReader(rs.Body, offset)); err != nil {
+ return nil, newPathErrorErr("ReadStreamRange", path, err)
+ }
+
+ // return a io.ReadCloser that is limited to `length` bytes.
+ return &limitedReadCloser{rs.Body, int(length)}, nil
+ }
+
+ rs.Body.Close()
+ return nil, newPathError("ReadStream", path, rs.StatusCode)
+}
+
+// Write writes data to a given path
+func (c *Client) Write(path string, data []byte, _ os.FileMode) (err error) {
+ s, err := c.put(path, bytes.NewReader(data), nil)
+ if err != nil {
+ return
+ }
+
+ switch s {
+
+ case 200, 201, 204:
+ return nil
+
+ case 409:
+ err = c.createParentCollection(path)
+ if err != nil {
+ return
+ }
+
+ s, err = c.put(path, bytes.NewReader(data), nil)
+ if err != nil {
+ return
+ }
+ if s == 200 || s == 201 || s == 204 {
+ return
+ }
+ }
+
+ return newPathError("Write", path, s)
+}
+
+// WriteStream writes a stream
+func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode, callback func(r *http.Request)) (err error) {
+
+ err = c.createParentCollection(path)
+ if err != nil {
+ return err
+ }
+
+ s, err := c.put(path, stream, callback)
+ if err != nil {
+ return err
+ }
+
+ switch s {
+ case 200, 201, 204:
+ return nil
+
+ default:
+ return newPathError("WriteStream", path, s)
+ }
+}
diff --git a/pkg/gowebdav/cmd/gowebdav/README.md b/pkg/gowebdav/cmd/gowebdav/README.md
new file mode 100644
index 00000000..30e1d4ca
--- /dev/null
+++ b/pkg/gowebdav/cmd/gowebdav/README.md
@@ -0,0 +1,103 @@
+# Description
+Command line tool for [gowebdav](https://github.com/studio-b12/gowebdav) library.
+
+# Prerequisites
+## Software
+* **OS**: all, which are supported by `Golang`
+* **Golang**: version 1.x
+* **Git**: version 2.14.2 at higher (required to install via `go get`)
+
+# Install
+```sh
+go get -u github.com/studio-b12/gowebdav/cmd/gowebdav
+```
+
+# Usage
+It is recommended to set following environment variables to improve your experience with this tool:
+* `ROOT` is an URL of target WebDAV server (e.g. `https://webdav.mydomain.me/user_root_folder`)
+* `USER` is a login to connect to specified server (e.g. `user`)
+* `PASSWORD` is a password to connect to specified server (e.g. `p@s$w0rD`)
+
+In following examples we suppose that:
+* environment variable `ROOT` is set to `https://webdav.mydomain.me/ufolder`
+* environment variable `USER` is set to `user`
+* environment variable `PASSWORD` is set `p@s$w0rD`
+* folder `/ufolder/temp` exists on the server
+* file `/ufolder/temp/file.txt` exists on the server
+* file `/ufolder/temp/document.rtf` exists on the server
+* file `/tmp/webdav/to_upload.txt` exists on the local machine
+* folder `/tmp/webdav/` is used to download files from the server
+
+## Examples
+
+#### Get content of specified folder
+```sh
+gowebdav -X LS temp
+```
+
+#### Get info about file/folder
+```sh
+gowebdav -X STAT temp
+gowebdav -X STAT temp/file.txt
+```
+
+#### Create folder on the remote server
+```sh
+gowebdav -X MKDIR temp2
+gowebdav -X MKDIRALL all/folders/which-you-want/to_create
+```
+
+#### Download file
+```sh
+gowebdav -X GET temp/document.rtf /tmp/webdav/document.rtf
+```
+
+You may do not specify target local path, in this case file will be downloaded to the current folder with the
+
+#### Upload file
+```sh
+gowebdav -X PUT temp/uploaded.txt /tmp/webdav/to_upload.txt
+```
+
+#### Move file on the remote server
+```sh
+gowebdav -X MV temp/file.txt temp/moved_file.txt
+```
+
+#### Copy file to another location
+```sh
+gowebdav -X MV temp/file.txt temp/file-copy.txt
+```
+
+#### Delete file from the remote server
+```sh
+gowebdav -X DEL temp/file.txt
+```
+
+# Wrapper script
+
+You can create wrapper script for your server (via `$EDITOR ./dav && chmod a+x ./dav`) and add following content to it:
+```sh
+#!/bin/sh
+
+ROOT="https://my.dav.server/" \
+USER="foo" \
+PASSWORD="$(pass dav/foo@my.dav.server)" \
+gowebdav $@
+```
+
+It allows you to use [pass](https://www.passwordstore.org/ "the standard unix password manager") or similar tools to retrieve the password.
+
+## Examples
+
+Using the `dav` wrapper:
+
+```sh
+$ ./dav -X LS /
+
+$ echo hi dav! > hello && ./dav -X PUT /hello
+$ ./dav -X STAT /hello
+$ ./dav -X PUT /hello_dav hello
+$ ./dav -X GET /hello_dav
+$ ./dav -X GET /hello_dav hello.txt
+```
\ No newline at end of file
diff --git a/pkg/gowebdav/cmd/gowebdav/main.go b/pkg/gowebdav/cmd/gowebdav/main.go
new file mode 100644
index 00000000..0164496f
--- /dev/null
+++ b/pkg/gowebdav/cmd/gowebdav/main.go
@@ -0,0 +1,263 @@
+package main
+
+import (
+ "errors"
+ "flag"
+ "fmt"
+ "io"
+ "io/fs"
+ "os"
+ "os/user"
+ "path"
+ "path/filepath"
+ "runtime"
+ "strings"
+
+ d "github.com/alist-org/alist/v3/pkg/gowebdav"
+)
+
+func main() {
+ root := flag.String("root", os.Getenv("ROOT"), "WebDAV Endpoint [ENV.ROOT]")
+ user := flag.String("user", os.Getenv("USER"), "User [ENV.USER]")
+ password := flag.String("pw", os.Getenv("PASSWORD"), "Password [ENV.PASSWORD]")
+ netrc := flag.String("netrc-file", filepath.Join(getHome(), ".netrc"), "read login from netrc file")
+ method := flag.String("X", "", `Method:
+ LS
+ STAT
+
+ MKDIR
+ MKDIRALL
+
+ GET []
+ PUT []
+
+ MV
+ CP
+
+ DEL
+ `)
+ flag.Parse()
+
+ if *root == "" {
+ fail("Set WebDAV ROOT")
+ }
+
+ if argsLength := len(flag.Args()); argsLength == 0 || argsLength > 2 {
+ fail("Unsupported arguments")
+ }
+
+ if *password == "" {
+ if u, p := d.ReadConfig(*root, *netrc); u != "" && p != "" {
+ user = &u
+ password = &p
+ }
+ }
+
+ c := d.NewClient(*root, *user, *password)
+
+ cmd := getCmd(*method)
+
+ if e := cmd(c, flag.Arg(0), flag.Arg(1)); e != nil {
+ fail(e)
+ }
+}
+
+func fail(err interface{}) {
+ if err != nil {
+ fmt.Println(err)
+ }
+ os.Exit(-1)
+}
+
+func getHome() string {
+ u, e := user.Current()
+ if e != nil {
+ return os.Getenv("HOME")
+ }
+
+ if u != nil {
+ return u.HomeDir
+ }
+
+ switch runtime.GOOS {
+ case "windows":
+ return ""
+ default:
+ return "~/"
+ }
+}
+
+func getCmd(method string) func(c *d.Client, p0, p1 string) error {
+ switch strings.ToUpper(method) {
+ case "LS", "LIST", "PROPFIND":
+ return cmdLs
+
+ case "STAT":
+ return cmdStat
+
+ case "GET", "PULL", "READ":
+ return cmdGet
+
+ case "DELETE", "RM", "DEL":
+ return cmdRm
+
+ case "MKCOL", "MKDIR":
+ return cmdMkdir
+
+ case "MKCOLALL", "MKDIRALL", "MKDIRP":
+ return cmdMkdirAll
+
+ case "RENAME", "MV", "MOVE":
+ return cmdMv
+
+ case "COPY", "CP":
+ return cmdCp
+
+ case "PUT", "PUSH", "WRITE":
+ return cmdPut
+
+ default:
+ return func(c *d.Client, p0, p1 string) (err error) {
+ return errors.New("Unsupported method: " + method)
+ }
+ }
+}
+
+func cmdLs(c *d.Client, p0, _ string) (err error) {
+ files, err := c.ReadDir(p0)
+ if err == nil {
+ fmt.Println(fmt.Sprintf("ReadDir: '%s' entries: %d ", p0, len(files)))
+ for _, f := range files {
+ fmt.Println(f)
+ }
+ }
+ return
+}
+
+func cmdStat(c *d.Client, p0, _ string) (err error) {
+ file, err := c.Stat(p0)
+ if err == nil {
+ fmt.Println(file)
+ }
+ return
+}
+
+func cmdGet(c *d.Client, p0, p1 string) (err error) {
+ bytes, err := c.Read(p0)
+ if err == nil {
+ if p1 == "" {
+ p1 = filepath.Join(".", p0)
+ }
+ err = writeFile(p1, bytes, 0644)
+ if err == nil {
+ fmt.Println(fmt.Sprintf("Written %d bytes to: %s", len(bytes), p1))
+ }
+ }
+ return
+}
+
+func cmdRm(c *d.Client, p0, _ string) (err error) {
+ if err = c.Remove(p0); err == nil {
+ fmt.Println("Remove: " + p0)
+ }
+ return
+}
+
+func cmdMkdir(c *d.Client, p0, _ string) (err error) {
+ if err = c.Mkdir(p0, 0755); err == nil {
+ fmt.Println("Mkdir: " + p0)
+ }
+ return
+}
+
+func cmdMkdirAll(c *d.Client, p0, _ string) (err error) {
+ if err = c.MkdirAll(p0, 0755); err == nil {
+ fmt.Println("MkdirAll: " + p0)
+ }
+ return
+}
+
+func cmdMv(c *d.Client, p0, p1 string) (err error) {
+ if err = c.Rename(p0, p1, true); err == nil {
+ fmt.Println("Rename: " + p0 + " -> " + p1)
+ }
+ return
+}
+
+func cmdCp(c *d.Client, p0, p1 string) (err error) {
+ if err = c.Copy(p0, p1, true); err == nil {
+ fmt.Println("Copy: " + p0 + " -> " + p1)
+ }
+ return
+}
+
+func cmdPut(c *d.Client, p0, p1 string) (err error) {
+ if p1 == "" {
+ p1 = path.Join(".", p0)
+ } else {
+ var fi fs.FileInfo
+ fi, err = c.Stat(p0)
+ if err != nil && !d.IsErrNotFound(err) {
+ return
+ }
+ if !d.IsErrNotFound(err) && fi.IsDir() {
+ p0 = path.Join(p0, p1)
+ }
+ }
+
+ stream, err := getStream(p1)
+ if err != nil {
+ return
+ }
+ defer stream.Close()
+
+ if err = c.WriteStream(p0, stream, 0644, nil); err == nil {
+ fmt.Println("Put: " + p1 + " -> " + p0)
+ }
+ return
+}
+
+func writeFile(path string, bytes []byte, mode os.FileMode) error {
+ parent := filepath.Dir(path)
+ if _, e := os.Stat(parent); os.IsNotExist(e) {
+ if e := os.MkdirAll(parent, os.ModePerm); e != nil {
+ return e
+ }
+ }
+
+ f, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ _, err = f.Write(bytes)
+ return err
+}
+
+func getStream(pathOrString string) (io.ReadCloser, error) {
+
+ fi, err := os.Stat(pathOrString)
+ if err != nil {
+ return nil, err
+ }
+
+ if fi.IsDir() {
+ return nil, &os.PathError{
+ Op: "Open",
+ Path: pathOrString,
+ Err: errors.New("Path: '" + pathOrString + "' is a directory"),
+ }
+ }
+
+ f, err := os.Open(pathOrString)
+ if err == nil {
+ return f, nil
+ }
+
+ return nil, &os.PathError{
+ Op: "Open",
+ Path: pathOrString,
+ Err: err,
+ }
+}
diff --git a/pkg/gowebdav/digestAuth.go b/pkg/gowebdav/digestAuth.go
new file mode 100644
index 00000000..4a5eb62f
--- /dev/null
+++ b/pkg/gowebdav/digestAuth.go
@@ -0,0 +1,146 @@
+package gowebdav
+
+import (
+ "crypto/md5"
+ "crypto/rand"
+ "encoding/hex"
+ "fmt"
+ "io"
+ "net/http"
+ "strings"
+)
+
+// DigestAuth structure holds our credentials
+type DigestAuth struct {
+ user string
+ pw string
+ digestParts map[string]string
+}
+
+// Type identifies the DigestAuthenticator
+func (d *DigestAuth) Type() string {
+ return "DigestAuth"
+}
+
+// User holds the DigestAuth username
+func (d *DigestAuth) User() string {
+ return d.user
+}
+
+// Pass holds the DigestAuth password
+func (d *DigestAuth) Pass() string {
+ return d.pw
+}
+
+// Authorize the current request
+func (d *DigestAuth) Authorize(req *http.Request, method string, path string) {
+ d.digestParts["uri"] = path
+ d.digestParts["method"] = method
+ d.digestParts["username"] = d.user
+ d.digestParts["password"] = d.pw
+ req.Header.Set("Authorization", getDigestAuthorization(d.digestParts))
+}
+
+func digestParts(resp *http.Response) map[string]string {
+ result := map[string]string{}
+ if len(resp.Header["Www-Authenticate"]) > 0 {
+ wantedHeaders := []string{"nonce", "realm", "qop", "opaque", "algorithm", "entityBody"}
+ responseHeaders := strings.Split(resp.Header["Www-Authenticate"][0], ",")
+ for _, r := range responseHeaders {
+ for _, w := range wantedHeaders {
+ if strings.Contains(r, w) {
+ result[w] = strings.Trim(
+ strings.SplitN(r, `=`, 2)[1],
+ `"`,
+ )
+ }
+ }
+ }
+ }
+ return result
+}
+
+func getMD5(text string) string {
+ hasher := md5.New()
+ hasher.Write([]byte(text))
+ return hex.EncodeToString(hasher.Sum(nil))
+}
+
+func getCnonce() string {
+ b := make([]byte, 8)
+ io.ReadFull(rand.Reader, b)
+ return fmt.Sprintf("%x", b)[:16]
+}
+
+func getDigestAuthorization(digestParts map[string]string) string {
+ d := digestParts
+ // These are the correct ha1 and ha2 for qop=auth. We should probably check for other types of qop.
+
+ var (
+ ha1 string
+ ha2 string
+ nonceCount = 00000001
+ cnonce = getCnonce()
+ response string
+ )
+
+ // 'ha1' value depends on value of "algorithm" field
+ switch d["algorithm"] {
+ case "MD5", "":
+ ha1 = getMD5(d["username"] + ":" + d["realm"] + ":" + d["password"])
+ case "MD5-sess":
+ ha1 = getMD5(
+ fmt.Sprintf("%s:%v:%s",
+ getMD5(d["username"]+":"+d["realm"]+":"+d["password"]),
+ nonceCount,
+ cnonce,
+ ),
+ )
+ }
+
+ // 'ha2' value depends on value of "qop" field
+ switch d["qop"] {
+ case "auth", "":
+ ha2 = getMD5(d["method"] + ":" + d["uri"])
+ case "auth-int":
+ if d["entityBody"] != "" {
+ ha2 = getMD5(d["method"] + ":" + d["uri"] + ":" + getMD5(d["entityBody"]))
+ }
+ }
+
+ // 'response' value depends on value of "qop" field
+ switch d["qop"] {
+ case "":
+ response = getMD5(
+ fmt.Sprintf("%s:%s:%s",
+ ha1,
+ d["nonce"],
+ ha2,
+ ),
+ )
+ case "auth", "auth-int":
+ response = getMD5(
+ fmt.Sprintf("%s:%s:%v:%s:%s:%s",
+ ha1,
+ d["nonce"],
+ nonceCount,
+ cnonce,
+ d["qop"],
+ ha2,
+ ),
+ )
+ }
+
+ authorization := fmt.Sprintf(`Digest username="%s", realm="%s", nonce="%s", uri="%s", nc=%v, cnonce="%s", response="%s"`,
+ d["username"], d["realm"], d["nonce"], d["uri"], nonceCount, cnonce, response)
+
+ if d["qop"] != "" {
+ authorization += fmt.Sprintf(`, qop=%s`, d["qop"])
+ }
+
+ if d["opaque"] != "" {
+ authorization += fmt.Sprintf(`, opaque="%s"`, d["opaque"])
+ }
+
+ return authorization
+}
diff --git a/pkg/gowebdav/doc.go b/pkg/gowebdav/doc.go
new file mode 100644
index 00000000..e47d5eee
--- /dev/null
+++ b/pkg/gowebdav/doc.go
@@ -0,0 +1,3 @@
+// Package gowebdav is a WebDAV client library with a command line tool
+// included.
+package gowebdav
diff --git a/pkg/gowebdav/errors.go b/pkg/gowebdav/errors.go
new file mode 100644
index 00000000..bbf1e929
--- /dev/null
+++ b/pkg/gowebdav/errors.go
@@ -0,0 +1,49 @@
+package gowebdav
+
+import (
+ "fmt"
+ "os"
+)
+
+// StatusError implements error and wraps
+// an erroneous status code.
+type StatusError struct {
+ Status int
+}
+
+func (se StatusError) Error() string {
+ return fmt.Sprintf("%d", se.Status)
+}
+
+// IsErrCode returns true if the given error
+// is an os.PathError wrapping a StatusError
+// with the given status code.
+func IsErrCode(err error, code int) bool {
+ if pe, ok := err.(*os.PathError); ok {
+ se, ok := pe.Err.(StatusError)
+ return ok && se.Status == code
+ }
+ return false
+}
+
+// IsErrNotFound is shorthand for IsErrCode
+// for status 404.
+func IsErrNotFound(err error) bool {
+ return IsErrCode(err, 404)
+}
+
+func newPathError(op string, path string, statusCode int) error {
+ return &os.PathError{
+ Op: op,
+ Path: path,
+ Err: StatusError{statusCode},
+ }
+}
+
+func newPathErrorErr(op string, path string, err error) error {
+ return &os.PathError{
+ Op: op,
+ Path: path,
+ Err: err,
+ }
+}
diff --git a/pkg/gowebdav/file.go b/pkg/gowebdav/file.go
new file mode 100644
index 00000000..ae2303fc
--- /dev/null
+++ b/pkg/gowebdav/file.go
@@ -0,0 +1,77 @@
+package gowebdav
+
+import (
+ "fmt"
+ "os"
+ "time"
+)
+
+// File is our structure for a given file
+type File struct {
+ path string
+ name string
+ contentType string
+ size int64
+ modified time.Time
+ etag string
+ isdir bool
+}
+
+// Path returns the full path of a file
+func (f File) Path() string {
+ return f.path
+}
+
+// Name returns the name of a file
+func (f File) Name() string {
+ return f.name
+}
+
+// ContentType returns the content type of a file
+func (f File) ContentType() string {
+ return f.contentType
+}
+
+// Size returns the size of a file
+func (f File) Size() int64 {
+ return f.size
+}
+
+// Mode will return the mode of a given file
+func (f File) Mode() os.FileMode {
+ // TODO check webdav perms
+ if f.isdir {
+ return 0775 | os.ModeDir
+ }
+
+ return 0664
+}
+
+// ModTime returns the modified time of a file
+func (f File) ModTime() time.Time {
+ return f.modified
+}
+
+// ETag returns the ETag of a file
+func (f File) ETag() string {
+ return f.etag
+}
+
+// IsDir let us see if a given file is a directory or not
+func (f File) IsDir() bool {
+ return f.isdir
+}
+
+// Sys ????
+func (f File) Sys() interface{} {
+ return nil
+}
+
+// String lets us see file information
+func (f File) String() string {
+ if f.isdir {
+ return fmt.Sprintf("Dir : '%s' - '%s'", f.path, f.name)
+ }
+
+ return fmt.Sprintf("File: '%s' SIZE: %d MODIFIED: %s ETAG: %s CTYPE: %s", f.path, f.size, f.modified.String(), f.etag, f.contentType)
+}
diff --git a/pkg/gowebdav/netrc.go b/pkg/gowebdav/netrc.go
new file mode 100644
index 00000000..df479b52
--- /dev/null
+++ b/pkg/gowebdav/netrc.go
@@ -0,0 +1,54 @@
+package gowebdav
+
+import (
+ "bufio"
+ "fmt"
+ "net/url"
+ "os"
+ "regexp"
+ "strings"
+)
+
+func parseLine(s string) (login, pass string) {
+ fields := strings.Fields(s)
+ for i, f := range fields {
+ if f == "login" {
+ login = fields[i+1]
+ }
+ if f == "password" {
+ pass = fields[i+1]
+ }
+ }
+ return login, pass
+}
+
+// ReadConfig reads login and password configuration from ~/.netrc
+// machine foo.com login username password 123456
+func ReadConfig(uri, netrc string) (string, string) {
+ u, err := url.Parse(uri)
+ if err != nil {
+ return "", ""
+ }
+
+ file, err := os.Open(netrc)
+ if err != nil {
+ return "", ""
+ }
+ defer file.Close()
+
+ re := fmt.Sprintf(`^.*machine %s.*$`, u.Host)
+ scanner := bufio.NewScanner(file)
+ for scanner.Scan() {
+ s := scanner.Text()
+
+ matched, err := regexp.MatchString(re, s)
+ if err != nil {
+ return "", ""
+ }
+ if matched {
+ return parseLine(s)
+ }
+ }
+
+ return "", ""
+}
diff --git a/pkg/gowebdav/requests.go b/pkg/gowebdav/requests.go
new file mode 100644
index 00000000..5472db08
--- /dev/null
+++ b/pkg/gowebdav/requests.go
@@ -0,0 +1,214 @@
+package gowebdav
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "net/http"
+ "path"
+ "strings"
+)
+
+func (c *Client) req(method, path string, body io.Reader, intercept func(*http.Request)) (req *http.Response, err error) {
+ var r *http.Request
+ var retryBuf io.Reader
+
+ if body != nil {
+ // If the authorization fails, we will need to restart reading
+ // from the passed body stream.
+ // When body is seekable, use seek to reset the streams
+ // cursor to the start.
+ // Otherwise, copy the stream into a buffer while uploading
+ // and use the buffers content on retry.
+ if sk, ok := body.(io.Seeker); ok {
+ if _, err = sk.Seek(0, io.SeekStart); err != nil {
+ return
+ }
+ retryBuf = body
+ } else {
+ buff := &bytes.Buffer{}
+ retryBuf = buff
+ body = io.TeeReader(body, buff)
+ }
+ r, err = http.NewRequest(method, PathEscape(Join(c.root, path)), body)
+ } else {
+ r, err = http.NewRequest(method, PathEscape(Join(c.root, path)), nil)
+ }
+
+ if err != nil {
+ return nil, err
+ }
+
+ for k, vals := range c.headers {
+ for _, v := range vals {
+ r.Header.Add(k, v)
+ }
+ }
+
+ // make sure we read 'c.auth' only once since it will be substituted below
+ // and that is unsafe to do when multiple goroutines are running at the same time.
+ c.authMutex.Lock()
+ auth := c.auth
+ c.authMutex.Unlock()
+
+ auth.Authorize(r, method, path)
+
+ if intercept != nil {
+ intercept(r)
+ }
+
+ if c.interceptor != nil {
+ c.interceptor(method, r)
+ }
+
+ rs, err := c.c.Do(r)
+ if err != nil {
+ return nil, err
+ }
+
+ if rs.StatusCode == 401 && auth.Type() == "NoAuth" {
+ wwwAuthenticateHeader := strings.ToLower(rs.Header.Get("Www-Authenticate"))
+
+ if strings.Index(wwwAuthenticateHeader, "digest") > -1 {
+ c.authMutex.Lock()
+ c.auth = &DigestAuth{auth.User(), auth.Pass(), digestParts(rs)}
+ c.authMutex.Unlock()
+ } else if strings.Index(wwwAuthenticateHeader, "basic") > -1 {
+ c.authMutex.Lock()
+ c.auth = &BasicAuth{auth.User(), auth.Pass()}
+ c.authMutex.Unlock()
+ } else {
+ return rs, newPathError("Authorize", c.root, rs.StatusCode)
+ }
+
+ // retryBuf will be nil if body was nil initially so no check
+ // for body == nil is required here.
+ return c.req(method, path, retryBuf, intercept)
+ } else if rs.StatusCode == 401 {
+ return rs, newPathError("Authorize", c.root, rs.StatusCode)
+ }
+
+ return rs, err
+}
+
+func (c *Client) mkcol(path string) (status int, err error) {
+ rs, err := c.req("MKCOL", path, nil, nil)
+ if err != nil {
+ return
+ }
+ defer rs.Body.Close()
+
+ status = rs.StatusCode
+ if status == 405 {
+ status = 201
+ }
+
+ return
+}
+
+func (c *Client) options(path string) (*http.Response, error) {
+ return c.req("OPTIONS", path, nil, func(rq *http.Request) {
+ rq.Header.Add("Depth", "0")
+ })
+}
+
+func (c *Client) propfind(path string, self bool, body string, resp interface{}, parse func(resp interface{}) error) error {
+ rs, err := c.req("PROPFIND", path, strings.NewReader(body), func(rq *http.Request) {
+ if self {
+ rq.Header.Add("Depth", "0")
+ } else {
+ rq.Header.Add("Depth", "1")
+ }
+ rq.Header.Add("Content-Type", "application/xml;charset=UTF-8")
+ rq.Header.Add("Accept", "application/xml,text/xml")
+ rq.Header.Add("Accept-Charset", "utf-8")
+ // TODO add support for 'gzip,deflate;q=0.8,q=0.7'
+ rq.Header.Add("Accept-Encoding", "")
+ })
+ if err != nil {
+ return err
+ }
+ defer rs.Body.Close()
+
+ if rs.StatusCode != 207 {
+ return newPathError("PROPFIND", path, rs.StatusCode)
+ }
+
+ return parseXML(rs.Body, resp, parse)
+}
+
+func (c *Client) doCopyMove(
+ method string,
+ oldpath string,
+ newpath string,
+ overwrite bool,
+) (
+ status int,
+ r io.ReadCloser,
+ err error,
+) {
+ rs, err := c.req(method, oldpath, nil, func(rq *http.Request) {
+ rq.Header.Add("Destination", PathEscape(Join(c.root, newpath)))
+ if overwrite {
+ rq.Header.Add("Overwrite", "T")
+ } else {
+ rq.Header.Add("Overwrite", "F")
+ }
+ })
+ if err != nil {
+ return
+ }
+ status = rs.StatusCode
+ r = rs.Body
+ return
+}
+
+func (c *Client) copymove(method string, oldpath string, newpath string, overwrite bool) (err error) {
+ s, data, err := c.doCopyMove(method, oldpath, newpath, overwrite)
+ if err != nil {
+ return
+ }
+ if data != nil {
+ defer data.Close()
+ }
+
+ switch s {
+ case 201, 204:
+ return nil
+
+ case 207:
+ // TODO handle multistat errors, worst case ...
+ log(fmt.Sprintf(" TODO handle %s - %s multistatus result %s", method, oldpath, String(data)))
+
+ case 409:
+ err := c.createParentCollection(newpath)
+ if err != nil {
+ return err
+ }
+
+ return c.copymove(method, oldpath, newpath, overwrite)
+ }
+
+ return newPathError(method, oldpath, s)
+}
+
+func (c *Client) put(path string, stream io.Reader, callback func(r *http.Request)) (status int, err error) {
+ rs, err := c.req("PUT", path, stream, callback)
+ if err != nil {
+ return
+ }
+ defer rs.Body.Close()
+ //all, _ := io.ReadAll(rs.Body)
+ //logrus.Debugln("put res: ", string(all))
+ status = rs.StatusCode
+ return
+}
+
+func (c *Client) createParentCollection(itemPath string) (err error) {
+ parentPath := path.Dir(itemPath)
+ if parentPath == "." || parentPath == "/" {
+ return nil
+ }
+
+ return c.MkdirAll(parentPath, 0755)
+}
diff --git a/pkg/gowebdav/utils.go b/pkg/gowebdav/utils.go
new file mode 100644
index 00000000..c7a65ad5
--- /dev/null
+++ b/pkg/gowebdav/utils.go
@@ -0,0 +1,118 @@
+package gowebdav
+
+import (
+ "bytes"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+)
+
+func log(msg interface{}) {
+ fmt.Println(msg)
+}
+
+// PathEscape escapes all segments of a given path
+func PathEscape(path string) string {
+ s := strings.Split(path, "/")
+ for i, e := range s {
+ s[i] = url.PathEscape(e)
+ }
+ return strings.Join(s, "/")
+}
+
+// FixSlash appends a trailing / to our string
+func FixSlash(s string) string {
+ if !strings.HasSuffix(s, "/") {
+ s += "/"
+ }
+ return s
+}
+
+// FixSlashes appends and prepends a / if they are missing
+func FixSlashes(s string) string {
+ if !strings.HasPrefix(s, "/") {
+ s = "/" + s
+ }
+
+ return FixSlash(s)
+}
+
+// Join joins two paths
+func Join(path0 string, path1 string) string {
+ return strings.TrimSuffix(path0, "/") + "/" + strings.TrimPrefix(path1, "/")
+}
+
+// String pulls a string out of our io.Reader
+func String(r io.Reader) string {
+ buf := new(bytes.Buffer)
+ // TODO - make String return an error as well
+ _, _ = buf.ReadFrom(r)
+ return buf.String()
+}
+
+func parseUint(s *string) uint {
+ if n, e := strconv.ParseUint(*s, 10, 32); e == nil {
+ return uint(n)
+ }
+ return 0
+}
+
+func parseInt64(s *string) int64 {
+ if n, e := strconv.ParseInt(*s, 10, 64); e == nil {
+ return n
+ }
+ return 0
+}
+
+func parseModified(s *string) time.Time {
+ if t, e := time.Parse(time.RFC1123, *s); e == nil {
+ return t
+ }
+ return time.Unix(0, 0)
+}
+
+func parseXML(data io.Reader, resp interface{}, parse func(resp interface{}) error) error {
+ decoder := xml.NewDecoder(data)
+ for t, _ := decoder.Token(); t != nil; t, _ = decoder.Token() {
+ switch se := t.(type) {
+ case xml.StartElement:
+ if se.Name.Local == "response" {
+ if e := decoder.DecodeElement(resp, &se); e == nil {
+ if err := parse(resp); err != nil {
+ return err
+ }
+ }
+ }
+ }
+ }
+ return nil
+}
+
+// limitedReadCloser wraps a io.ReadCloser and limits the number of bytes that can be read from it.
+type limitedReadCloser struct {
+ rc io.ReadCloser
+ remaining int
+}
+
+func (l *limitedReadCloser) Read(buf []byte) (int, error) {
+ if l.remaining <= 0 {
+ return 0, io.EOF
+ }
+
+ if len(buf) > l.remaining {
+ buf = buf[0:l.remaining]
+ }
+
+ n, err := l.rc.Read(buf)
+ l.remaining -= n
+
+ return n, err
+}
+
+func (l *limitedReadCloser) Close() error {
+ return l.rc.Close()
+}
diff --git a/pkg/gowebdav/utils_test.go b/pkg/gowebdav/utils_test.go
new file mode 100644
index 00000000..04410fd0
--- /dev/null
+++ b/pkg/gowebdav/utils_test.go
@@ -0,0 +1,67 @@
+package gowebdav
+
+import (
+ "fmt"
+ "net/url"
+ "testing"
+)
+
+func TestJoin(t *testing.T) {
+ eq(t, "/", "", "")
+ eq(t, "/", "/", "/")
+ eq(t, "/foo", "", "/foo")
+ eq(t, "foo/foo", "foo/", "/foo")
+ eq(t, "foo/foo", "foo/", "foo")
+}
+
+func eq(t *testing.T, expected string, s0 string, s1 string) {
+ s := Join(s0, s1)
+ if s != expected {
+ t.Error("For", "'"+s0+"','"+s1+"'", "expeted", "'"+expected+"'", "got", "'"+s+"'")
+ }
+}
+
+func ExamplePathEscape() {
+ fmt.Println(PathEscape(""))
+ fmt.Println(PathEscape("/"))
+ fmt.Println(PathEscape("/web"))
+ fmt.Println(PathEscape("/web/"))
+ fmt.Println(PathEscape("/w e b/d a v/s%u&c#k:s/"))
+
+ // Output:
+ //
+ // /
+ // /web
+ // /web/
+ // /w%20e%20b/d%20a%20v/s%25u&c%23k:s/
+}
+
+func TestEscapeURL(t *testing.T) {
+ ex := "https://foo.com/w%20e%20b/d%20a%20v/s%25u&c%23k:s/"
+ u, _ := url.Parse("https://foo.com" + PathEscape("/w e b/d a v/s%u&c#k:s/"))
+ if ex != u.String() {
+ t.Error("expected: " + ex + " got: " + u.String())
+ }
+}
+
+func TestFixSlashes(t *testing.T) {
+ expected := "/"
+
+ if got := FixSlashes(""); got != expected {
+ t.Errorf("expected: %q, got: %q", expected, got)
+ }
+
+ expected = "/path/"
+
+ if got := FixSlashes("path"); got != expected {
+ t.Errorf("expected: %q, got: %q", expected, got)
+ }
+
+ if got := FixSlashes("/path"); got != expected {
+ t.Errorf("expected: %q, got: %q", expected, got)
+ }
+
+ if got := FixSlashes("path/"); got != expected {
+ t.Errorf("expected: %q, got: %q", expected, got)
+ }
+}