update README

Very useful when iterating over ReadDir results and wanting to do some operation on them.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+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.

.gitignore

@@ -1,4 +1,19 @@
+# Folders to ignore
 /src
 /bin
 /pkg
 /gowebdav
+/.idea
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out

.travis.yml

@@ -2,3 +2,9 @@ language: go
 
 go:
   - "1.x"
+
+install:
+  - go get ./...
+
+script:
+  - go test -v --short ./...

README.md

@@ -4,84 +4,147 @@
 [![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 golang WebDAV client library and command line tool.
+A golang WebDAV client library.
 
-## Install command line tool
+## Main features
-
+`gowebdav` library allows to perform following actions on the remote WebDAV server:
-```sh
+* [create path](#create-path-on-a-webdav-server)
-go get -u github.com/studio-b12/gowebdav/cmd/gowebdav
+* [get files list](#get-files-list)
-```
+* [download file](#download-file-to-byte-array)
+* [upload file](#upload-file-from-byte-array)
+* [get information about specified file/folder](#get-information-about-specified-filefolder)
+* [move file to another location](#move-file-to-another-location)
+* [copy file to another location](#copy-file-to-another-location)
+* [delete file](#delete-file)
 
 ## Usage
 
-```sh
+First of all you should create `Client` instance using `NewClient()` function:
-$ gowebdav --help
-Usage of gowebdav
-  -X string
-        Method:
-                LS <PATH>
-                STAT <PATH>
 
-                MKDIR <PATH>
+```go
-                MKDIRALL <PATH>
+root := "https://webdav.mydomain.me"
+user := "user"
+password := "password"
 
-                GET <PATH> [<FILE>]
+c := gowebdav.NewClient(root, user, password)
-                PUT <PATH> [<FILE>]
-
-                MV <OLD> <NEW>
-                CP <OLD> <NEW>
-
-                DEL <PATH>
-
-  -netrc-file string
-        read login from netrc file (default "~/.netrc")
-  -pw string
-        Password [ENV.PASSWORD]
-  -root string
-        WebDAV Endpoint [ENV.ROOT]
-  -user string
-        User [ENV.USER] (default "$USER")
 ```
 
-*gowebdav wrapper script*
+After you can use this `Client` to perform actions, described below.
 
-Create a wrapper script for example `$EDITOR ./dav && chmod a+x ./dav` for your
+**NOTICE:** we will not check errors in examples, to focus you on the `gowebdav` library's code, but you should do it in your code!
-server and use [pass](https://www.passwordstore.org/ "the standard unix password manager")
-or similar tools to retrieve the password.
 
-```sh
+### Create path on a WebDAV server
-#!/bin/sh
+```go
-
+err := c.Mkdir("folder", 0644)
-ROOT="https://my.dav.server/" \
+```
-USER="foo" \
+In case you want to create several folders you can use `c.MkdirAll()`:
-PASSWORD="$(pass dav/foo@my.dav.server)" \
+```go
-gowebdav $@
+err := c.MkdirAll("folder/subfolder/subfolder2", 0644)
 ```
 
-*Examples*
+### Get files list
-
+```go
-Using the `dav` wrapper:
+files, _ := c.ReadDir("folder/subfolder")
-
+for _, file := range files {
-```sh
+    //notice that [file] has os.FileInfo type
-$ ./dav -X LS /
+    fmt.Println(file.Name())
-
+}
-$ 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
 ```
 
-## LINKS
+### Download file to byte array
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
 
-* [RFC 2518 - HTTP Extensions for Distributed Authoring -- WEBDAV](http://www.faqs.org/rfcs/rfc2518.html "RFC 2518 - HTTP Extensions for Distributed Authoring -- WEBDAV")
+bytes, _ := c.Read(webdavFilePath)
+ioutil.WriteFile(localFilePath, bytes, 0644)
+```
+
+### Download file via reader
+Also you can use `c.ReadStream()` method:
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+reader, _ := c.ReadStream(webdavFilePath)
+
+file, _ := os.Create(localFilePath)
+defer file.Close()
+
+io.Copy(file, reader)
+```
+
+### Upload file from byte array
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+bytes, _ := ioutil.ReadFile(localFilePath)
+
+c.Write(webdavFilePath, bytes, 0644)
+```
+
+### Upload file via writer
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+localFilePath := "/tmp/webdav/file.txt"
+
+file, _ := os.Open(localFilePath)
+defer file.Close()
+
+c.WriteStream(webdavFilePath, file, 0644)
+```
+
+### Get information about specified file/folder
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+
+info := c.Stat(webdavFilePath)
+//notice that [info] has os.FileInfo type
+fmt.Println(info)
+```
+
+### Move file to another location
+```go
+oldPath := "folder/subfolder/file.txt"
+newPath := "folder/subfolder/moved.txt"
+isOverwrite := true
+
+c.Rename(oldPath, newPath, isOverwrite)
+```
+
+### Copy file to another location
+```go
+oldPath := "folder/subfolder/file.txt"
+newPath := "folder/subfolder/file-copy.txt"
+isOverwrite := true
+
+c.Copy(oldPath, newPath, isOverwrite)
+```
+
+### Delete file
+```go
+webdavFilePath := "folder/subfolder/file.txt"
+
+c.Remove(webdavFilePath)
+```
+
+## Links
+
+More details about WebDAV server you can read from following resources:
+
+* [RFC 4918 - HTTP Extensions for Web Distributed Authoring and Versioning (WebDAV)](https://tools.ietf.org/html/rfc4918)
+* [RFC 5689 - Extended MKCOL for Web Distributed Authoring and Versioning (WebDAV)](https://tools.ietf.org/html/rfc5689)
 * [RFC 2616 - HTTP/1.1 Status Code Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html "HTTP/1.1 Status Code Definitions")
 * [WebDav: Next Generation Collaborative Web Authoring By Lisa Dusseaul](https://books.google.de/books?isbn=0130652083 "WebDav: Next Generation Collaborative Web Authoring By Lisa Dusseault")
 
+**NOTICE**: RFC 2518 is obsoleted by RFC 4918 in June 2007
+
+## Contributing
+All contributing are welcome. If you have any suggestions or find some bug - please create an Issue to let us make this project better. We appreciate your help!
+
+## License
+This library is distributed under the BSD 3-Clause license found in the [LICENSE](https://github.com/studio-b12/gowebdav/blob/master/LICENSE) file.
 ## API
 
 `import "github.com/studio-b12/gowebdav"`
@@ -138,6 +201,7 @@ included.
   * [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)
@@ -253,55 +317,55 @@ 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=6960:7028#L314)
+#### <a name="Client.Copy">func</a> (\*Client) [Copy](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6376:6444#L303)
 ``` 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=6051:6107#L273)
+#### <a name="Client.Mkdir">func</a> (\*Client) [Mkdir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5467:5523#L262)
 ``` go
 func (c *Client) Mkdir(path string, _ os.FileMode) error
 ```
 Mkdir makes a directory
 
-#### <a name="Client.MkdirAll">func</a> (\*Client) [MkdirAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6286:6345#L284)
+#### <a name="Client.MkdirAll">func</a> (\*Client) [MkdirAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5702:5761#L273)
 ``` go
 func (c *Client) MkdirAll(path string, _ os.FileMode) 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=7134:7184#L319)
+#### <a name="Client.Read">func</a> (\*Client) [Read](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6550:6600#L308)
 ``` 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=3126:3186#L131)
+#### <a name="Client.ReadDir">func</a> (\*Client) [ReadDir](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=2542:2602#L120)
 ``` 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=7495:7558#L337)
+#### <a name="Client.ReadStream">func</a> (\*Client) [ReadStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6911:6974#L326)
 ``` go
 func (c *Client) ReadStream(path string) (io.ReadCloser, error)
 ```
 ReadStream reads the stream for a given path
 
-#### <a name="Client.Remove">func</a> (\*Client) [Remove](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5557:5599#L250)
+#### <a name="Client.Remove">func</a> (\*Client) [Remove](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=4973:5015#L239)
 ``` 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=5665:5710#L255)
+#### <a name="Client.RemoveAll">func</a> (\*Client) [RemoveAll](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=5081:5126#L244)
 ``` 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=6794:6864#L309)
+#### <a name="Client.Rename">func</a> (\*Client) [Rename](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=6210:6280#L298)
 ``` go
 func (c *Client) Rename(oldpath, newpath string, overwrite bool) error
 ```
@@ -325,19 +389,19 @@ 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=4513:4568#L198)
+#### <a name="Client.Stat">func</a> (\*Client) [Stat](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=3929:3984#L187)
 ``` 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=7849:7918#L352)
+#### <a name="Client.Write">func</a> (\*Client) [Write](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=7265:7334#L341)
 ``` go
 func (c *Client) Write(path string, data []byte, _ os.FileMode) 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=8320:8400#L374)
+#### <a name="Client.WriteStream">func</a> (\*Client) [WriteStream](https://github.com/studio-b12/gowebdav/blob/master/client.go?s=7690:7770#L364)
 ``` go
 func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error
 ```
@@ -383,55 +447,61 @@ type File struct {
 ```
 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=388:422#L26)
+#### <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=841:868#L51)
+#### <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=947:973#L56)
+#### <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=748:781#L46)
+#### <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=577:609#L36)
+#### <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=290:317#L21)
+#### <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.Size">func</a> (File) [Size](https://github.com/studio-b12/gowebdav/blob/master/file.go?s=485:511#L31)
+#### <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=1095:1124#L66)
+#### <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=1007:1038#L61)
+#### <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{}
 ```

client.go

@@ -85,18 +85,7 @@ func (c *Client) Connect() error {
 		return err
 	}
 
-	if rs.StatusCode == 401 && c.auth.Type() == "NoAuth" {
+	if rs.StatusCode != 200 {
-		if strings.Index(rs.Header.Get("Www-Authenticate"), "Digest") > -1 {
-			c.auth = &DigestAuth{c.auth.User(), c.auth.Pass(), digestParts(rs)}
-		} else if strings.Index(rs.Header.Get("Www-Authenticate"), "Basic") > -1 {
-			c.auth = &BasicAuth{c.auth.User(), c.auth.Pass()}
-		} else {
-			return newPathError("Authorize", c.root, rs.StatusCode)
-		}
-		return c.Connect()
-	} else if rs.StatusCode == 401 {
-		return newPathError("Authorize", c.root, rs.StatusCode)
-	} else if rs.StatusCode != 200 || (rs.Header.Get("Dav") == "" && rs.Header.Get("DAV") == "") {
 		return newPathError("Connect", c.root, rs.StatusCode)
 	}
 
@@ -357,13 +346,14 @@ func (c *Client) Write(path string, data []byte, _ os.FileMode) error {
 		return nil
 
 	case 409:
-		if i := strings.LastIndex(path, "/"); i > -1 {
+		err := c.createParentCollection(path)
-			if err := c.MkdirAll(path[0:i+1], 0755); err == nil {
+		if err != nil {
-				s = c.put(path, bytes.NewReader(data))
+			return err
-				if s == 200 || s == 201 || s == 204 {
+		}
-					return nil
+
-				}
+		s = c.put(path, bytes.NewReader(data))
-			}
+		if s == 200 || s == 201 || s == 204 {
+			return nil
 		}
 	}
 
@@ -372,8 +362,14 @@ func (c *Client) Write(path string, data []byte, _ os.FileMode) error {
 
 // WriteStream writes a stream
 func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error {
-	// TODO check if parent collection exists
+
+	err := c.createParentCollection(path)
+	if err != nil {
+		return err
+	}
+
 	s := c.put(path, stream)
+
 	switch s {
 	case 200, 201, 204:
 		return nil

cmd/gowebdav/README.md

@@ -0,0 +1,103 @@
+# Description
+Command line tool for [gowebdav](https://github.com/studio-b12/gowebdav) library.
+
+# Prerequisites
+## Software
+* **OS**: all, which are supported by `Golang`
+* **Golang**: version 1.x
+* **Git**: version 2.14.2 at higher (required to install via `go get`)
+
+# Install
+```sh
+go get -u github.com/studio-b12/gowebdav/cmd/gowebdav
+```
+
+# Usage
+It is recommended to set following environment variables to improve your experience with this tool:
+* `ROOT` is an URL of target WebDAV server (e.g. `https://webdav.mydomain.me/user_root_folder`)
+* `USER` is a login to connect to specified server (e.g. `user`)
+* `PASSWORD` is a password to connect to specified server (e.g. `p@s$w0rD`)
+
+In following examples we suppose that:
+* environment variable `ROOT` is set to `https://webdav.mydomain.me/ufolder`
+* environment variable `USER` is set to `user`
+* environment variable `PASSWORD` is set `p@s$w0rD`
+* folder `/ufolder/temp` exists on the server
+* file `/ufolder/temp/file.txt` exists on the server
+* file `/ufolder/temp/document.rtf` exists on the server
+* file `/tmp/webdav/to_upload.txt` exists on the local machine
+* folder `/tmp/webdav/` is used to download files from the server
+
+## Examples
+
+#### Get content of specified folder
+```sh
+gowebdav -X LS temp
+```
+
+#### Get info about file/folder
+```sh
+gowebdav -X STAT temp
+gowebdav -X STAT temp/file.txt
+```
+
+#### Create folder on the remote server
+```sh
+gowebdav -X MKDIR temp2
+gowebdav -X MKDIRALL all/folders/which-you-want/to_create
+```
+
+#### Download file
+```sh
+gowebdav -X GET temp/document.rtf /tmp/webdav/document.rtf
+```
+
+You may do not specify target local path, in this case file will be downloaded to the current folder with the
+
+#### Upload file
+```sh
+gowebdav -X PUT temp/uploaded.txt /tmp/webdav/to_upload.txt
+```
+
+#### Move file on the remote server
+```sh
+gowebdav -X MV temp/file.txt temp/moved_file.txt
+```
+
+#### Copy file to another location
+```sh
+gowebdav -X MV temp/file.txt temp/file-copy.txt
+```
+
+#### Delete file from the remote server
+```sh
+gowebdav -X DEL temp/file.txt
+```
+
+# Wrapper script
+
+You can create wrapper script for your server (via `$EDITOR ./dav && chmod a+x ./dav`) and add following content to it:
+```sh
+#!/bin/sh
+
+ROOT="https://my.dav.server/" \
+USER="foo" \
+PASSWORD="$(pass dav/foo@my.dav.server)" \
+gowebdav $@
+```
+
+It allows you to use [pass](https://www.passwordstore.org/ "the standard unix password manager") or similar tools to retrieve the password.
+
+## Examples
+
+Using the `dav` wrapper:
+
+```sh
+$ ./dav -X LS /
+
+$ echo hi dav! > hello && ./dav -X PUT /hello
+$ ./dav -X STAT /hello
+$ ./dav -X PUT /hello_dav hello
+$ ./dav -X GET /hello_dav
+$ ./dav -X GET /hello_dav hello.txt
+```

cmd/gowebdav/main.go

@@ -9,13 +9,14 @@ import (
 	"os"
 	"os/user"
 	"path/filepath"
+	"runtime"
 	"strings"
 )
 
 func main() {
 	root := flag.String("root", os.Getenv("ROOT"), "WebDAV Endpoint [ENV.ROOT]")
-	usr := flag.String("user", os.Getenv("USER"), "User [ENV.USER]")
+	user := flag.String("user", os.Getenv("USER"), "User [ENV.USER]")
-	pw := flag.String("pw", os.Getenv("PASSWORD"), "Password [ENV.PASSWORD]")
+	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>
@@ -38,21 +39,18 @@ func main() {
 		fail("Set WebDAV ROOT")
 	}
 
-	if l := len(flag.Args()); l == 0 || l > 2 {
+	if argsLength := len(flag.Args()); argsLength == 0 || argsLength > 2 {
 		fail("Unsupported arguments")
 	}
 
-	if *pw == "" {
+	if *password == "" {
 		if u, p := d.ReadConfig(*root, *netrc); u != "" && p != "" {
-			usr = &u
+			user = &u
-			pw = &p
+			password = &p
 		}
 	}
 
-	c := d.NewClient(*root, *usr, *pw)
+	c := d.NewClient(*root, *user, *password)
-	if err := c.Connect(); err != nil {
-		fail(fmt.Sprintf("Failed to connect due to: %s", err.Error()))
-	}
 
 	cmd := getCmd(*method)
 
@@ -69,10 +67,21 @@ func fail(err interface{}) {
 }
 
 func getHome() string {
-	if u, e := user.Current(); e != nil {
+	u, e := user.Current()
+	if e != nil {
+		return os.Getenv("HOME")
+	}
+
+	if u != nil {
 		return u.HomeDir
 	}
-	return os.Getenv("HOME")
+
+	switch runtime.GOOS {
+	case "windows":
+		return ""
+	default:
+		return "~/"
+	}
 }
 
 func getCmd(method string) func(c *d.Client, p0, p1 string) error {
@@ -214,32 +223,28 @@ func writeFile(path string, bytes []byte, mode os.FileMode) error {
 }
 
 func getStream(pathOrString string) (io.ReadCloser, error) {
+
 	fi, err := os.Stat(pathOrString)
-	if err == nil {
+	if err != nil {
-		if fi.IsDir() {
+		return nil, err
-			return nil, &os.PathError{
+	}
-				Op:   "Open",
+
-				Path: pathOrString,
+	if fi.IsDir() {
-				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,
+			Err:  errors.New("Path: '" + pathOrString + "' is a directory"),
 		}
 	}
-	return nopCloser{strings.NewReader(pathOrString)}, nil
-}
 
-type nopCloser struct {
+	f, err := os.Open(pathOrString)
-	io.Reader
+	if err == nil {
-}
+		return f, nil
+	}
 
-func (nopCloser) Close() error {
+	return nil, &os.PathError{
-	return nil
+		Op:   "Open",
+		Path: pathOrString,
+		Err:  err,
+	}
 }

digestAuth.go

@@ -44,12 +44,15 @@ func (d *DigestAuth) Authorize(c *Client, method string, path string) {
 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"}
+		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.Split(r, `"`)[1]
+					result[w] = strings.Trim(
+						strings.SplitN(r, `=`, 2)[1],
+						`"`,
+					)
 				}
 			}
 		}
@@ -72,12 +75,72 @@ func getCnonce() string {
 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.
-	ha1 := getMD5(d["username"] + ":" + d["realm"] + ":" + d["password"])
+
-	ha2 := getMD5(d["method"] + ":" + d["uri"])
+	var (
-	nonceCount := 00000001
+		ha1        string
-	cnonce := getCnonce()
+		ha2        string
-	response := getMD5(fmt.Sprintf("%s:%s:%v:%s:%s:%s", ha1, d["nonce"], nonceCount, cnonce, d["qop"], ha2))
+		nonceCount = 00000001
-	authorization := fmt.Sprintf(`Digest username="%s", realm="%s", nonce="%s", uri="%s", cnonce="%s", nc="%v", qop="%s", response="%s", opaque="%s"`,
+		cnonce     = getCnonce()
-		d["username"], d["realm"], d["nonce"], d["uri"], cnonce, nonceCount, d["qop"], response, d["opaque"])
+		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
 }

file.go

@@ -17,6 +17,11 @@ type File struct {
 	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

requests.go

@@ -1,20 +1,32 @@
 package gowebdav
 
 import (
+	"bytes"
 	"fmt"
 	"io"
 	"net/http"
+	"path"
 	"strings"
 )
 
 func (c *Client) req(method, path string, body io.Reader, intercept func(*http.Request)) (req *http.Response, err error) {
-	r, err := http.NewRequest(method, PathEscape(Join(c.root, path)), body)
+	// Tee the body, because if authorization fails we will need to read from it again.
+	var r *http.Request
+	var ba bytes.Buffer
+	bb := io.TeeReader(body, &ba)
+
+	if body == nil {
+		r, err = http.NewRequest(method, PathEscape(Join(c.root, path)), nil)
+	} else {
+		r, err = http.NewRequest(method, PathEscape(Join(c.root, path)), bb)
+	}
+
 	if err != nil {
 		return nil, err
 	}
 
 	c.auth.Authorize(c, method, path)
-	
+
 	for k, vals := range c.headers {
 		for _, v := range vals {
 			r.Header.Add(k, v)
@@ -25,15 +37,44 @@ func (c *Client) req(method, path string, body io.Reader, intercept func(*http.R
 		intercept(r)
 	}
 
-	return c.c.Do(r)
+	rs, err := c.c.Do(r)
+	if err != nil {
+		return nil, err
+	}
+
+	if rs.StatusCode == 401 && c.auth.Type() == "NoAuth" {
+
+		wwwAuthenticateHeader := strings.ToLower(rs.Header.Get("Www-Authenticate"))
+
+		if strings.Index(wwwAuthenticateHeader, "digest") > -1 {
+			c.auth = &DigestAuth{c.auth.User(), c.auth.Pass(), digestParts(rs)}
+
+		} else if strings.Index(wwwAuthenticateHeader, "basic") > -1 {
+			c.auth = &BasicAuth{c.auth.User(), c.auth.Pass()}
+
+		} else {
+			return rs, newPathError("Authorize", c.root, rs.StatusCode)
+		}
+
+		if body == nil {
+			return c.req(method, path, nil, intercept)
+		} else {
+			return c.req(method, path, &ba, intercept)
+		}
+
+	} else if rs.StatusCode == 401 {
+		return rs, newPathError("Authorize", c.root, rs.StatusCode)
+	}
+
+	return rs, err
 }
 
 func (c *Client) mkcol(path string) int {
 	rs, err := c.req("MKCOL", path, nil, nil)
-	defer rs.Body.Close()
 	if err != nil {
 		return 400
 	}
+	defer rs.Body.Close()
 
 	if rs.StatusCode == 201 || rs.StatusCode == 405 {
 		return 201
@@ -55,16 +96,16 @@ func (c *Client) propfind(path string, self bool, body string, resp interface{},
 		} else {
 			rq.Header.Add("Depth", "1")
 		}
-		rq.Header.Add("Content-Type", "text/xml;charset=UTF-8")
+		rq.Header.Add("Content-Type", "application/xml;charset=UTF-8")
 		rq.Header.Add("Accept", "application/xml,text/xml")
 		rq.Header.Add("Accept-Charset", "utf-8")
 		// TODO add support for 'gzip,deflate;q=0.8,q=0.7'
 		rq.Header.Add("Accept-Encoding", "")
 	})
-	defer rs.Body.Close()
 	if err != nil {
 		return err
 	}
+	defer rs.Body.Close()
 
 	if rs.StatusCode != 207 {
 		return fmt.Errorf("%s - %s %s", rs.Status, "PROPFIND", path)
@@ -101,7 +142,12 @@ func (c *Client) copymove(method string, oldpath string, newpath string, overwri
 		log(fmt.Sprintf(" TODO handle %s - %s multistatus result %s", method, oldpath, String(data)))
 
 	case 409:
-		// TODO create dst path
+		err := c.createParentCollection(newpath)
+		if err != nil {
+			return err
+		}
+
+		return c.copymove(method, oldpath, newpath, overwrite)
 	}
 
 	return newPathError(method, oldpath, s)
@@ -109,10 +155,19 @@ func (c *Client) copymove(method string, oldpath string, newpath string, overwri
 
 func (c *Client) put(path string, stream io.Reader) int {
 	rs, err := c.req("PUT", path, stream, nil)
-	defer rs.Body.Close()
 	if err != nil {
 		return 400
 	}
+	defer rs.Body.Close()
 
 	return rs.StatusCode
 }
+
+func (c *Client) createParentCollection(itemPath string) (err error) {
+	parentPath := path.Dir(itemPath)
+	if parentPath == "." || parentPath == "/" {
+		return nil
+	}
+
+	return c.MkdirAll(parentPath, 0755)
+}