gowebdav

To simplify usage and securely manage credentials (e.g., using pass), you can create a shell wrapper script. This allows you to run commands against a specific server without manually providing the URL, user, or password every time.

Example wrapper content:

#!/bin/sh

ROOT="https://my.dav.server/" \
USER="foo" \
PASSWORD="$(pass dav/foo@my.dav.server)" \
gowebdav $@

After creating the file, make it executable with chmod a+x <filename>.

Install the gowebdav command line tool using go get. Ensure you have Golang 1.x and Git 2.14.2 or higher installed.

go get -u github.com/studio-b12/gowebdav/cmd/gowebdav

The gowebdav CLI uses environment variables to manage connection details. Setting these improves the user experience by avoiding repetitive arguments.

Required/Recommended variables:

• ROOT: The URL of the target WebDAV server (e.g., https://webdav.mydomain.me/user_root_folder).
• USER: The login username for the server.
• PASSWORD: The password for the server.

Use NewDigestAuth to create a new DigestAuth instance. This function requires the user's login credentials and an *http.Response object that contains the Www-Authenticate header (typically from a 401 Unauthorized response) to extract necessary digest parameters like nonce, realm, and qop.

// Assuming 'resp' is an *http.Response received from a 401 challenge
auth, err := gowebdav.NewDigestAuth("my_user", "my_password", resp)
if err != nil {
    // handle error
}

The File type provides the following exported methods for retrieving metadata:

• Path() string: Returns the full path of the file.
• Name() string: Returns the name of the file.
• ContentType() string: Returns the MIME content type.
• Size() int64: Returns the size of the file in bytes.
• Mode() os.FileMode: Returns the file mode. Directories return 0775 | os.ModeDir; files return 0664.
• ModTime() time.Time: Returns the last modified time.
• ETag() string: Returns the ETag.
• IsDir() bool: Returns true if the item is a directory.
• Sys() interface{}: Returns nil (placeholder for underlying system data).
• String() string: Returns a formatted string representation of the file or directory information.

The ReadDir(path string) method returns a slice of os.FileInfo representing the contents of the remote directory. It uses PROPFIND to retrieve metadata like name, size, modification time, and whether the item is a collection (directory).

files, err := client.ReadDir("/remote/path")
if err != nil {
    log.Fatal(err)
}
for _, f := range files {
    fmt.Printf("Name: %s, IsDir: %v, Size: %d\n", f.Name(), f.IsDir(), f.Size())
}

The Verify method checks the response from a server to determine if the authentication session is still valid or if a re-authentication is required. It handles HTTP redirect status codes (301, 302, 307, 308) and 401 Unauthorized errors.

Returns:

• redo (bool): If true, the client should retry the request (e.g., after a redirect or re-authentication).
• err (error): Returns a NewPathError if a 401 Unauthorized is encountered or if authentication fails during a redirect.

redo, err := auth.Verify(httpClient, response, "/remote/path")
if err != nil {
    // handle error
}
if redo {
    // retry the request
}

If you know exactly which authentication method the server requires and want to avoid the overhead of negotiation, use NewPreemptiveAuth(auth Authenticator). This authorizer will use the provided Authenticator for every request regardless of any Www-Authenticate headers sent by the server.

Constraints:

• It only supports a single authentication method.
• Calling AddAuthenticator on a preemptive authorizer will panic.
• It is a high-performance implementation without synchronization, making it suitable for BasicAuth even within goroutines.

// Assuming basicAuth is an existing Authenticator instance
preemptiveAz := gowebdav.NewPreemptiveAuth(basicAuth)

If you want full control over which authentication methods are supported, use NewEmptyAuth(). You can then register your own authentication factories using AddAuthenticator(key string, fn AuthFactory). The order in which you add authenticators determines the priority during negotiation (FIFO).

Warning: Calling AddAuthenticator with a key that is already registered will cause a panic.

authorizer := gowebdav.NewEmptyAuth()

// Register a custom factory
authorizer.AddAuthenticator("my-custom-auth", func(c *http.Client, rs *http.Response, path string) (gowebdav.Authenticator, error) {
    return &MyCustomAuth{}, nil
})