29 changed files with 343 additions and 3492 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,27 +0,0 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 ---
 Hello Collaborators,
 **Describe the bug**
 A short description of what you think the bug is.
 **Software**
 - OS:
 - Golang:
 - Version:
 **To Reproduce**
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
 4. See error
 **Expected**
 A short description of what you expected to happen.
 **Additional context**
 Add any other context about the problem here.
--- a/.github/workflows/artifacts.yml
+++ b/.github/workflows/artifacts.yml
@ -1,46 +0,0 @@
 name: Build Artifacts
 on:
  workflow_dispatch:
  push:
    branches:
      - master
    paths-ignore:
      - "**.md"
 jobs:
  build_artifacts:
    name: Build Artifcats
    runs-on: ubuntu-latest
    strategy:
      matrix:
        goos:
          - linux
          - windows
          - darwin
        goarch:
          - amd64
          - arm64
    steps:
      - name: Set up Go
        uses: actions/setup-go@v1
        with:
          go-version: "^1.17"
      - name: Check out code into the Go module directory
        uses: actions/checkout@v2
      - name: Get dependencies
        run: go get ./...
      - name: Build Client (${{ matrix.goos }}-${{ matrix.goarch }})
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
        run: go build -v -o ./bin/gowebdav-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/gowebdav/main.go
      - name: Rename Windows Binary
        if: ${{ matrix.goos == 'windows' }}
        env:
          FNAME: ./bin/gowebdav-${{ matrix.goos }}-${{ matrix.goarch }}
        run: mv ${{ env.FNAME }} ${{ env.FNAME }}.exe
      - name: Upload Artifcats
        uses: actions/upload-artifact@v2
        with:
          name: ${{ matrix.goos }}-${{ matrix.goarch }}
          path: ./bin/
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@ -1,31 +0,0 @@
 name: Unit Tests
 on:
  workflow_dispatch:
  push:
    branches:
      - "*"
    paths-ignore:
      - "**.md"
  pull_request:
 jobs:
  unit_tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    strategy:
      matrix:
        goversion:
          - "1.20"
          - "1.19"
          - "1.18"
    steps:
      - name: Set up Go
        uses: actions/setup-go@v1
        with:
          go-version: ${{ matrix.goversion }}
      - name: Check out code into the Go module directory
        uses: actions/checkout@v2
      - name: Get dependencies
        run: go get ./...
      - name: Run Unit Tests
        run: go test -modfile=go_test.mod -v -cover -race ./...
--- a/.gitignore
+++ b/.gitignore
@ -1,21 +1,2 @@
-# Folders to ignore
+src
-/src
+bin
 /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/
--- a/47
+++ b/47
@ -1,42 +1,21 @@
-BIN := gowebdav
+SRC     := $(wildcard *.go) main/client.go
-SRC := $(wildcard *.go) cmd/gowebdav/main.go
+BIN     := bin
 CLIENT  := ${BIN}/client
 GOPATH  ?= ${PWD}
-all: test cmd
+all: test client
-cmd: ${BIN}
+client: ${CLIENT}
-${BIN}: ${SRC}
+${CLIENT}: ${SRC}
-	go build -o $@ ./cmd/gowebdav
+	@echo build $@
 	@GOPATH=${GOPATH} go build -o $@ -- main/client.go
 test:
-	go test -modfile=go_test.mod -v -short -cover ./...
+	@GOPATH=${GOPATH} go test
 api: .go/bin/godoc2md
 	@sed '/^## API$$/,$$d' -i README.md
 	@echo '## API' >> README.md
 	@$< 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: .go/bin/gocyclo
 	gofmt -w -s $(SRC)
 	@echo
 	.go/bin/gocyclo -over 15 .
 	@echo
 	go vet -modfile=go_test.mod ./...
 .go/bin/godoc2md:
 	@mkdir -p $(@D)
 	@GOPATH="$(CURDIR)/.go" go install github.com/davecheney/godoc2md@latest
 .go/bin/gocyclo:
 	@mkdir -p $(@D)
 	@GOPATH="$(CURDIR)/.go" go install github.com/fzipp/gocyclo/cmd/gocyclo@latest
 clean:
-	@rm -f ${BIN}
+	@echo clean ${BIN}
 	@rm -f ${BIN}/*
-.PHONY: all cmd clean test api check
+.PHONY: all client clean
--- a/README.md
+++ b/README.md
@ -1,793 +1,10 @@
-# GoWebDAV
+# GOWEBDAV - WebDAV Client for golang
-[![Unit Tests Status](https://github.com/studio-b12/gowebdav/actions/workflows/tests.yml/badge.svg)](https://github.com/studio-b12/gowebdav/actions/workflows/tests.yml)
+## LINKS
 [![Build Artifacts Status](https://github.com/studio-b12/gowebdav/actions/workflows/artifacts.yml/badge.svg)](https://github.com/studio-b12/gowebdav/actions/workflows/artifacts.yml)
 [![GoDoc](https://godoc.org/github.com/studio-b12/gowebdav?status.svg)](https://godoc.org/github.com/studio-b12/gowebdav)
 [![Go Report Card](https://goreportcard.com/badge/github.com/studio-b12/gowebdav)](https://goreportcard.com/report/github.com/studio-b12/gowebdav)
-A pure Golang WebDAV client library that comes with a [reference implementation](https://github.com/studio-b12/gowebdav/tree/master/cmd/gowebdav).
+* [rfc2518](http://asg.andrew.cmu.edu/rfc/rfc2518.html)
 * [rfc2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
-## Features at a glance
+## Books
-Our `gowebdav` library allows to perform following actions on the remote WebDAV server:
+* [WebDav: Next Gen](https://books.google.de/books?isbn=0130652083 "WebDav: Next Generation Collaborative Web Authoring By Lisa Dusseault")
 * [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)
 It also provides an [authentication API](#type-authenticator) that makes it easy to encapsulate and control complex authentication challenges.
 The default implementation negotiates the algorithm based on the user's preferences and the methods offered by the remote server.
 Out-of-box authentication support for:
 * [BasicAuth](https://en.wikipedia.org/wiki/Basic_access_authentication)
 * [DigestAuth](https://en.wikipedia.org/wiki/Digest_access_authentication)
 * [MS-PASS](https://github.com/studio-b12/gowebdav/pull/70#issuecomment-1421713726)
 * [WIP Kerberos](https://github.com/studio-b12/gowebdav/pull/71#issuecomment-1416465334)
 * [WIP Bearer Token](https://github.com/studio-b12/gowebdav/issues/61)
 ## 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)
 c.Connect()
 // kick of your work!
 ```
 After you can use this `Client` to perform actions, described below.
 **NOTICE:** We will not check for errors in the 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)
 os.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, _ := os.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)
 ### <a name="pkg-overview">Overview</a>
 Package gowebdav is a WebDAV client library with a command line tool
 included.
 ### <a name="pkg-index">Index</a>
 * [Constants](#pkg-constants)
 * [Variables](#pkg-variables)
 * [func FixSlash(s string) string](#FixSlash)
 * [func FixSlashes(s string) string](#FixSlashes)
 * [func IsErrCode(err error, code int) bool](#IsErrCode)
 * [func IsErrNotFound(err error) bool](#IsErrNotFound)
 * [func Join(path0 string, path1 string) string](#Join)
 * [func NewPathError(op string, path string, statusCode int) error](#NewPathError)
 * [func NewPathErrorErr(op string, path string, err error) error](#NewPathErrorErr)
 * [func PathEscape(path string) string](#PathEscape)
 * [func ReadConfig(uri, netrc string) (string, string)](#ReadConfig)
 * [func String(r io.Reader) string](#String)
 * [type AuthFactory](#AuthFactory)
 * [type Authenticator](#Authenticator)
  * [func NewDigestAuth(login, secret string, rs *http.Response) (Authenticator, error)](#NewDigestAuth)
  * [func NewPassportAuth(c *http.Client, user, pw, partnerURL string, header *http.Header) (Authenticator, error)](#NewPassportAuth)
 * [type Authorizer](#Authorizer)
  * [func NewAutoAuth(login string, secret string) Authorizer](#NewAutoAuth)
  * [func NewEmptyAuth() Authorizer](#NewEmptyAuth)
  * [func NewPreemptiveAuth(auth Authenticator) Authorizer](#NewPreemptiveAuth)
 * [type BasicAuth](#BasicAuth)
  * [func (b *BasicAuth) Authorize(c *http.Client, rq *http.Request, path string) error](#BasicAuth.Authorize)
  * [func (b *BasicAuth) Clone() Authenticator](#BasicAuth.Clone)
  * [func (b *BasicAuth) Close() error](#BasicAuth.Close)
  * [func (b *BasicAuth) String() string](#BasicAuth.String)
  * [func (b *BasicAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)](#BasicAuth.Verify)
 * [type Client](#Client)
  * [func NewAuthClient(uri string, auth Authorizer) *Client](#NewAuthClient)
  * [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) (err error)](#Client.Mkdir)
  * [func (c *Client) MkdirAll(path string, _ os.FileMode) (err 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) SetJar(jar http.CookieJar)](#Client.SetJar)
  * [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) (err error)](#Client.Write)
  * [func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) (err error)](#Client.WriteStream)
 * [type DigestAuth](#DigestAuth)
  * [func (d *DigestAuth) Authorize(c *http.Client, rq *http.Request, path string) error](#DigestAuth.Authorize)
  * [func (d *DigestAuth) Clone() Authenticator](#DigestAuth.Clone)
  * [func (d *DigestAuth) Close() error](#DigestAuth.Close)
  * [func (d *DigestAuth) String() string](#DigestAuth.String)
  * [func (d *DigestAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)](#DigestAuth.Verify)
 * [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 PassportAuth](#PassportAuth)
  * [func (p *PassportAuth) Authorize(c *http.Client, rq *http.Request, path string) error](#PassportAuth.Authorize)
  * [func (p *PassportAuth) Clone() Authenticator](#PassportAuth.Clone)
  * [func (p *PassportAuth) Close() error](#PassportAuth.Close)
  * [func (p *PassportAuth) String() string](#PassportAuth.String)
  * [func (p *PassportAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)](#PassportAuth.Verify)
 * [type StatusError](#StatusError)
  * [func (se StatusError) Error() string](#StatusError.Error)
 ##### <a name="pkg-examples">Examples</a>
 * [PathEscape](#example_PathEscape)
 ##### <a name="pkg-files">Package files</a>
 [auth.go](https://github.com/studio-b12/gowebdav/blob/master/auth.go) [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) [errors.go](https://github.com/studio-b12/gowebdav/blob/master/errors.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) [passportAuth.go](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.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) 
 ### <a name="pkg-constants">Constants</a>
 ``` go
 const XInhibitRedirect = "X-Gowebdav-Inhibit-Redirect"
 ```
 ### <a name="pkg-variables">Variables</a>
 ``` go
 var ErrAuthChanged = errors.New("authentication failed, change algorithm")
 ```
 ErrAuthChanged must be returned from the Verify method as an error
 to trigger a re-authentication / negotiation with a new authenticator.
 ``` go
 var ErrTooManyRedirects = errors.New("stopped after 10 redirects")
 ```
 ErrTooManyRedirects will be used as return error if a request exceeds 10 redirects.
 ### <a name="FixSlash">func</a> [FixSlash](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=354:384#L23)
 ``` go
 func FixSlash(s string) string
 ```
 FixSlash appends a trailing / to our string
 ### <a name="FixSlashes">func</a> [FixSlashes](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=506:538#L31)
 ``` go
 func FixSlashes(s string) string
 ```
 FixSlashes appends and prepends a / if they are missing
 ### <a name="IsErrCode">func</a> [IsErrCode](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=740:780#L29)
 ``` go
 func IsErrCode(err error, code int) bool
 ```
 IsErrCode returns true if the given error
 is an os.PathError wrapping a StatusError
 with the given status code.
 ### <a name="IsErrNotFound">func</a> [IsErrNotFound](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=972:1006#L39)
 ``` go
 func IsErrNotFound(err error) bool
 ```
 IsErrNotFound is shorthand for IsErrCode
 for status 404.
 ### <a name="Join">func</a> [Join](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=639:683#L40)
 ``` go
 func Join(path0 string, path1 string) string
 ```
 Join joins two paths
 ### <a name="NewPathError">func</a> [NewPathError](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=1040:1103#L43)
 ``` go
 func NewPathError(op string, path string, statusCode int) error
 ```
 ### <a name="NewPathErrorErr">func</a> [NewPathErrorErr](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=1194:1255#L51)
 ``` go
 func NewPathErrorErr(op string, path string, err error) error
 ```
 ### <a name="PathEscape">func</a> [PathEscape](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=153:188#L14)
 ``` go
 func PathEscape(path string) string
 ```
 PathEscape escapes all segments of a given path
 ### <a name="ReadConfig">func</a> [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
 ### <a name="String">func</a> [String](https://github.com/studio-b12/gowebdav/blob/master/utils.go?s=813:844#L45)
 ``` go
 func String(r io.Reader) string
 ```
 String pulls a string out of our io.Reader
 ### <a name="AuthFactory">type</a> [AuthFactory](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=150:251#L13)
 ``` go
 type AuthFactory func(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error)
 ```
 AuthFactory prototype function to create a new Authenticator
 ### <a name="Authenticator">type</a> [Authenticator](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=2155:2695#L56)
 ``` go
 type Authenticator interface {
    // Authorizes a request. Usually by adding some authorization headers.
    Authorize(c *http.Client, rq *http.Request, path string) error
    // Verifies the response if the authorization was successful.
    // May trigger some round trips to pass the authentication.
    // May also trigger a new Authenticator negotiation by returning `ErrAuthChenged`
    Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)
    // Creates a copy of the underlying Authenticator.
    Clone() Authenticator
    io.Closer
 }
 ```
 A Authenticator implements a specific way to authorize requests.
 Each request is bound to a separate Authenticator instance.
 The authentication flow itself is broken down into `Authorize`
 and `Verify` steps. The former method runs before, and the latter
 runs after the `Request` is submitted.
 This makes it easy to encapsulate and control complex
 authentication challenges.
 Some authentication flows causing authentication round trips,
 which can be archived by returning the `redo` of the Verify
 method. `True` restarts the authentication process for the
 current action: A new `Request` is spawned, which must be
 authorized, sent, and re-verified again, until the action
 is successfully submitted.
 The preferred way is to handle the authentication ping-pong
 within `Verify`, and then `redo` with fresh credentials.
 The result of the `Verify` method can also trigger an
 `Authenticator` change by returning the `ErrAuthChanged`
 as an error. Depending on the `Authorizer` this may trigger
 an `Authenticator` negotiation.
 Set the `XInhibitRedirect` header to '1' in the `Authorize`
 method to get control over request redirection.
 Attention! You must handle the incoming request yourself.
 To store a shared session state the `Clone` method **must**
 return a new instance, initialized with the shared state.
 #### <a name="NewDigestAuth">func</a> [NewDigestAuth](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=324:406#L21)
 ``` go
 func NewDigestAuth(login, secret string, rs *http.Response) (Authenticator, error)
 ```
 NewDigestAuth creates a new instance of our Digest Authenticator
 #### <a name="NewPassportAuth">func</a> [NewPassportAuth](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=386:495#L21)
 ``` go
 func NewPassportAuth(c *http.Client, user, pw, partnerURL string, header *http.Header) (Authenticator, error)
 ```
 constructor for PassportAuth creates a new PassportAuth object and
 automatically authenticates against the given partnerURL
 ### <a name="Authorizer">type</a> [Authorizer](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=349:764#L17)
 ``` go
 type Authorizer interface {
    // Creates a new Authenticator Shim per request.
    // It may track request related states and perform payload buffering
    // for authentication round trips.
    // The underlying Authenticator will perform the real authentication.
    NewAuthenticator(body io.Reader) (Authenticator, io.Reader)
    // Registers a new Authenticator factory to a key.
    AddAuthenticator(key string, fn AuthFactory)
 }
 ```
 Authorizer our Authenticator factory which creates an
 `Authenticator` per action/request.
 #### <a name="NewAutoAuth">func</a> [NewAutoAuth](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=3789:3845#L109)
 ``` go
 func NewAutoAuth(login string, secret string) Authorizer
 ```
 NewAutoAuth creates an auto Authenticator factory.
 It negotiates the default authentication method
 based on the order of the registered Authenticators
 and the remotely offered authentication methods.
 First In, First Out.
 #### <a name="NewEmptyAuth">func</a> [NewEmptyAuth](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=4694:4724#L132)
 ``` go
 func NewEmptyAuth() Authorizer
 ```
 NewEmptyAuth creates an empty Authenticator factory
 The order of adding the Authenticator matters.
 First In, First Out.
 It offers the `NewAutoAuth` features.
 #### <a name="NewPreemptiveAuth">func</a> [NewPreemptiveAuth](https://github.com/studio-b12/gowebdav/blob/master/auth.go?s=5300:5353#L148)
 ``` go
 func NewPreemptiveAuth(auth Authenticator) Authorizer
 ```
 NewPreemptiveAuth creates a preemptive Authenticator
 The preemptive authorizer uses the provided Authenticator
 for every request regardless of any `Www-Authenticate` header.
 It may only have one authentication method,
 so calling `AddAuthenticator` **will panic**!
 Look out!! This offers the skinniest and slickest implementation
 without any synchronisation!!
 Still applicable with `BasicAuth` within go routines.
 ### <a name="BasicAuth">type</a> [BasicAuth](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=94:145#L9)
 ``` go
 type BasicAuth struct {
    // contains filtered or unexported fields
 }
 ```
 BasicAuth structure holds our credentials
 #### <a name="BasicAuth.Authorize">func</a> (\*BasicAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=180:262#L15)
 ``` go
 func (b *BasicAuth) Authorize(c *http.Client, rq *http.Request, path string) error
 ```
 Authorize the current request
 #### <a name="BasicAuth.Clone">func</a> (\*BasicAuth) [Clone](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=666:707#L34)
 ``` go
 func (b *BasicAuth) Clone() Authenticator
 ```
 Clone creates a Copy of itself
 #### <a name="BasicAuth.Close">func</a> (\*BasicAuth) [Close](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=581:614#L29)
 ``` go
 func (b *BasicAuth) Close() error
 ```
 Close cleans up all resources
 #### <a name="BasicAuth.String">func</a> (\*BasicAuth) [String](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=778:813#L40)
 ``` go
 func (b *BasicAuth) String() string
 ```
 String toString
 #### <a name="BasicAuth.Verify">func</a> (\*BasicAuth) [Verify](https://github.com/studio-b12/gowebdav/blob/master/basicAuth.go?s=352:449#L21)
 ``` go
 func (b *BasicAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)
 ```
 Verify verifies if the authentication
 ### <a name="Client">type</a> [Client](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=220:388#L19)
 ``` go
 type Client struct {
    // contains filtered or unexported fields
 }
 ```
 Client defines our structure
 #### <a name="NewAuthClient">func</a> [NewAuthClient](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=608:663#L33)
 ``` go
 func NewAuthClient(uri string, auth Authorizer) *Client
 ```
 NewAuthClient creates a new client instance with a custom Authorizer
 #### <a name="NewClient">func</a> [NewClient](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=436:480#L28)
 ``` go
 func NewClient(uri, user, pw string) *Client
 ```
 NewClient creates a new instance of client
 #### <a name="Client.Connect">func</a> (\*Client) [Connect](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1829:1861#L74)
 ``` go
 func (c *Client) Connect() error
 ```
 Connect connects to our dav server
 #### <a name="Client.Copy">func</a> (\*Client) [Copy](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6815:6883#L310)
 ``` go
 func (c *Client) Copy(oldpath, newpath string, overwrite bool) error
 ```
 Copy copies a file from A to B
 #### <a name="Client.Mkdir">func</a> (\*Client) [Mkdir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5790:5852#L259)
 ``` go
 func (c *Client) Mkdir(path string, _ os.FileMode) (err error)
 ```
 Mkdir makes a directory
 #### <a name="Client.MkdirAll">func</a> (\*Client) [MkdirAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6065:6130#L273)
 ``` go
 func (c *Client) MkdirAll(path string, _ os.FileMode) (err error)
 ```
 MkdirAll like mkdir -p, but for webdav
 #### <a name="Client.Read">func</a> (\*Client) [Read](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6989:7039#L315)
 ``` go
 func (c *Client) Read(path string) ([]byte, error)
 ```
 Read reads the contents of a remote file
 #### <a name="Client.ReadDir">func</a> (\*Client) [ReadDir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=2855:2915#L117)
 ``` go
 func (c *Client) ReadDir(path string) ([]os.FileInfo, error)
 ```
 ReadDir reads the contents of a remote directory
 #### <a name="Client.ReadStream">func</a> (\*Client) [ReadStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=7350:7413#L333)
 ``` go
 func (c *Client) ReadStream(path string) (io.ReadCloser, error)
 ```
 ReadStream reads the stream for a given path
 #### <a name="Client.ReadStreamRange">func</a> (\*Client) [ReadStreamRange](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=8162:8252#L355)
 ``` 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`.
 #### <a name="Client.Remove">func</a> (\*Client) [Remove](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5296:5338#L236)
 ``` go
 func (c *Client) Remove(path string) error
 ```
 Remove removes a remote file
 #### <a name="Client.RemoveAll">func</a> (\*Client) [RemoveAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5404:5449#L241)
 ``` go
 func (c *Client) RemoveAll(path string) error
 ```
 RemoveAll removes remote files
 #### <a name="Client.Rename">func</a> (\*Client) [Rename](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6649:6719#L305)
 ``` go
 func (c *Client) Rename(oldpath, newpath string, overwrite bool) error
 ```
 Rename moves a file from A to B
 #### <a name="Client.SetHeader">func</a> (\*Client) [SetHeader](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1092:1137#L49)
 ``` go
 func (c *Client) SetHeader(key, value string)
 ```
 SetHeader lets us set arbitrary headers for a given client
 #### <a name="Client.SetInterceptor">func</a> (\*Client) [SetInterceptor](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1244:1326#L54)
 ``` go
 func (c *Client) SetInterceptor(interceptor func(method string, rq *http.Request))
 ```
 SetInterceptor lets us set an arbitrary interceptor for a given client
 #### <a name="Client.SetJar">func</a> (\*Client) [SetJar](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1727:1770#L69)
 ``` go
 func (c *Client) SetJar(jar http.CookieJar)
 ```
 SetJar exposes the ability to set a cookie jar to the client.
 #### <a name="Client.SetTimeout">func</a> (\*Client) [SetTimeout](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1428:1478#L59)
 ``` go
 func (c *Client) SetTimeout(timeout time.Duration)
 ```
 SetTimeout exposes the ability to set a time limit for requests
 #### <a name="Client.SetTransport">func</a> (\*Client) [SetTransport](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=1571:1629#L64)
 ``` go
 func (c *Client) SetTransport(transport http.RoundTripper)
 ```
 SetTransport exposes the ability to define custom transports
 #### <a name="Client.Stat">func</a> (\*Client) [Stat](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=4241:4296#L184)
 ``` go
 func (c *Client) Stat(path string) (os.FileInfo, error)
 ```
 Stat returns the file stats for a specified path
 #### <a name="Client.Write">func</a> (\*Client) [Write](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=9272:9347#L389)
 ``` go
 func (c *Client) Write(path string, data []byte, _ os.FileMode) (err error)
 ```
 Write writes data to a given path
 #### <a name="Client.WriteStream">func</a> (\*Client) [WriteStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=9771:9857#L419)
 ``` go
 func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) (err error)
 ```
 WriteStream writes a stream
 ### <a name="DigestAuth">type</a> [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
 #### <a name="DigestAuth.Authorize">func</a> (\*DigestAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=525:608#L26)
 ``` go
 func (d *DigestAuth) Authorize(c *http.Client, rq *http.Request, path string) error
 ```
 Authorize the current request
 #### <a name="DigestAuth.Clone">func</a> (\*DigestAuth) [Clone](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=1228:1270#L49)
 ``` go
 func (d *DigestAuth) Clone() Authenticator
 ```
 Clone creates a copy of itself
 #### <a name="DigestAuth.Close">func</a> (\*DigestAuth) [Close](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=1142:1176#L44)
 ``` go
 func (d *DigestAuth) Close() error
 ```
 Close cleans up all resources
 #### <a name="DigestAuth.String">func</a> (\*DigestAuth) [String](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=1466:1502#L58)
 ``` go
 func (d *DigestAuth) String() string
 ```
 String toString
 #### <a name="DigestAuth.Verify">func</a> (\*DigestAuth) [Verify](https://github.com/studio-b12/gowebdav/blob/master/digestAuth.go?s=912:1010#L36)
 ``` go
 func (d *DigestAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)
 ```
 Verify checks for authentication issues and may trigger a re-authentication
 ### <a name="File">type</a> [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
 #### <a name="File.ContentType">func</a> (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
 #### <a name="File.ETag">func</a> (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
 #### <a name="File.IsDir">func</a> (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
 #### <a name="File.ModTime">func</a> (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
 #### <a name="File.Mode">func</a> (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
 #### <a name="File.Name">func</a> (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
 #### <a name="File.Path">func</a> (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
 #### <a name="File.Size">func</a> (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
 #### <a name="File.String">func</a> (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
 #### <a name="File.Sys">func</a> (File) [Sys](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=1095:1126#L66)
 ``` go
 func (f File) Sys() interface{}
 ```
 Sys ????
 ### <a name="PassportAuth">type</a> [PassportAuth](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=125:254#L12)
 ``` go
 type PassportAuth struct {
    // contains filtered or unexported fields
 }
 ```
 PassportAuth structure holds our credentials
 #### <a name="PassportAuth.Authorize">func</a> (\*PassportAuth) [Authorize](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=690:775#L32)
 ``` go
 func (p *PassportAuth) Authorize(c *http.Client, rq *http.Request, path string) error
 ```
 Authorize the current request
 #### <a name="PassportAuth.Clone">func</a> (\*PassportAuth) [Clone](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=1701:1745#L69)
 ``` go
 func (p *PassportAuth) Clone() Authenticator
 ```
 Clone creates a Copy of itself
 #### <a name="PassportAuth.Close">func</a> (\*PassportAuth) [Close](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=1613:1649#L64)
 ``` go
 func (p *PassportAuth) Close() error
 ```
 Close cleans up all resources
 #### <a name="PassportAuth.String">func</a> (\*PassportAuth) [String](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=2048:2086#L83)
 ``` go
 func (p *PassportAuth) String() string
 ```
 String toString
 #### <a name="PassportAuth.Verify">func</a> (\*PassportAuth) [Verify](https://github.com/studio-b12/gowebdav/blob/master/passportAuth.go?s=1075:1175#L46)
 ``` go
 func (p *PassportAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)
 ```
 Verify verifies if the authentication is good
 ### <a name="StatusError">type</a> [StatusError](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=499:538#L18)
 ``` go
 type StatusError struct {
    Status int
 }
 ```
 StatusError implements error and wraps
 an erroneous status code.
 #### <a name="StatusError.Error">func</a> (StatusError) [Error](https://github.com/studio-b12/gowebdav/blob/master/errors.go?s=540:576#L22)
 ``` go
 func (se StatusError) Error() string
 ```
 - - -
 Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md)
--- a/auth.go
+++ b/auth.go
@ -1,409 +0,0 @@
 package gowebdav
 import (
 	"bytes"
 	"errors"
 	"io"
 	"net/http"
 	"strings"
 	"sync"
 )
 // AuthFactory prototype function to create a new Authenticator
 type AuthFactory func(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error)
 // Authorizer our Authenticator factory which creates an
 // `Authenticator` per action/request.
 type Authorizer interface {
 	// Creates a new Authenticator Shim per request.
 	// It may track request related states and perform payload buffering
 	// for authentication round trips.
 	// The underlying Authenticator will perform the real authentication.
 	NewAuthenticator(body io.Reader) (Authenticator, io.Reader)
 	// Registers a new Authenticator factory to a key.
 	AddAuthenticator(key string, fn AuthFactory)
 }
 // A Authenticator implements a specific way to authorize requests.
 // Each request is bound to a separate Authenticator instance.
 //
 // The authentication flow itself is broken down into `Authorize`
 // and `Verify` steps. The former method runs before, and the latter
 // runs after the `Request` is submitted.
 // This makes it easy to encapsulate and control complex
 // authentication challenges.
 //
 // Some authentication flows causing authentication round trips,
 // which can be archived by returning the `redo` of the Verify
 // method. `True` restarts the authentication process for the
 // current action: A new `Request` is spawned, which must be
 // authorized, sent, and re-verified again, until the action
 // is successfully submitted.
 // The preferred way is to handle the authentication ping-pong
 // within `Verify`, and then `redo` with fresh credentials.
 //
 // The result of the `Verify` method can also trigger an
 // `Authenticator` change by returning the `ErrAuthChanged`
 // as an error. Depending on the `Authorizer` this may trigger
 // an `Authenticator` negotiation.
 //
 // Set the `XInhibitRedirect` header to '1' in the `Authorize`
 // method to get control over request redirection.
 // Attention! You must handle the incoming request yourself.
 //
 // To store a shared session state the `Clone` method **must**
 // return a new instance, initialized with the shared state.
 type Authenticator interface {
 	// Authorizes a request. Usually by adding some authorization headers.
 	Authorize(c *http.Client, rq *http.Request, path string) error
 	// Verifies the response if the authorization was successful.
 	// May trigger some round trips to pass the authentication.
 	// May also trigger a new Authenticator negotiation by returning `ErrAuthChenged`
 	Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error)
 	// Creates a copy of the underlying Authenticator.
 	Clone() Authenticator
 	io.Closer
 }
 type authfactory struct {
 	key    string
 	create AuthFactory
 }
 // authorizer structure holds our Authenticator create functions
 type authorizer struct {
 	factories  []authfactory
 	defAuthMux sync.Mutex
 	defAuth    Authenticator
 }
 // preemptiveAuthorizer structure holds the preemptive Authenticator
 type preemptiveAuthorizer struct {
 	auth Authenticator
 }
 // authShim structure that wraps the real Authenticator
 type authShim struct {
 	factory AuthFactory
 	body    io.Reader
 	auth    Authenticator
 }
 // negoAuth structure holds the authenticators that are going to be negotiated
 type negoAuth struct {
 	auths                   []Authenticator
 	setDefaultAuthenticator func(auth Authenticator)
 }
 // nullAuth initializes the whole authentication flow
 type nullAuth struct{}
 // noAuth structure to perform no authentication at all
 type noAuth struct{}
 // NewAutoAuth creates an auto Authenticator factory.
 // It negotiates the default authentication method
 // based on the order of the registered Authenticators
 // and the remotely offered authentication methods.
 // First In, First Out.
 func NewAutoAuth(login string, secret string) Authorizer {
 	fmap := make([]authfactory, 0)
 	az := &authorizer{factories: fmap, defAuthMux: sync.Mutex{}, defAuth: &nullAuth{}}
 	az.AddAuthenticator("basic", func(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error) {
 		return &BasicAuth{user: login, pw: secret}, nil
 	})
 	az.AddAuthenticator("digest", func(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error) {
 		return NewDigestAuth(login, secret, rs)
 	})
 	az.AddAuthenticator("passport1.4", func(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error) {
 		return NewPassportAuth(c, login, secret, rs.Request.URL.String(), &rs.Header)
 	})
 	return az
 }
 // NewEmptyAuth creates an empty Authenticator factory
 // The order of adding the Authenticator matters.
 // First In, First Out.
 // It offers the `NewAutoAuth` features.
 func NewEmptyAuth() Authorizer {
 	fmap := make([]authfactory, 0)
 	az := &authorizer{factories: fmap, defAuthMux: sync.Mutex{}, defAuth: &nullAuth{}}
 	return az
 }
 // NewPreemptiveAuth creates a preemptive Authenticator
 // The preemptive authorizer uses the provided Authenticator
 // for every request regardless of any `Www-Authenticate` header.
 //
 // It may only have one authentication method,
 // so calling `AddAuthenticator` **will panic**!
 //
 // Look out!! This offers the skinniest and slickest implementation
 // without any synchronisation!!
 // Still applicable with `BasicAuth` within go routines.
 func NewPreemptiveAuth(auth Authenticator) Authorizer {
 	return &preemptiveAuthorizer{auth: auth}
 }
 // NewAuthenticator creates an Authenticator (Shim) per request
 func (a *authorizer) NewAuthenticator(body io.Reader) (Authenticator, io.Reader) {
 	var retryBuf io.Reader = body
 	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 _, ok := retryBuf.(io.Seeker); ok {
 			body = io.NopCloser(body)
 		} else {
 			buff := &bytes.Buffer{}
 			retryBuf = buff
 			body = io.TeeReader(body, buff)
 		}
 	}
 	a.defAuthMux.Lock()
 	defAuth := a.defAuth.Clone()
 	a.defAuthMux.Unlock()
 	return &authShim{factory: a.factory, body: retryBuf, auth: defAuth}, body
 }
 // AddAuthenticator appends the AuthFactory to our factories.
 // It converts the key to lower case and preserves the order.
 func (a *authorizer) AddAuthenticator(key string, fn AuthFactory) {
 	key = strings.ToLower(key)
 	for _, f := range a.factories {
 		if f.key == key {
 			panic("Authenticator exists: " + key)
 		}
 	}
 	a.factories = append(a.factories, authfactory{key, fn})
 }
 // factory picks all valid Authenticators based on Www-Authenticate headers
 func (a *authorizer) factory(c *http.Client, rs *http.Response, path string) (auth Authenticator, err error) {
 	headers := rs.Header.Values("Www-Authenticate")
 	if len(headers) > 0 {
 		auths := make([]Authenticator, 0)
 		for _, f := range a.factories {
 			for _, header := range headers {
 				headerLower := strings.ToLower(header)
 				if strings.Contains(headerLower, f.key) {
 					rs.Header.Set("Www-Authenticate", header)
 					if auth, err = f.create(c, rs, path); err == nil {
 						auths = append(auths, auth)
 						break
 					}
 				}
 			}
 		}
 		switch len(auths) {
 		case 0:
 			return nil, NewPathError("NoAuthenticator", path, rs.StatusCode)
 		case 1:
 			auth = auths[0]
 		default:
 			auth = &negoAuth{auths: auths, setDefaultAuthenticator: a.setDefaultAuthenticator}
 		}
 	} else {
 		auth = &noAuth{}
 	}
 	a.setDefaultAuthenticator(auth)
 	return auth, nil
 }
 // setDefaultAuthenticator sets the default Authenticator
 func (a *authorizer) setDefaultAuthenticator(auth Authenticator) {
 	a.defAuthMux.Lock()
 	a.defAuth.Close()
 	a.defAuth = auth
 	a.defAuthMux.Unlock()
 }
 // Authorize the current request
 func (s *authShim) Authorize(c *http.Client, rq *http.Request, path string) error {
 	if err := s.auth.Authorize(c, rq, path); err != nil {
 		return err
 	}
 	body := s.body
 	rq.GetBody = func() (io.ReadCloser, error) {
 		if body != nil {
 			if sk, ok := body.(io.Seeker); ok {
 				if _, err := sk.Seek(0, io.SeekStart); err != nil {
 					return nil, err
 				}
 			}
 			return io.NopCloser(body), nil
 		}
 		return nil, nil
 	}
 	return nil
 }
 // Verify checks for authentication issues and may trigger a re-authentication.
 // Catches AlgoChangedErr to update the current Authenticator
 func (s *authShim) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	redo, err = s.auth.Verify(c, rs, path)
 	if err != nil && errors.Is(err, ErrAuthChanged) {
 		if auth, aerr := s.factory(c, rs, path); aerr == nil {
 			s.auth.Close()
 			s.auth = auth
 			return true, nil
 		} else {
 			return false, aerr
 		}
 	}
 	return
 }
 // Close closes all resources
 func (s *authShim) Close() error {
 	s.auth.Close()
 	s.auth, s.factory = nil, nil
 	if s.body != nil {
 		if closer, ok := s.body.(io.Closer); ok {
 			return closer.Close()
 		}
 	}
 	return nil
 }
 // It's not intend to Clone the shim
 // therefore it returns a noAuth instance
 func (s *authShim) Clone() Authenticator {
 	return &noAuth{}
 }
 // String toString
 func (s *authShim) String() string {
 	return "AuthShim"
 }
 // Authorize authorizes the current request with the top most Authorizer
 func (n *negoAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	if len(n.auths) == 0 {
 		return NewPathError("NoAuthenticator", path, 400)
 	}
 	return n.auths[0].Authorize(c, rq, path)
 }
 // Verify verifies the authentication and selects the next one based on the result
 func (n *negoAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	if len(n.auths) == 0 {
 		return false, NewPathError("NoAuthenticator", path, 400)
 	}
 	redo, err = n.auths[0].Verify(c, rs, path)
 	if err != nil {
 		if len(n.auths) > 1 {
 			n.auths[0].Close()
 			n.auths = n.auths[1:]
 			return true, nil
 		}
 	} else if redo {
 		return
 	} else {
 		auth := n.auths[0]
 		n.auths = n.auths[1:]
 		n.setDefaultAuthenticator(auth)
 		return
 	}
 	return false, NewPathError("NoAuthenticator", path, rs.StatusCode)
 }
 // Close will close the underlying authenticators.
 func (n *negoAuth) Close() error {
 	for _, a := range n.auths {
 		a.Close()
 	}
 	n.setDefaultAuthenticator = nil
 	return nil
 }
 // Clone clones the underlying authenticators.
 func (n *negoAuth) Clone() Authenticator {
 	auths := make([]Authenticator, len(n.auths))
 	for i, e := range n.auths {
 		auths[i] = e.Clone()
 	}
 	return &negoAuth{auths: auths, setDefaultAuthenticator: n.setDefaultAuthenticator}
 }
 func (n *negoAuth) String() string {
 	return "NegoAuth"
 }
 // Authorize the current request
 func (n *noAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	return nil
 }
 // Verify checks for authentication issues and may trigger a re-authentication
 func (n *noAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	if "" != rs.Header.Get("Www-Authenticate") {
 		err = ErrAuthChanged
 	}
 	return
 }
 // Close closes all resources
 func (n *noAuth) Close() error {
 	return nil
 }
 // Clone creates a copy of itself
 func (n *noAuth) Clone() Authenticator {
 	// no copy due to read only access
 	return n
 }
 // String toString
 func (n *noAuth) String() string {
 	return "NoAuth"
 }
 // Authorize the current request
 func (n *nullAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	rq.Header.Set(XInhibitRedirect, "1")
 	return nil
 }
 // Verify checks for authentication issues and may trigger a re-authentication
 func (n *nullAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	return true, ErrAuthChanged
 }
 // Close closes all resources
 func (n *nullAuth) Close() error {
 	return nil
 }
 // Clone creates a copy of itself
 func (n *nullAuth) Clone() Authenticator {
 	// no copy due to read only access
 	return n
 }
 // String toString
 func (n *nullAuth) String() string {
 	return "NullAuth"
 }
 // NewAuthenticator creates an Authenticator (Shim) per request
 func (b *preemptiveAuthorizer) NewAuthenticator(body io.Reader) (Authenticator, io.Reader) {
 	return b.auth.Clone(), body
 }
 // AddAuthenticator Will PANIC because it may only have a single authentication method
 func (b *preemptiveAuthorizer) AddAuthenticator(key string, fn AuthFactory) {
 	panic("You're funny! A preemptive authorizer may only have a single authentication method")
 }
--- a/auth_test.go
+++ b/auth_test.go
@ -1,62 +0,0 @@
 package gowebdav
 import (
 	"bytes"
 	"net/http"
 	"strings"
 	"testing"
 )
 func TestEmptyAuth(t *testing.T) {
 	auth := NewEmptyAuth()
 	srv, _, _ := newAuthSrv(t, basicAuth)
 	defer srv.Close()
 	cli := NewAuthClient(srv.URL, auth)
 	if err := cli.Connect(); err == nil {
 		t.Fatalf("got nil want error")
 	}
 }
 func TestRedirectAuthWIP(t *testing.T) {
 	hasPassedAuthServer := false
 	authHandler := func(h http.Handler) http.HandlerFunc {
 		return func(w http.ResponseWriter, r *http.Request) {
 			if user, passwd, ok := r.BasicAuth(); ok {
 				if user == "user" && passwd == "password" {
 					hasPassedAuthServer = true
 					w.WriteHeader(200)
 					return
 				}
 			}
 			w.Header().Set("Www-Authenticate", `Basic realm="x"`)
 			w.WriteHeader(401)
 		}
 	}
 	psrv, _, _ := newAuthSrv(t, authHandler)
 	defer psrv.Close()
 	dataHandler := func(h http.Handler) http.HandlerFunc {
 		return func(w http.ResponseWriter, r *http.Request) {
 			hasAuth := strings.Contains(r.Header.Get("Authorization"), "Basic dXNlcjpwYXNzd29yZA==")
 			if hasPassedAuthServer && hasAuth {
 				h.ServeHTTP(w, r)
 				return
 			}
 			w.Header().Set("Www-Authenticate", `Basic realm="x"`)
 			http.Redirect(w, r, psrv.URL+"/", 302)
 		}
 	}
 	srv, _, _ := newAuthSrv(t, dataHandler)
 	defer srv.Close()
 	cli := NewClient(srv.URL, "user", "password")
 	data, err := cli.Read("/hello.txt")
 	if err != nil {
 		t.Logf("WIP got error=%v; want nil", err)
 	}
 	if bytes.Compare(data, []byte("hello gowebdav\n")) != 0 {
 		t.Logf("WIP got data=%v; want=hello gowebdav", data)
 	}
 }
--- a/basicAuth.go
+++ b/basicAuth.go
@ -1,47 +0,0 @@
 package gowebdav
 import (
 	"fmt"
 	"net/http"
 )
 // BasicAuth structure holds our credentials
 type BasicAuth struct {
 	user string
 	pw   string
 }
 // NewDigestAuth creates a new instance of our Digest Authenticator
 func NewBasicAuth(login, secret string) (Authenticator, error) {
 	return &BasicAuth{user: login, pw: secret}, nil
 }
 // Authorize the current request
 func (b *BasicAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	rq.SetBasicAuth(b.user, b.pw)
 	return nil
 }
 // Verify verifies if the authentication
 func (b *BasicAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	if rs.StatusCode == 401 {
 		err = NewPathError("Authorize", path, rs.StatusCode)
 	}
 	return
 }
 // Close cleans up all resources
 func (b *BasicAuth) Close() error {
 	return nil
 }
 // Clone creates a Copy of itself
 func (b *BasicAuth) Clone() Authenticator {
 	// no copy due to read only access
 	return b
 }
 // String toString
 func (b *BasicAuth) String() string {
 	return fmt.Sprintf("BasicAuth login: %s", b.user)
 }
--- a/basicAuth_test.go
+++ b/basicAuth_test.go
@ -1,51 +0,0 @@
 package gowebdav
 import (
 	"net/http"
 	"testing"
 )
 func TestNewBasicAuth(t *testing.T) {
 	a := &BasicAuth{user: "user", pw: "password"}
 	ex := "BasicAuth login: user"
 	if a.String() != ex {
 		t.Error("expected: " + ex + " got: " + a.String())
 	}
 	if a.Clone() != a {
 		t.Error("expected the same instance")
 	}
 	if a.Close() != nil {
 		t.Error("expected close without errors")
 	}
 }
 func TestBasicAuthAuthorize(t *testing.T) {
 	a := &BasicAuth{user: "user", pw: "password"}
 	rq, _ := http.NewRequest("GET", "http://localhost/", nil)
 	a.Authorize(nil, rq, "/")
 	if rq.Header.Get("Authorization") != "Basic dXNlcjpwYXNzd29yZA==" {
 		t.Error("got wrong Authorization header: " + rq.Header.Get("Authorization"))
 	}
 }
 func TestPreemtiveBasicAuth(t *testing.T) {
 	a := &BasicAuth{user: "user", pw: "password"}
 	auth := NewPreemptiveAuth(a)
 	n, b := auth.NewAuthenticator(nil)
 	if b != nil {
 		t.Error("expected body to be nil")
 	}
 	if n != a {
 		t.Error("expected the same instance")
 	}
 	srv, _, _ := newAuthSrv(t, basicAuth)
 	defer srv.Close()
 	cli := NewAuthClient(srv.URL, auth)
 	if err := cli.Connect(); err != nil {
 		t.Fatalf("got error: %v, want nil", err)
 	}
 }
--- a/client.go
+++ b/client.go
@ -2,103 +2,56 @@ package gowebdav
 import (
 	"bytes"
 	"encoding/base64"
 	"encoding/xml"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"os"
 	pathpkg "path"
 	"strings"
 	"time"
 )
 const XInhibitRedirect = "X-Gowebdav-Inhibit-Redirect"
 // Client defines our structure
 type Client struct {
-	root        string
+	root    string
-	headers     http.Header
+	headers http.Header
-	interceptor func(method string, rq *http.Request)
+	c       *http.Client
 	c           *http.Client
 	auth        Authorizer
 }
-// NewClient creates a new instance of client
+func NewClient(uri string, user string, pw string) *Client {
-func NewClient(uri, user, pw string) *Client {
+	c := &Client{uri, make(http.Header), &http.Client{}}
 	return NewAuthClient(uri, NewAutoAuth(user, pw))
 }
-// NewAuthClient creates a new client instance with a custom Authorizer
+	if len(user) > 0 && len(pw) > 0 {
-func NewAuthClient(uri string, auth Authorizer) *Client {
+		a := user + ":" + pw
-	c := &http.Client{
+		auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(a))
-		CheckRedirect: func(rq *http.Request, via []*http.Request) error {
+		c.headers.Add("Authorization", auth)
 			if len(via) >= 10 {
 				return ErrTooManyRedirects
 			}
 			if via[0].Header.Get(XInhibitRedirect) != "" {
 				return http.ErrUseLastResponse
 			}
 			return nil
 		},
 	}
-	return &Client{root: FixSlash(uri), headers: make(http.Header), interceptor: nil, c: c, auth: auth}
+
 	c.root = FixSlash(c.root)
 	return c
 }
 // 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
 }
 // SetJar exposes the ability to set a cookie jar to the client.
 func (c *Client) SetJar(jar http.CookieJar) {
 	c.c.Jar = jar
 }
 // Connect connects to our dav server
 func (c *Client) Connect() error {
 	rs, err := c.options("/")
-	if err != nil {
+	if err == nil {
-		return err
+		rs.Body.Close()
 	}
-	err = rs.Body.Close()
+		if rs.StatusCode != 200 || (rs.Header.Get("Dav") == "" && rs.Header.Get("DAV") == "") {
-	if err != nil {
+			return newPathError("Connect", c.root, rs.StatusCode)
-		return err
+		}
 	}
-	if rs.StatusCode != 200 {
+		_, err = c.ReadDir("/")
 		return NewPathError("Connect", c.root, rs.StatusCode)
 	}
-
+	return err
 	return nil
 }
 type props struct {
-	Status      string   `xml:"DAV: status"`
+	Status   string   `xml:"DAV: status"`
-	Name        string   `xml:"DAV: prop>displayname,omitempty"`
+	Name     string   `xml:"DAV: prop>displayname,omitempty"`
-	Type        xml.Name `xml:"DAV: prop>resourcetype>collection,omitempty"`
+	Type     xml.Name `xml:"DAV: prop>resourcetype>collection,omitempty"`
-	Size        string   `xml:"DAV: prop>getcontentlength,omitempty"`
+	Size     string   `xml:"DAV: prop>getcontentlength,omitempty"`
-	ContentType string   `xml:"DAV: prop>getcontenttype,omitempty"`
+	Modified string   `xml:"DAV: prop>getlastmodified,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"`
@ -106,14 +59,13 @@ type response struct {
 func getProps(r *response, status string) *props {
 	for _, prop := range r.Props {
-		if strings.Contains(prop.Status, status) {
+		if strings.Index(prop.Status, status) != -1 {
 			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)
@ -127,27 +79,22 @@ func (c *Client) ReadDir(path string) ([]os.FileInfo, error) {
 				r.Props = nil
 				return nil
 			}
-			return NewPathError("ReadDir", path, 405)
+			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 = p.Name
 				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.modified = time.Unix(0, 0)
 				f.isdir = true
 			} else {
 				f.size = parseInt64(&p.Size)
 				f.modified = parseModified(&p.Modified)
 				f.isdir = false
 			}
@ -164,8 +111,6 @@ func (c *Client) ReadDir(path string) ([]os.FileInfo, error) {
 				<d:displayname/>
 				<d:resourcetype/>
 				<d:getcontentlength/>
 				<d:getcontenttype/>
 				<d:getetag/>
 				<d:getlastmodified/>
 			</d:prop>
 		</d:propfind>`,
@ -174,30 +119,27 @@ func (c *Client) ReadDir(path string) ([]os.FileInfo, error) {
 	if err != nil {
 		if _, ok := err.(*os.PathError); !ok {
-			err = NewPathErrorErr("ReadDir", path, err)
+			err = &os.PathError{"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
+	var f *File = nil
 	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 = parseModified(&p.Modified)
+				f.modified = time.Unix(0, 0)
 				f.isdir = true
 			} else {
 				f.size = parseInt64(&p.Size)
@ -216,8 +158,6 @@ func (c *Client) Stat(path string) (os.FileInfo, error) {
 				<d:displayname/>
 				<d:resourcetype/>
 				<d:getcontentlength/>
 				<d:getcontenttype/>
 				<d:getetag/>
 				<d:getlastmodified/>
 			</d:prop>
 		</d:propfind>`,
@ -226,60 +166,46 @@ func (c *Client) Stat(path string) (os.FileInfo, error) {
 	if err != nil {
 		if _, ok := err.(*os.PathError); !ok {
-			err = NewPathErrorErr("ReadDir", path, err)
+			err = &os.PathError{"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)
+		return newPathError("Remove", path, 400)
 	}
 	err = rs.Body.Close()
 	if err != nil {
 		return err
 	}
 	rs.Body.Close()
-	if rs.StatusCode == 200 || rs.StatusCode == 204 || rs.StatusCode == 404 {
+	if rs.StatusCode == 200 || rs.StatusCode == 404 {
 		return nil
 	} else {
 		return newPathError("Remove", path, rs.StatusCode)
 	}
 	return NewPathError("Remove", path, rs.StatusCode)
 }
-// Mkdir makes a directory
+func (c *Client) Mkdir(path string, _ os.FileMode) error {
 func (c *Client) Mkdir(path string, _ os.FileMode) (err error) {
 	path = FixSlashes(path)
-	status, err := c.mkcol(path)
+	status := c.mkcol(path)
 	if err != nil {
 		return
 	}
 	if status == 201 {
 		return nil
 	} else {
 		return newPathError("Mkdir", path, status)
 	}
 	return NewPathError("Mkdir", path, status)
 }
-// MkdirAll like mkdir -p, but for webdav
+func (c *Client) MkdirAll(path string, _ os.FileMode) error {
 func (c *Client) MkdirAll(path string, _ os.FileMode) (err error) {
 	path = FixSlashes(path)
-	status, err := c.mkcol(path)
+	status := c.mkcol(path)
 	if err != nil {
 		return
 	}
 	if status == 201 {
 		return nil
-	}
+	} else if status == 409 {
 	if status == 409 {
 		paths := strings.Split(path, "/")
 		sub := "/"
 		for _, e := range paths {
@ -287,152 +213,75 @@ func (c *Client) MkdirAll(path string, _ os.FileMode) (err error) {
 				continue
 			}
 			sub += e + "/"
-			status, err = c.mkcol(sub)
+			status = c.mkcol(sub)
 			if err != nil {
 				return
 			}
 			if status != 201 {
-				return NewPathError("MkdirAll", sub, status)
+				return newPathError("MkdirAll", sub, status)
 			}
 		}
 		return nil
 	}
-	return NewPathError("MkdirAll", path, status)
+	return newPathError("MkdirAll", path, status)
 }
-// Rename moves a file from A to B
+func (c *Client) Rename(oldpath string, newpath string, overwrite bool) error {
 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 string, newpath string, overwrite bool) error {
 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
+	if stream, err := c.ReadStream(path); err == nil {
-	var err error
+		defer stream.Close()
-
+		buf := new(bytes.Buffer)
-	if stream, err = c.ReadStream(path); err != nil {
+		buf.ReadFrom(stream)
 		return buf.Bytes(), nil
 	} else {
 		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) (io.ReadCloser, error) {
 	rs, err := c.req("GET", path, nil, nil)
 	if err != nil {
-		return nil, NewPathErrorErr("ReadStream", path, err)
+		return nil, newPathErrorErr("ReadStream", path, err)
 	}
-
+	return rs.Body, nil
 	if rs.StatusCode == 200 {
 		return rs.Body, nil
 	}
 	rs.Body.Close()
 	return nil, NewPathError("ReadStream", path, rs.StatusCode)
 }
-// ReadStreamRange reads the stream representing a subset of bytes for a given path,
+func (c *Client) Write(path string, data []byte, _ os.FileMode) error {
-// utilizing HTTP Range Requests if the server supports it.
+	s := c.put(path, bytes.NewReader(data))
 // 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) {
 		if length > 0 {
 			r.Header.Add("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+length-1))
 		} else {
 			r.Header.Add("Range", fmt.Sprintf("bytes=%d-", offset))
 		}
 	})
 	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{rc: rs.Body, remaining: 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))
 	if err != nil {
 		return
 	}
 	switch s {
-	case 200, 201, 204:
+	case 200, 201:
 		return nil
-	case 404, 409:
+	case 409:
-		err = c.createParentCollection(path)
+		if idx := strings.LastIndex(path, "/"); idx == -1 {
-		if err != nil {
+			// faulty root
-			return
+			return newPathError("Write", path, 500)
-		}
+		} else {
-
+			if err := c.MkdirAll(path[0:idx+1], 0755); err == nil {
-		s, err = c.put(path, bytes.NewReader(data))
+				s = c.put(path, bytes.NewReader(data))
-		if err != nil {
+				if s == 200 || s == 201 {
-			return
+					return nil
-		}
+				}
-		if s == 200 || s == 201 || s == 204 {
+			}
 			return
 		}
 	}
-
+	return newPathError("Write", path, s)
 	return NewPathError("Write", path, s)
 }
-// WriteStream writes a stream
+func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error {
-func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) (err error) {
+	// TODO check if parent collection exists
-
+	s := c.put(path, stream)
 	err = c.createParentCollection(path)
 	if err != nil {
 		return err
 	}
 	s, err := c.put(path, stream)
 	if err != nil {
 		return err
 	}
 	switch s {
-	case 200, 201, 204:
+	case 200, 201:
 		return nil
 	default:
-		return NewPathError("WriteStream", path, s)
+		return newPathError("WriteStream", path, s)
 	}
 }
--- a/client_test.go
+++ b/client_test.go
@ -1,574 +0,0 @@
 package gowebdav
 import (
 	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"strings"
 	"sync"
 	"testing"
 	"time"
 	"golang.org/x/net/webdav"
 )
 func noAuthHndl(h http.Handler) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		h.ServeHTTP(w, r)
 	}
 }
 func basicAuth(h http.Handler) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		if user, passwd, ok := r.BasicAuth(); ok {
 			if user == "user" && passwd == "password" {
 				h.ServeHTTP(w, r)
 				return
 			}
 			http.Error(w, "not authorized", 403)
 		} else {
 			w.Header().Set("WWW-Authenticate", `Basic realm="x"`)
 			w.WriteHeader(401)
 		}
 	}
 }
 func multipleAuth(h http.Handler) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		notAuthed := false
 		if r.Header.Get("Authorization") == "" {
 			notAuthed = true
 		} else if user, passwd, ok := r.BasicAuth(); ok {
 			if user == "user" && passwd == "password" {
 				h.ServeHTTP(w, r)
 				return
 			}
 			notAuthed = true
 		} else if strings.HasPrefix(r.Header.Get("Authorization"), "Digest ") {
 			pairs := strings.TrimPrefix(r.Header.Get("Authorization"), "Digest ")
 			digestParts := make(map[string]string)
 			for _, pair := range strings.Split(pairs, ",") {
 				kv := strings.SplitN(strings.TrimSpace(pair), "=", 2)
 				key, value := kv[0], kv[1]
 				value = strings.Trim(value, `"`)
 				digestParts[key] = value
 			}
 			if digestParts["qop"] == "" {
 				digestParts["qop"] = "auth"
 			}
 			ha1 := getMD5(fmt.Sprint(digestParts["username"], ":", digestParts["realm"], ":", "digestPW"))
 			ha2 := getMD5(fmt.Sprint(r.Method, ":", digestParts["uri"]))
 			expected := getMD5(fmt.Sprint(ha1,
 				":", digestParts["nonce"],
 				":", digestParts["nc"],
 				":", digestParts["cnonce"],
 				":", digestParts["qop"],
 				":", ha2))
 			if expected == digestParts["response"] {
 				h.ServeHTTP(w, r)
 				return
 			}
 			notAuthed = true
 		}
 		if notAuthed {
 			w.Header().Add("WWW-Authenticate", `Digest realm="testrealm@host.com", qop="auth,auth-int",nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",opaque="5ccc069c403ebaf9f0171e9517f40e41"`)
 			w.Header().Add("WWW-Authenticate", `Basic realm="x"`)
 			w.WriteHeader(401)
 		}
 	}
 }
 func fillFs(t *testing.T, fs webdav.FileSystem) context.Context {
 	ctx := context.Background()
 	f, err := fs.OpenFile(ctx, "hello.txt", os.O_CREATE, 0644)
 	if err != nil {
 		t.Errorf("fail to crate file: %v", err)
 	}
 	f.Write([]byte("hello gowebdav\n"))
 	f.Close()
 	err = fs.Mkdir(ctx, "/test", 0755)
 	if err != nil {
 		t.Errorf("fail to crate directory: %v", err)
 	}
 	f, err = fs.OpenFile(ctx, "/test/test.txt", os.O_CREATE, 0644)
 	if err != nil {
 		t.Errorf("fail to crate file: %v", err)
 	}
 	f.Write([]byte("test test gowebdav\n"))
 	f.Close()
 	return ctx
 }
 func newServer(t *testing.T) (*Client, *httptest.Server, webdav.FileSystem, context.Context) {
 	return newAuthServer(t, basicAuth)
 }
 func newAuthServer(t *testing.T, auth func(h http.Handler) http.HandlerFunc) (*Client, *httptest.Server, webdav.FileSystem, context.Context) {
 	srv, fs, ctx := newAuthSrv(t, auth)
 	cli := NewClient(srv.URL, "user", "password")
 	return cli, srv, fs, ctx
 }
 func newAuthSrv(t *testing.T, auth func(h http.Handler) http.HandlerFunc) (*httptest.Server, webdav.FileSystem, context.Context) {
 	mux := http.NewServeMux()
 	fs := webdav.NewMemFS()
 	ctx := fillFs(t, fs)
 	mux.HandleFunc("/", auth(&webdav.Handler{
 		FileSystem: fs,
 		LockSystem: webdav.NewMemLS(),
 	}))
 	srv := httptest.NewServer(mux)
 	return srv, fs, ctx
 }
 func TestConnect(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	if err := cli.Connect(); err != nil {
 		t.Fatalf("got error: %v, want nil", err)
 	}
 	cli = NewClient(srv.URL, "no", "no")
 	if err := cli.Connect(); err == nil {
 		t.Fatalf("got nil, want error: %v", err)
 	}
 }
 func TestConnectMultipleAuth(t *testing.T) {
 	cli, srv, _, _ := newAuthServer(t, multipleAuth)
 	defer srv.Close()
 	if err := cli.Connect(); err != nil {
 		t.Fatalf("got error: %v, want nil", err)
 	}
 	cli = NewClient(srv.URL, "digestUser", "digestPW")
 	if err := cli.Connect(); err != nil {
 		t.Fatalf("got nil, want error: %v", err)
 	}
 	cli = NewClient(srv.URL, "no", "no")
 	if err := cli.Connect(); err == nil {
 		t.Fatalf("got nil, want error: %v", err)
 	}
 }
 func TestConnectMultiAuthII(t *testing.T) {
 	cli, srv, _, _ := newAuthServer(t, func(h http.Handler) http.HandlerFunc {
 		return func(w http.ResponseWriter, r *http.Request) {
 			if user, passwd, ok := r.BasicAuth(); ok {
 				if user == "user" && passwd == "password" {
 					h.ServeHTTP(w, r)
 					return
 				}
 				http.Error(w, "not authorized", 403)
 			} else {
 				w.Header().Add("WWW-Authenticate", `FooAuth`)
 				w.Header().Add("WWW-Authenticate", `BazAuth`)
 				w.Header().Add("WWW-Authenticate", `BarAuth`)
 				w.Header().Add("WWW-Authenticate", `Basic realm="x"`)
 				w.WriteHeader(401)
 			}
 		}
 	})
 	defer srv.Close()
 	if err := cli.Connect(); err != nil {
 		t.Fatalf("got error: %v, want nil", err)
 	}
 	cli = NewClient(srv.URL, "no", "no")
 	if err := cli.Connect(); err == nil {
 		t.Fatalf("got nil, want error: %v", err)
 	}
 }
 func TestReadDirConcurrent(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	var wg sync.WaitGroup
 	errs := make(chan error, 2)
 	for i := 0; i < 2; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			f, err := cli.ReadDir("/")
 			if err != nil {
 				errs <- errors.New(fmt.Sprintf("got error: %v, want file listing: %v", err, f))
 			}
 			if len(f) != 2 {
 				errs <- errors.New(fmt.Sprintf("f: %v err: %v", f, err))
 			}
 			if f[0].Name() != "hello.txt" && f[1].Name() != "hello.txt" {
 				errs <- errors.New(fmt.Sprintf("got: %v, want file: %s", f, "hello.txt"))
 			}
 			if f[0].Name() != "test" && f[1].Name() != "test" {
 				errs <- errors.New(fmt.Sprintf("got: %v, want directory: %s", f, "test"))
 			}
 		}()
 	}
 	wg.Wait()
 	close(errs)
 	for err := range errs {
 		if err != nil {
 			t.Fatal(err)
 		}
 	}
 }
 func TestRead(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	data, err := cli.Read("/hello.txt")
 	if err != nil || bytes.Compare(data, []byte("hello gowebdav\n")) != 0 {
 		t.Fatalf("got: %v, want data: %s", err, []byte("hello gowebdav\n"))
 	}
 	data, err = cli.Read("/404.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", data, err)
 	}
 	if !IsErrNotFound(err) {
 		t.Fatalf("got: %v, want 404 error", err)
 	}
 }
 func TestReadNoAuth(t *testing.T) {
 	cli, srv, _, _ := newAuthServer(t, noAuthHndl)
 	defer srv.Close()
 	data, err := cli.Read("/hello.txt")
 	if err != nil || bytes.Compare(data, []byte("hello gowebdav\n")) != 0 {
 		t.Fatalf("got: %v, want data: %s", err, []byte("hello gowebdav\n"))
 	}
 	data, err = cli.Read("/404.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", data, err)
 	}
 	if !IsErrNotFound(err) {
 		t.Fatalf("got: %v, want 404 error", err)
 	}
 }
 func TestReadStream(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	stream, err := cli.ReadStream("/hello.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want data: %v", err, stream)
 	}
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(stream)
 	if buf.String() != "hello gowebdav\n" {
 		t.Fatalf("got: %v, want stream: hello gowebdav", buf.String())
 	}
 	stream, err = cli.ReadStream("/404/hello.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", stream, err)
 	}
 }
 func TestReadStreamRange(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	stream, err := cli.ReadStreamRange("/hello.txt", 4, 4)
 	if err != nil {
 		t.Fatalf("got: %v, want data: %v", err, stream)
 	}
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(stream)
 	if buf.String() != "o go" {
 		t.Fatalf("got: %v, want stream: o go", buf.String())
 	}
 	stream, err = cli.ReadStream("/404/hello.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", stream, err)
 	}
 }
 func TestReadStreamRangeUnkownLength(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	stream, err := cli.ReadStreamRange("/hello.txt", 6, 0)
 	if err != nil {
 		t.Fatalf("got: %v, want data: %v", err, stream)
 	}
 	buf := new(bytes.Buffer)
 	buf.ReadFrom(stream)
 	if buf.String() != "gowebdav\n" {
 		t.Fatalf("got: %v, want stream: gowebdav\n", buf.String())
 	}
 	stream, err = cli.ReadStream("/404/hello.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", stream, err)
 	}
 }
 func TestStat(t *testing.T) {
 	cli, srv, _, _ := newServer(t)
 	defer srv.Close()
 	info, err := cli.Stat("/hello.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want os.Info: %v", err, info)
 	}
 	if info.Name() != "hello.txt" {
 		t.Fatalf("got: %v, want file hello.txt", info)
 	}
 	info, err = cli.Stat("/404.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if !IsErrNotFound(err) {
 		t.Fatalf("got: %v, want 404 error", err)
 	}
 }
 func TestMkdir(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	info, err := cli.Stat("/newdir")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.Mkdir("/newdir", 0755); err != nil {
 		t.Fatalf("got: %v, want mkdir /newdir", err)
 	}
 	if err := cli.Mkdir("/newdir", 0755); err != nil {
 		t.Fatalf("got: %v, want mkdir /newdir", err)
 	}
 	info, err = fs.Stat(ctx, "/newdir")
 	if err != nil {
 		t.Fatalf("got: %v, want dir info: %v", err, info)
 	}
 	if err := cli.Mkdir("/404/newdir", 0755); err == nil {
 		t.Fatalf("expected Mkdir error due to missing parent directory")
 	}
 }
 func TestMkdirAll(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	if err := cli.MkdirAll("/dir/dir/dir", 0755); err != nil {
 		t.Fatalf("got: %v, want mkdirAll /dir/dir/dir", err)
 	}
 	info, err := fs.Stat(ctx, "/dir/dir/dir")
 	if err != nil {
 		t.Fatalf("got: %v, want dir info: %v", err, info)
 	}
 }
 func TestCopy(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	info, err := fs.Stat(ctx, "/copy.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.Copy("/hello.txt", "/copy.txt", false); err != nil {
 		t.Fatalf("got: %v, want copy /hello.txt to /copy.txt", err)
 	}
 	info, err = fs.Stat(ctx, "/copy.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 15 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 15)
 	}
 	info, err = fs.Stat(ctx, "/hello.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 15 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 15)
 	}
 	if err := cli.Copy("/hello.txt", "/copy.txt", false); err == nil {
 		t.Fatalf("expected copy error due to overwrite false")
 	}
 	if err := cli.Copy("/hello.txt", "/copy.txt", true); err != nil {
 		t.Fatalf("got: %v, want overwrite /copy.txt with /hello.txt", err)
 	}
 }
 func TestRename(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	info, err := fs.Stat(ctx, "/copy.txt")
 	if err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.Rename("/hello.txt", "/copy.txt", false); err != nil {
 		t.Fatalf("got: %v, want mv /hello.txt to /copy.txt", err)
 	}
 	info, err = fs.Stat(ctx, "/copy.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 15 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 15)
 	}
 	if info, err = fs.Stat(ctx, "/hello.txt"); err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.Rename("/test/test.txt", "/copy.txt", true); err != nil {
 		t.Fatalf("got: %v, want overwrite /copy.txt with /hello.txt", err)
 	}
 	info, err = fs.Stat(ctx, "/copy.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 19 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 19)
 	}
 }
 func TestRemove(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	if err := cli.Remove("/hello.txt"); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	if info, err := fs.Stat(ctx, "/hello.txt"); err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.Remove("/404.txt"); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 }
 func TestRemoveAll(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	if err := cli.RemoveAll("/test/test.txt"); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	if info, err := fs.Stat(ctx, "/test/test.txt"); err == nil {
 		t.Fatalf("got: %v, want error: %v", info, err)
 	}
 	if err := cli.RemoveAll("/404.txt"); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	if err := cli.RemoveAll("/404/404/404.txt"); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 }
 func TestWrite(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	if err := cli.Write("/newfile.txt", []byte("foo bar\n"), 0660); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	info, err := fs.Stat(ctx, "/newfile.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 8 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 8)
 	}
 	if err := cli.Write("/404/newfile.txt", []byte("foo bar\n"), 0660); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 }
 func TestWriteStream(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	if err := cli.WriteStream("/newfile.txt", strings.NewReader("foo bar\n"), 0660); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	info, err := fs.Stat(ctx, "/newfile.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 8 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 8)
 	}
 	if err := cli.WriteStream("/404/works.txt", strings.NewReader("foo bar\n"), 0660); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	if info, err := fs.Stat(ctx, "/404/works.txt"); err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 }
 func TestWriteStreamFromPipe(t *testing.T) {
 	cli, srv, fs, ctx := newServer(t)
 	defer srv.Close()
 	r, w := io.Pipe()
 	go func() {
 		defer w.Close()
 		fmt.Fprint(w, "foo")
 		time.Sleep(1 * time.Second)
 		fmt.Fprint(w, " ")
 		time.Sleep(1 * time.Second)
 		fmt.Fprint(w, "bar\n")
 	}()
 	if err := cli.WriteStream("/newfile.txt", r, 0660); err != nil {
 		t.Fatalf("got: %v, want nil", err)
 	}
 	info, err := fs.Stat(ctx, "/newfile.txt")
 	if err != nil {
 		t.Fatalf("got: %v, want file info: %v", err, info)
 	}
 	if info.Size() != 8 {
 		t.Fatalf("got: %v, want file size: %d bytes", info.Size(), 8)
 	}
 }
--- a/cmd/gowebdav/README.md
+++ b/cmd/gowebdav/README.md
@ -1,103 +0,0 @@
 # 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
 ```
--- a/cmd/gowebdav/main.go
+++ b/cmd/gowebdav/main.go
@ -1,267 +0,0 @@
 package main
 import (
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"io/fs"
 	"os"
 	"os/user"
 	"path"
 	"path/filepath"
 	"runtime"
 	"strings"
 	d "git.siteop.biz/shoopea/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 <PATH>
 	STAT <PATH>
 	MKDIR <PATH>
 	MKDIRALL <PATH>
 	GET <PATH> [<FILE>]
 	PUT <PATH> [<FILE>]
 	MV <OLD> <NEW>
 	CP <OLD> <NEW>
 	DEL <PATH>
 	`)
 	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)
 	if e := c.Connect(); e != nil {
 		panic(e)
 	}
 	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); 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,
 	}
 }
--- a/digestAuth.go
+++ b/digestAuth.go
@ -1,164 +0,0 @@
 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
 }
 // NewDigestAuth creates a new instance of our Digest Authenticator
 func NewDigestAuth(login, secret string, rs *http.Response) (Authenticator, error) {
 	return &DigestAuth{user: login, pw: secret, digestParts: digestParts(rs)}, nil
 }
 // Authorize the current request
 func (d *DigestAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	d.digestParts["uri"] = path
 	d.digestParts["method"] = rq.Method
 	d.digestParts["username"] = d.user
 	d.digestParts["password"] = d.pw
 	rq.Header.Set("Authorization", getDigestAuthorization(d.digestParts))
 	return nil
 }
 // Verify checks for authentication issues and may trigger a re-authentication
 func (d *DigestAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	if rs.StatusCode == 401 {
 		err = NewPathError("Authorize", path, rs.StatusCode)
 	}
 	return
 }
 // Close cleans up all resources
 func (d *DigestAuth) Close() error {
 	return nil
 }
 // Clone creates a copy of itself
 func (d *DigestAuth) Clone() Authenticator {
 	parts := make(map[string]string, len(d.digestParts))
 	for k, v := range d.digestParts {
 		parts[k] = v
 	}
 	return &DigestAuth{user: d.user, pw: d.pw, digestParts: parts}
 }
 // String toString
 func (d *DigestAuth) String() string {
 	return fmt.Sprintf("DigestAuth login: %s", d.user)
 }
 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
 }
--- a/digestAuth_test.go
+++ b/digestAuth_test.go
@ -1,35 +0,0 @@
 package gowebdav
 import (
 	"net/http"
 	"strings"
 	"testing"
 )
 func TestNewDigestAuth(t *testing.T) {
 	a := &DigestAuth{user: "user", pw: "password", digestParts: make(map[string]string, 0)}
 	ex := "DigestAuth login: user"
 	if a.String() != ex {
 		t.Error("expected: " + ex + " got: " + a.String())
 	}
 	if a.Clone() == a {
 		t.Error("expected a different instance")
 	}
 	if a.Close() != nil {
 		t.Error("expected close without errors")
 	}
 }
 func TestDigestAuthAuthorize(t *testing.T) {
 	a := &DigestAuth{user: "user", pw: "password", digestParts: make(map[string]string, 0)}
 	rq, _ := http.NewRequest("GET", "http://localhost/", nil)
 	a.Authorize(nil, rq, "/")
 	// TODO this is a very lazy test it cuts of cnonce
 	ex := `Digest username="user", realm="", nonce="", uri="/", nc=1, cnonce="`
 	if strings.Index(rq.Header.Get("Authorization"), ex) != 0 {
 		t.Error("got wrong Authorization header: " + rq.Header.Get("Authorization"))
 	}
 }
--- a/doc.go
+++ b/doc.go
@ -1,3 +0,0 @@
 // Package gowebdav is a WebDAV client library with a command line tool
 // included.
 package gowebdav
--- a/errors.go
+++ b/errors.go
@ -1,57 +0,0 @@
 package gowebdav
 import (
 	"errors"
 	"fmt"
 	"os"
 )
 // ErrAuthChanged must be returned from the Verify method as an error
 // to trigger a re-authentication / negotiation with a new authenticator.
 var ErrAuthChanged = errors.New("authentication failed, change algorithm")
 // ErrTooManyRedirects will be used as return error if a request exceeds 10 redirects.
 var ErrTooManyRedirects = errors.New("stopped after 10 redirects")
 // 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,
 	}
 }
--- a/file.go
+++ b/file.go
@ -6,72 +6,47 @@ import (
 	"time"
 )
 // File is our structure for a given file
 type File struct {
-	path        string
+	path     string
-	name        string
+	name     string
-	contentType string
+	size     int64
-	size        int64
+	modified time.Time
-	modified    time.Time
+	isdir    bool
 	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
 	} else {
 		return 0664
 	}
 	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)
 	} else {
 		return fmt.Sprintf("File: '%s' SIZE: %d MODIFIED: %s", f.path, f.size, f.modified.String())
 	}
 	return fmt.Sprintf("File: '%s' SIZE: %d MODIFIED: %s ETAG: %s CTYPE: %s", f.path, f.size, f.modified.String(), f.etag, f.contentType)
 }
--- a/go.mod
+++ b/go.mod
@ -1,3 +0,0 @@
 module git.siteop.biz/shoopea/gowebdav
 go 1.17
--- a/go_test.mod
+++ b/go_test.mod
@ -1,5 +0,0 @@
 module github.com/studio-b12/gowebdav
 go 1.17
 require golang.org/x/net v0.0.0-20221014081412-f15817d10f9b
--- a/go_test.sum
+++ b/go_test.sum
@ -1,7 +0,0 @@
 golang.org/x/net v0.0.0-20221014081412-f15817d10f9b h1:tvrvnPFcdzp294diPnrdZZZ8XUt2Tyj7svb7X52iDuU=
 golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
--- a/main/client.go
+++ b/main/client.go
@ -0,0 +1,181 @@
 package main
 import (
 	"errors"
 	"flag"
 	"fmt"
 	d "gowebdav"
 	"io"
 	"os"
 	"strings"
 )
 func Fail(err interface{}) {
 	if err != nil {
 		fmt.Println(err)
 	} else {
 		fmt.Println("Usage: client FLAGS ARGS")
 		fmt.Println("Flags:")
 		flag.PrintDefaults()
 		fmt.Println("Method <ARGS>")
 		fmt.Println(" LS | LIST | PROPFIND <PATH>")
 		fmt.Println(" RM | DELETE | DEL <PATH>")
 		fmt.Println(" MKDIR | MKCOL <PATH>")
 		fmt.Println(" MKDIRALL | MKCOLALL <PATH>")
 		fmt.Println(" MV | MOVE | RENAME <OLD_PATH> <NEW_PATH>")
 		fmt.Println(" CP | COPY <OLD_PATH> <NEW_PATH>")
 		fmt.Println(" GET | PULL | READ <PATH>")
 		fmt.Println(" PUT | PUSH | WRITE <PATH> <FILE>")
 		fmt.Println(" STAT <PATH>")
 	}
 	os.Exit(-1)
 }
 func writeFile(path string, bytes []byte, mode os.FileMode) error {
 	f, err := os.Create(path)
 	if err != nil {
 		return err
 	}
 	defer f.Close()
 	_, err = f.Write(bytes)
 	return err
 }
 func main() {
 	root := flag.String("root", "URL", "WebDAV Endpoint")
 	usr := flag.String("user", "", "user")
 	pw := flag.String("pw", "", "password")
 	m := flag.String("X", "GET", "Method ...")
 	flag.Parse()
 	if *root == "URL" {
 		Fail(nil)
 	}
 	M := strings.ToUpper(*m)
 	m = &M
 	c := d.NewClient(*root, *usr, *pw)
 	if err := c.Connect(); err != nil {
 		Fail(fmt.Sprintf("Failed to connect due to: %s", err.Error()))
 	}
 	alen := len(flag.Args())
 	if alen == 1 {
 		path := flag.Args()[0]
 		switch *m {
 		case "LS", "LIST", "PROPFIND":
 			if files, err := c.ReadDir(path); err == nil {
 				fmt.Println(fmt.Sprintf("ReadDir: '%s' entries: %d ", path, len(files)))
 				for _, f := range files {
 					fmt.Println(f)
 				}
 			} else {
 				fmt.Println(err)
 			}
 		case "STAT":
 			if file, err := c.Stat(path); err == nil {
 				fmt.Println(file)
 			} else {
 				fmt.Println(err)
 			}
 		case "GET", "PULL", "READ":
 			if bytes, err := c.Read(path); err == nil {
 				if lidx := strings.LastIndex(path, "/"); lidx != -1 {
 					path = path[lidx+1:]
 				}
 				if err := writeFile(path, bytes, 0644); err != nil {
 					fmt.Println(err)
 				} else {
 					fmt.Println(fmt.Sprintf("Written %d bytes to: %s", len(bytes), path))
 				}
 			} else {
 				fmt.Println(err)
 			}
 		case "DELETE", "RM", "DEL":
 			if err := c.Remove(path); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println("Remove: " + path)
 			}
 		case "MKCOL", "MKDIR":
 			if err := c.Mkdir(path, 0); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println("MkDir: " + path)
 			}
 		case "MKCOLALL", "MKDIRALL":
 			if err := c.MkdirAll(path, 0); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println("MkDirAll: " + path)
 			}
 		default:
 			Fail(nil)
 		}
 	} else if alen == 2 {
 		a0 := flag.Args()[0]
 		a1 := flag.Args()[1]
 		switch *m {
 		case "RENAME", "MV", "MOVE":
 			if err := c.Rename(a0, a1, true); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println("Rename: " + a0 + " -> " + a1)
 			}
 		case "COPY", "CP":
 			if err := c.Copy(a0, a1, true); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println("Copy: " + a0 + " -> " + a1)
 			}
 		case "PUT", "PUSH", "WRITE":
 			stream, err := getStream(a1)
 			if err != nil {
 				Fail(err)
 			}
 			if err := c.WriteStream(a0, stream, 0644); err != nil {
 				fmt.Println(err)
 			} else {
 				fmt.Println(fmt.Sprintf("Written: '%s' -> %s", a1, a0))
 			}
 		default:
 			Fail(nil)
 		}
 	} else {
 		Fail(nil)
 	}
 }
 func getStream(pathOrString string) (io.ReadCloser, error) {
 	fi, err := os.Stat(pathOrString)
 	if err == nil {
 		if fi.IsDir() {
 			return nil, &os.PathError{"Open", pathOrString, errors.New("Path: '" + pathOrString + "' is a directory")}
 		}
 		f, err := os.Open(pathOrString)
 		if err == nil {
 			return f, nil
 		}
 		return nil, &os.PathError{"Open", pathOrString, err}
 	} else {
 		return nopCloser{strings.NewReader(pathOrString)}, nil
 	}
 }
 type nopCloser struct {
 	io.Reader
 }
 func (nopCloser) Close() error {
 	return nil
 }
--- a/netrc.go
+++ b/netrc.go
@ -1,54 +0,0 @@
 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 "", ""
 }
--- a/passportAuth.go
+++ b/passportAuth.go
@ -1,181 +0,0 @@
 package gowebdav
 import (
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 )
 // PassportAuth structure holds our credentials
 type PassportAuth struct {
 	user            string
 	pw              string
 	cookies         []http.Cookie
 	inhibitRedirect bool
 }
 // constructor for PassportAuth creates a new PassportAuth object and
 // automatically authenticates against the given partnerURL
 func NewPassportAuth(c *http.Client, user, pw, partnerURL string, header *http.Header) (Authenticator, error) {
 	p := &PassportAuth{
 		user:            user,
 		pw:              pw,
 		inhibitRedirect: true,
 	}
 	err := p.genCookies(c, partnerURL, header)
 	return p, err
 }
 // Authorize the current request
 func (p *PassportAuth) Authorize(c *http.Client, rq *http.Request, path string) error {
 	// prevent redirects to detect subsequent authentication requests
 	if p.inhibitRedirect {
 		rq.Header.Set(XInhibitRedirect, "1")
 	} else {
 		p.inhibitRedirect = true
 	}
 	for _, cookie := range p.cookies {
 		rq.AddCookie(&cookie)
 	}
 	return nil
 }
 // Verify verifies if the authentication is good
 func (p *PassportAuth) Verify(c *http.Client, rs *http.Response, path string) (redo bool, err error) {
 	switch rs.StatusCode {
 	case 301, 302, 307, 308:
 		redo = true
 		if rs.Header.Get("Www-Authenticate") != "" {
 			// re-authentication required as we are redirected to the login page
 			err = p.genCookies(c, rs.Request.URL.String(), &rs.Header)
 		} else {
 			// just a redirect, follow it
 			p.inhibitRedirect = false
 		}
 	case 401:
 		err = NewPathError("Authorize", path, rs.StatusCode)
 	}
 	return
 }
 // Close cleans up all resources
 func (p *PassportAuth) Close() error {
 	return nil
 }
 // Clone creates a Copy of itself
 func (p *PassportAuth) Clone() Authenticator {
 	// create a copy to allow independent cookie updates
 	clonedCookies := make([]http.Cookie, len(p.cookies))
 	copy(clonedCookies, p.cookies)
 	return &PassportAuth{
 		user:            p.user,
 		pw:              p.pw,
 		cookies:         clonedCookies,
 		inhibitRedirect: true,
 	}
 }
 // String toString
 func (p *PassportAuth) String() string {
 	return fmt.Sprintf("PassportAuth login: %s", p.user)
 }
 func (p *PassportAuth) genCookies(c *http.Client, partnerUrl string, header *http.Header) error {
 	// For more details refer to:
 	// https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-pass/2c80637d-438c-4d4b-adc5-903170a779f3
 	// Skipping step 1 and 2 as we already have the partner server challenge
 	baseAuthenticationServer := header.Get("Location")
 	baseAuthenticationServerURL, err := url.Parse(baseAuthenticationServer)
 	if err != nil {
 		return err
 	}
 	// Skipping step 3 and 4 as we already know that we need and have the user's credentials
 	// Step 5 (Sign-in request)
 	authenticationServerUrl := url.URL{
 		Scheme: baseAuthenticationServerURL.Scheme,
 		Host:   baseAuthenticationServerURL.Host,
 		Path:   "/login2.srf",
 	}
 	partnerServerChallenge := strings.Split(header.Get("Www-Authenticate"), " ")[1]
 	req := http.Request{
 		Method: "GET",
 		URL:    &authenticationServerUrl,
 		Header: http.Header{
 			"Authorization": []string{"Passport1.4 sign-in=" + url.QueryEscape(p.user) + ",pwd=" + url.QueryEscape(p.pw) + ",OrgVerb=GET,OrgUrl=" + partnerUrl + "," + partnerServerChallenge},
 		},
 	}
 	rs, err := c.Do(&req)
 	if err != nil {
 		return err
 	}
 	io.Copy(io.Discard, rs.Body)
 	rs.Body.Close()
 	if rs.StatusCode != 200 {
 		return NewPathError("Authorize", "/", rs.StatusCode)
 	}
 	// Step 6 (Token Response from Authentication Server)
 	tokenResponseHeader := rs.Header.Get("Authentication-Info")
 	if tokenResponseHeader == "" {
 		return NewPathError("Authorize", "/", 401)
 	}
 	tokenResponseHeaderList := strings.Split(tokenResponseHeader, ",")
 	token := ""
 	for _, tokenResponseHeader := range tokenResponseHeaderList {
 		if strings.HasPrefix(tokenResponseHeader, "from-PP='") {
 			token = tokenResponseHeader
 			break
 		}
 	}
 	if token == "" {
 		return NewPathError("Authorize", "/", 401)
 	}
 	// Step 7 (First Authentication Request to Partner Server)
 	origUrl, err := url.Parse(partnerUrl)
 	if err != nil {
 		return err
 	}
 	req = http.Request{
 		Method: "GET",
 		URL:    origUrl,
 		Header: http.Header{
 			"Authorization": []string{"Passport1.4 " + token},
 		},
 	}
 	rs, err = c.Do(&req)
 	if err != nil {
 		return err
 	}
 	io.Copy(io.Discard, rs.Body)
 	rs.Body.Close()
 	if rs.StatusCode != 200 && rs.StatusCode != 302 {
 		return NewPathError("Authorize", "/", rs.StatusCode)
 	}
 	// Step 8 (Set Token Message from Partner Server)
 	cookies := rs.Header.Values("Set-Cookie")
 	p.cookies = make([]http.Cookie, len(cookies))
 	for i, cookie := range cookies {
 		cookieParts := strings.Split(cookie, ";")
 		cookieName := strings.Split(cookieParts[0], "=")[0]
 		cookieValue := strings.Split(cookieParts[0], "=")[1]
 		p.cookies[i] = http.Cookie{
 			Name:  cookieName,
 			Value: cookieValue,
 		}
 	}
 	return nil
 }
--- a/passportAuth_test.go
+++ b/passportAuth_test.go
@ -1,66 +0,0 @@
 package gowebdav
 import (
 	"bytes"
 	"net/http"
 	"net/url"
 	"regexp"
 	"testing"
 )
 // testing the creation is enough as it handles the authorization during init
 func TestNewPassportAuth(t *testing.T) {
 	user := "user"
 	pass := "password"
 	p1 := "some,comma,separated,values"
 	token := "from-PP='token'"
 	authHandler := func(h http.Handler) http.HandlerFunc {
 		return func(w http.ResponseWriter, r *http.Request) {
 			reg, err := regexp.Compile("Passport1\\.4 sign-in=" + url.QueryEscape(user) + ",pwd=" + url.QueryEscape(pass) + ",OrgVerb=GET,OrgUrl=.*," + p1)
 			if err != nil {
 				t.Error(err)
 			}
 			if reg.MatchString(r.Header.Get("Authorization")) {
 				w.Header().Set("Authentication-Info", token)
 				w.WriteHeader(200)
 				return
 			}
 		}
 	}
 	authsrv, _, _ := newAuthSrv(t, authHandler)
 	defer authsrv.Close()
 	dataHandler := func(h http.Handler) http.HandlerFunc {
 		return func(w http.ResponseWriter, r *http.Request) {
 			reg, err := regexp.Compile("Passport1\\.4 " + token)
 			if err != nil {
 				t.Error(err)
 			}
 			if reg.MatchString(r.Header.Get("Authorization")) {
 				w.Header().Set("Set-Cookie", "Pass=port")
 				h.ServeHTTP(w, r)
 				return
 			}
 			for _, c := range r.Cookies() {
 				if c.Name == "Pass" && c.Value == "port" {
 					h.ServeHTTP(w, r)
 					return
 				}
 			}
 			w.Header().Set("Www-Authenticate", "Passport1.4 "+p1)
 			http.Redirect(w, r, authsrv.URL+"/", 302)
 		}
 	}
 	srv, _, _ := newAuthSrv(t, dataHandler)
 	defer srv.Close()
 	cli := NewClient(srv.URL, user, pass)
 	data, err := cli.Read("/hello.txt")
 	if err != nil {
 		t.Errorf("got error=%v; want nil", err)
 	}
 	if !bytes.Equal(data, []byte("hello gowebdav\n")) {
 		t.Logf("got data=%v; want=hello gowebdav", data)
 	}
 }
--- a/requests.go
+++ b/requests.go
@ -1,77 +1,43 @@
 package gowebdav
 import (
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"net/http"
 	"path"
 	"strings"
 )
-func (c *Client) req(method, path string, body io.Reader, intercept func(*http.Request)) (rs *http.Response, err error) {
+func (c *Client) req(method string, path string, body io.Reader, intercept func(*http.Request)) (req *http.Response, err error) {
-	var redo bool
+	r, err := http.NewRequest(method, Join(c.root, path), body)
-	var r *http.Request
+	if err != nil {
-	var uri = PathEscape(Join(c.root, path))
+		return nil, err
-	auth, body := c.auth.NewAuthenticator(body)
+	}
-	defer auth.Close()
+	for k, vals := range c.headers {
-
+		for _, v := range vals {
-	for { // TODO auth.continue() strategy(true|n times|until)?
+			r.Header.Add(k, v)
 		if r, err = http.NewRequest(method, uri, body); err != nil {
 			return
 		}
 		for k, vals := range c.headers {
 			for _, v := range vals {
 				r.Header.Add(k, v)
 			}
 		}
 		if err = auth.Authorize(c.c, r, path); err != nil {
 			return
 		}
 		if intercept != nil {
 			intercept(r)
 		}
 		if c.interceptor != nil {
 			c.interceptor(method, r)
 		}
 		if rs, err = c.c.Do(r); err != nil {
 			return
 		}
 		if redo, err = auth.Verify(c.c, rs, path); err != nil {
 			rs.Body.Close()
 			return nil, err
 		}
 		if redo {
 			rs.Body.Close()
 			if body, err = r.GetBody(); err != nil {
 				return nil, err
 			}
 			continue
 		}
 		break
 	}
-	return rs, err
+	if intercept != nil {
 		intercept(r)
 	}
 	return c.c.Do(r)
 }
-func (c *Client) mkcol(path string) (status int, err error) {
+func (c *Client) mkcol(path string) int {
 	rs, err := c.req("MKCOL", path, nil, nil)
 	if err != nil {
-		return
+		return 400
 	}
-	defer rs.Body.Close()
+	rs.Body.Close()
-	status = rs.StatusCode
+	if rs.StatusCode == 201 || rs.StatusCode == 405 {
-	if status == 405 {
+		return 201
 		status = 201
 	}
-	return
+	return rs.StatusCode
 }
 func (c *Client) options(path string) (*http.Response, error) {
@ -87,7 +53,7 @@ func (c *Client) propfind(path string, self bool, body string, resp interface{},
 		} else {
 			rq.Header.Add("Depth", "1")
 		}
-		rq.Header.Add("Content-Type", "application/xml;charset=UTF-8")
+		rq.Header.Add("Content-Type", "text/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'
@ -99,24 +65,15 @@ func (c *Client) propfind(path string, self bool, body string, resp interface{},
 	defer rs.Body.Close()
 	if rs.StatusCode != 207 {
-		return NewPathError("PROPFIND", path, rs.StatusCode)
+		return errors.New(fmt.Sprintf("%s - %s %s", rs.Status, "PROPFIND", path))
 	}
 	return parseXML(rs.Body, resp, parse)
 }
-func (c *Client) doCopyMove(
+func (c *Client) doCopyMove(method string, oldpath string, newpath string, overwrite bool) (int, io.ReadCloser) {
 	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)))
+		rq.Header.Add("Destination", Join(c.root, newpath))
 		if overwrite {
 			rq.Header.Add("Overwrite", "T")
 		} else {
@ -124,18 +81,13 @@ func (c *Client) doCopyMove(
 		}
 	})
 	if err != nil {
-		return
+		return 400, nil
 	}
-	status = rs.StatusCode
+	return rs.StatusCode, rs.Body
 	r = rs.Body
 	return
 }
-func (c *Client) copymove(method string, oldpath string, newpath string, overwrite bool) (err error) {
+func (c *Client) copymove(method string, oldpath string, newpath string, overwrite bool) error {
-	s, data, err := c.doCopyMove(method, oldpath, newpath, overwrite)
+	s, data := c.doCopyMove(method, oldpath, newpath, overwrite)
 	if err != nil {
 		return
 	}
 	if data != nil {
 		defer data.Close()
 	}
@ -146,36 +98,20 @@ func (c *Client) copymove(method string, oldpath string, newpath string, overwri
 	case 207:
 		// TODO handle multistat errors, worst case ...
-		log.Printf("TODO handle %s - %s multistatus result %s\n", method, oldpath, String(data))
+		log(fmt.Sprintf(" TODO handle %s - %s multistatus result %s", method, oldpath, String(data)))
 	case 409:
-		err := c.createParentCollection(newpath)
+		// TODO create dst path
 		if err != nil {
 			return err
 		}
 		return c.copymove(method, oldpath, newpath, overwrite)
 	}
-	return NewPathError(method, oldpath, s)
+	return newPathError(method, oldpath, s)
 }
-func (c *Client) put(path string, stream io.Reader) (status int, err error) {
+func (c *Client) put(path string, stream io.Reader) int {
 	rs, err := c.req("PUT", path, stream, nil)
 	if err != nil {
-		return
+		return 400
 	}
-	defer rs.Body.Close()
+	rs.Body.Close()
-
+	return rs.StatusCode
 	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)
 }
--- a/utils.go
+++ b/utils.go
@ -3,23 +3,27 @@ package gowebdav
 import (
 	"bytes"
 	"encoding/xml"
 	"errors"
 	"fmt"
 	"io"
-	"net/url"
+	"os"
 	"strconv"
 	"strings"
 	"time"
 )
-// PathEscape escapes all segments of a given path
+func log(msg interface{}) {
-func PathEscape(path string) string {
+	fmt.Println(msg)
-	s := strings.Split(path, "/")
+}
-	for i, e := range s {
+
-		s[i] = url.PathEscape(e)
+func newPathError(op string, path string, statusCode int) error {
-	}
+	return &os.PathError{op, path, errors.New(fmt.Sprintf("%d", statusCode))}
-	return strings.Join(s, "/")
+}
 func newPathErrorErr(op string, path string, err error) error {
 	return &os.PathError{op, path, err}
 }
 // FixSlash appends a trailing / to our string
 func FixSlash(s string) string {
 	if !strings.HasSuffix(s, "/") {
 		s += "/"
@ -27,25 +31,20 @@ func FixSlash(s string) string {
 	return s
 }
 // FixSlashes appends and prepends a / if they are missing
 func FixSlashes(s string) string {
-	if !strings.HasPrefix(s, "/") {
+	if s[0] != '/' {
 		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)
 	_, _ = buf.ReadFrom(r)
 	return buf.String()
 }
@ -86,28 +85,3 @@ func parseXML(data io.Reader, resp interface{}, parse func(resp interface{}) 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()
 }
--- a/utils_test.go
+++ b/utils_test.go
@ -1,10 +1,6 @@
 package gowebdav
-import (
+import "testing"
 	"fmt"
 	"net/url"
 	"testing"
 )
 func TestJoin(t *testing.T) {
 	eq(t, "/", "", "")
@ -20,48 +16,3 @@ func eq(t *testing.T, expected string, s0 string, s1 string) {
 		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)
 	}
 }
		`@ -1,3 +0,0 @@`
			`module git.siteop.biz/shoopea/gowebdav`

			`go 1.17`