overdue

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/core.go

@@ -0,0 +1,255 @@
+package pipeline
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"os"
+	"time"
+)
+
+// The Factory interface represents an object that can create its Policy object. Each HTTP request sent
+// requires that this Factory create a new instance of its Policy object.
+type Factory interface {
+	New(next Policy, po *PolicyOptions) Policy
+}
+
+// FactoryFunc is an adapter that allows the use of an ordinary function as a Factory interface.
+type FactoryFunc func(next Policy, po *PolicyOptions) PolicyFunc
+
+// New calls f(next,po).
+func (f FactoryFunc) New(next Policy, po *PolicyOptions) Policy {
+	return f(next, po)
+}
+
+// The Policy interface represents a mutable Policy object created by a Factory. The object can mutate/process
+// the HTTP request and then forward it on to the next Policy object in the linked-list. The returned
+// Response goes backward through the linked-list for additional processing.
+// NOTE: Request is passed by value so changes do not change the caller's version of
+// the request. However, Request has some fields that reference mutable objects (not strings).
+// These references are copied; a deep copy is not performed. Specifically, this means that
+// you should avoid modifying the objects referred to by these fields: URL, Header, Body,
+// GetBody, TransferEncoding, Form, MultipartForm, Trailer, TLS, Cancel, and Response.
+type Policy interface {
+	Do(ctx context.Context, request Request) (Response, error)
+}
+
+// PolicyFunc is an adapter that allows the use of an ordinary function as a Policy interface.
+type PolicyFunc func(ctx context.Context, request Request) (Response, error)
+
+// Do calls f(ctx, request).
+func (f PolicyFunc) Do(ctx context.Context, request Request) (Response, error) {
+	return f(ctx, request)
+}
+
+// Options configures a Pipeline's behavior.
+type Options struct {
+	HTTPSender Factory // If sender is nil, then the pipeline's default client is used to send the HTTP requests.
+	Log        LogOptions
+}
+
+// LogLevel tells a logger the minimum level to log. When code reports a log entry,
+// the LogLevel indicates the level of the log entry. The logger only records entries
+// whose level is at least the level it was told to log. See the Log* constants.
+// For example, if a logger is configured with LogError, then LogError, LogPanic,
+// and LogFatal entries will be logged; lower level entries are ignored.
+type LogLevel uint32
+
+const (
+	// LogNone tells a logger not to log any entries passed to it.
+	LogNone LogLevel = iota
+
+	// LogFatal tells a logger to log all LogFatal entries passed to it.
+	LogFatal
+
+	// LogPanic tells a logger to log all LogPanic and LogFatal entries passed to it.
+	LogPanic
+
+	// LogError tells a logger to log all LogError, LogPanic and LogFatal entries passed to it.
+	LogError
+
+	// LogWarning tells a logger to log all LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+	LogWarning
+
+	// LogInfo tells a logger to log all LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+	LogInfo
+
+	// LogDebug tells a logger to log all LogDebug, LogInfo, LogWarning, LogError, LogPanic and LogFatal entries passed to it.
+	LogDebug
+)
+
+// LogOptions configures the pipeline's logging mechanism & level filtering.
+type LogOptions struct {
+	Log func(level LogLevel, message string)
+
+	// ShouldLog is called periodically allowing you to return whether the specified LogLevel should be logged or not.
+	// An application can return different values over the its lifetime; this allows the application to dynamically
+	// alter what is logged. NOTE: This method can be called by multiple goroutines simultaneously so make sure
+	// you implement it in a goroutine-safe way. If nil, nothing is logged (the equivalent of returning LogNone).
+	// Usually, the function will be implemented simply like this: return level <= LogWarning
+	ShouldLog func(level LogLevel) bool
+}
+
+type pipeline struct {
+	factories []Factory
+	options   Options
+}
+
+// The Pipeline interface represents an ordered list of Factory objects and an object implementing the HTTPSender interface.
+// You construct a Pipeline by calling the pipeline.NewPipeline function. To send an HTTP request, call pipeline.NewRequest
+// and then call Pipeline's Do method passing a context, the request, and a method-specific Factory (or nil). Passing a
+// method-specific Factory allows this one call to Do to inject a Policy into the linked-list. The policy is injected where
+// the MethodFactoryMarker (see the pipeline.MethodFactoryMarker function) is in the slice of Factory objects.
+//
+// When Do is called, the Pipeline object asks each Factory object to construct its Policy object and adds each Policy to a linked-list.
+// THen, Do sends the Context and Request through all the Policy objects. The final Policy object sends the request over the network
+// (via the HTTPSender object passed to NewPipeline) and the response is returned backwards through all the Policy objects.
+// Since Pipeline and Factory objects are goroutine-safe, you typically create 1 Pipeline object and reuse it to make many HTTP requests.
+type Pipeline interface {
+	Do(ctx context.Context, methodFactory Factory, request Request) (Response, error)
+}
+
+// NewPipeline creates a new goroutine-safe Pipeline object from the slice of Factory objects and the specified options.
+func NewPipeline(factories []Factory, o Options) Pipeline {
+	if o.HTTPSender == nil {
+		o.HTTPSender = newDefaultHTTPClientFactory()
+	}
+	if o.Log.Log == nil {
+		o.Log.Log = func(LogLevel, string) {} // No-op logger
+	}
+	return &pipeline{factories: factories, options: o}
+}
+
+// Do is called for each and every HTTP request. It tells each Factory to create its own (mutable) Policy object
+// replacing a MethodFactoryMarker factory (if it exists) with the methodFactory passed in. Then, the Context and Request
+// are sent through the pipeline of Policy objects (which can transform the Request's URL/query parameters/headers) and
+// ultimately sends the transformed HTTP request over the network.
+func (p *pipeline) Do(ctx context.Context, methodFactory Factory, request Request) (Response, error) {
+	response, err := p.newPolicies(methodFactory).Do(ctx, request)
+	request.close()
+	return response, err
+}
+
+func (p *pipeline) newPolicies(methodFactory Factory) Policy {
+	// The last Policy is the one that actually sends the request over the wire and gets the response.
+	// It is overridable via the Options' HTTPSender field.
+	po := &PolicyOptions{pipeline: p} // One object shared by all policy objects
+	next := p.options.HTTPSender.New(nil, po)
+
+	// Walk over the slice of Factory objects in reverse (from wire to API)
+	markers := 0
+	for i := len(p.factories) - 1; i >= 0; i-- {
+		factory := p.factories[i]
+		if _, ok := factory.(methodFactoryMarker); ok {
+			markers++
+			if markers > 1 {
+				panic("MethodFactoryMarker can only appear once in the pipeline")
+			}
+			if methodFactory != nil {
+				// Replace MethodFactoryMarker with passed-in methodFactory
+				next = methodFactory.New(next, po)
+			}
+		} else {
+			// Use the slice's Factory to construct its Policy
+			next = factory.New(next, po)
+		}
+	}
+
+	// Each Factory has created its Policy
+	if markers == 0 && methodFactory != nil {
+		panic("Non-nil methodFactory requires MethodFactoryMarker in the pipeline")
+	}
+	return next // Return head of the Policy object linked-list
+}
+
+// A PolicyOptions represents optional information that can be used by a node in the
+// linked-list of Policy objects. A PolicyOptions is passed to the Factory's New method
+// which passes it (if desired) to the Policy object it creates. Today, the Policy object
+// uses the options to perform logging. But, in the future, this could be used for more.
+type PolicyOptions struct {
+	pipeline *pipeline
+}
+
+// ShouldLog returns true if the specified log level should be logged.
+func (po *PolicyOptions) ShouldLog(level LogLevel) bool {
+	if po.pipeline.options.Log.ShouldLog != nil {
+		return po.pipeline.options.Log.ShouldLog(level)
+	}
+	return false
+}
+
+// Log logs a string to the Pipeline's Logger.
+func (po *PolicyOptions) Log(level LogLevel, msg string) {
+	if !po.ShouldLog(level) {
+		return // Short circuit message formatting if we're not logging it
+	}
+
+	// We are logging it, ensure trailing newline
+	if len(msg) == 0 || msg[len(msg)-1] != '\n' {
+		msg += "\n" // Ensure trailing newline
+	}
+	po.pipeline.options.Log.Log(level, msg)
+
+	// If logger doesn't handle fatal/panic, we'll do it here.
+	if level == LogFatal {
+		os.Exit(1)
+	} else if level == LogPanic {
+		panic(msg)
+	}
+}
+
+var pipelineHTTPClient = newDefaultHTTPClient()
+
+func newDefaultHTTPClient() *http.Client {
+	// We want the Transport to have a large connection pool
+	return &http.Client{
+		Transport: &http.Transport{
+			Proxy: http.ProxyFromEnvironment,
+			// We use Dial instead of DialContext as DialContext has been reported to cause slower performance.
+			Dial /*Context*/ : (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+				DualStack: true,
+			}).Dial, /*Context*/
+			MaxIdleConns:           0, // No limit
+			MaxIdleConnsPerHost:    100,
+			IdleConnTimeout:        90 * time.Second,
+			TLSHandshakeTimeout:    10 * time.Second,
+			ExpectContinueTimeout:  1 * time.Second,
+			DisableKeepAlives:      false,
+			DisableCompression:     false,
+			MaxResponseHeaderBytes: 0,
+			//ResponseHeaderTimeout:  time.Duration{},
+			//ExpectContinueTimeout:  time.Duration{},
+		},
+	}
+}
+
+// newDefaultHTTPClientFactory creates a DefaultHTTPClientPolicyFactory object that sends HTTP requests to a Go's default http.Client.
+func newDefaultHTTPClientFactory() Factory {
+	return FactoryFunc(func(next Policy, po *PolicyOptions) PolicyFunc {
+		return func(ctx context.Context, request Request) (Response, error) {
+			r, err := pipelineHTTPClient.Do(request.WithContext(ctx))
+			if err != nil {
+				err = NewError(err, "HTTP request failed")
+			}
+			return NewHTTPResponse(r), err
+		}
+	})
+}
+
+var mfm = methodFactoryMarker{} // Singleton
+
+// MethodFactoryMarker returns a special marker Factory object. When Pipeline's Do method is called, any
+// MethodMarkerFactory object is replaced with the specified methodFactory object. If nil is passed fro Do's
+// methodFactory parameter, then the MethodFactoryMarker is ignored as the linked-list of Policy objects is created.
+func MethodFactoryMarker() Factory {
+	return mfm
+}
+
+type methodFactoryMarker struct {
+}
+
+func (methodFactoryMarker) New(next Policy, po *PolicyOptions) Policy {
+	panic("methodFactoryMarker policy should have been replaced with a method policy")
+}

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/defaultlog_syslog.go

@@ -0,0 +1,33 @@
+// +build !windows,!nacl,!plan9
+
+package pipeline
+
+import (
+	"log"
+	"log/syslog"
+)
+
+// ForceLog should rarely be used. It forceable logs an entry to the
+// Windows Event Log (on Windows) or to the SysLog (on Linux)
+func ForceLog(level LogLevel, msg string) {
+	if defaultLogger == nil {
+		return // Return fast if we failed to create the logger.
+	}
+	// We are logging it, ensure trailing newline
+	if len(msg) == 0 || msg[len(msg)-1] != '\n' {
+		msg += "\n" // Ensure trailing newline
+	}
+	switch level {
+	case LogFatal:
+		defaultLogger.Fatal(msg)
+	case LogPanic:
+		defaultLogger.Panic(msg)
+	case LogError, LogWarning, LogInfo:
+		defaultLogger.Print(msg)
+	}
+}
+
+var defaultLogger = func() *log.Logger {
+	l, _ := syslog.NewLogger(syslog.LOG_USER|syslog.LOG_WARNING, log.LstdFlags)
+	return l
+}()

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/defaultlog_windows.go

@@ -0,0 +1,61 @@
+package pipeline
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+// ForceLog should rarely be used. It forceable logs an entry to the
+// Windows Event Log (on Windows) or to the SysLog (on Linux)
+func ForceLog(level LogLevel, msg string) {
+	var el eventType
+	switch level {
+	case LogError, LogFatal, LogPanic:
+		el = elError
+	case LogWarning:
+		el = elWarning
+	case LogInfo:
+		el = elInfo
+	}
+	// We are logging it, ensure trailing newline
+	if len(msg) == 0 || msg[len(msg)-1] != '\n' {
+		msg += "\n" // Ensure trailing newline
+	}
+	reportEvent(el, 0, msg)
+}
+
+type eventType int16
+
+const (
+	elSuccess eventType = 0
+	elError   eventType = 1
+	elWarning eventType = 2
+	elInfo    eventType = 4
+)
+
+var reportEvent = func() func(eventType eventType, eventID int32, msg string) {
+	advAPI32 := syscall.MustLoadDLL("AdvAPI32.dll")
+	registerEventSource := advAPI32.MustFindProc("RegisterEventSourceW")
+
+	sourceName, _ := os.Executable()
+	sourceNameUTF16, _ := syscall.UTF16PtrFromString(sourceName)
+	handle, _, lastErr := registerEventSource.Call(uintptr(0), uintptr(unsafe.Pointer(sourceNameUTF16)))
+	if lastErr == nil { // On error, logging is a no-op
+		return func(eventType eventType, eventID int32, msg string) {}
+	}
+	reportEvent := advAPI32.MustFindProc("ReportEventW")
+	return func(eventType eventType, eventID int32, msg string) {
+		s, _ := syscall.UTF16PtrFromString(msg)
+		_, _, _ = reportEvent.Call(
+			uintptr(handle),             // HANDLE  hEventLog
+			uintptr(eventType),          // WORD    wType
+			uintptr(0),                  // WORD    wCategory
+			uintptr(eventID),            // DWORD   dwEventID
+			uintptr(0),                  // PSID    lpUserSid
+			uintptr(1),                  // WORD    wNumStrings
+			uintptr(0),                  // DWORD   dwDataSize
+			uintptr(unsafe.Pointer(&s)), // LPCTSTR *lpStrings
+			uintptr(0))                  // LPVOID  lpRawData
+	}
+}()

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/doc.go

@@ -0,0 +1,161 @@
+// Copyright 2017 Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by an MIT
+// license that can be found in the LICENSE file.
+
+/*
+Package pipeline implements an HTTP request/response middleware pipeline whose
+policy objects mutate an HTTP request's URL, query parameters, and/or headers before
+the request is sent over the wire.
+
+Not all policy objects mutate an HTTP request; some policy objects simply impact the
+flow of requests/responses by performing operations such as logging, retry policies,
+timeouts, failure injection, and deserialization of response payloads.
+
+Implementing the Policy Interface
+
+To implement a policy, define a struct that implements the pipeline.Policy interface's Do method. Your Do
+method is called when an HTTP request wants to be sent over the network. Your Do method can perform any
+operation(s) it desires. For example, it can log the outgoing request, mutate the URL, headers, and/or query
+parameters, inject a failure, etc. Your Do method must then forward the HTTP request to next Policy object
+in a linked-list ensuring that the remaining Policy objects perform their work. Ultimately, the last Policy
+object sends the HTTP request over the network (by calling the HTTPSender's Do method).
+
+When an HTTP response comes back, each Policy object in the linked-list gets a chance to process the response
+(in reverse order). The Policy object can log the response, retry the operation if due to a transient failure
+or timeout, deserialize the response body, etc. Ultimately, the last Policy object returns the HTTP response
+to the code that initiated the original HTTP request.
+
+Here is a template for how to define a pipeline.Policy object:
+
+   type myPolicy struct {
+      node   PolicyNode
+      // TODO: Add configuration/setting fields here (if desired)...
+   }
+
+   func (p *myPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+      // TODO: Mutate/process the HTTP request here...
+      response, err := p.node.Do(ctx, request)	// Forward HTTP request to next Policy & get HTTP response
+      // TODO: Mutate/process the HTTP response here...
+      return response, err	// Return response/error to previous Policy
+   }
+
+Implementing the Factory Interface
+
+Each Policy struct definition requires a factory struct definition that implements the pipeline.Factory interface's New
+method. The New method is called when application code wants to initiate a new HTTP request. Factory's New method is
+passed a pipeline.PolicyNode object which contains a reference to the owning pipeline.Pipeline object (discussed later) and
+a reference to the next Policy object in the linked list. The New method should create its corresponding Policy object
+passing it the PolicyNode and any other configuration/settings fields appropriate for the specific Policy object.
+
+Here is a template for how to define a pipeline.Policy object:
+
+   // NOTE: Once created & initialized, Factory objects should be goroutine-safe (ex: immutable);
+   // this allows reuse (efficient use of memory) and makes these objects usable by multiple goroutines concurrently.
+   type myPolicyFactory struct {
+      // TODO: Add any configuration/setting fields if desired...
+   }
+
+   func (f *myPolicyFactory) New(node pipeline.PolicyNode) Policy {
+      return &myPolicy{node: node} // TODO: Also initialize any configuration/setting fields here (if desired)...
+   }
+
+Using your Factory and Policy objects via a Pipeline
+
+To use the Factory and Policy objects, an application constructs a slice of Factory objects and passes
+this slice to the pipeline.NewPipeline function.
+
+   func NewPipeline(factories []pipeline.Factory, sender pipeline.HTTPSender) Pipeline
+
+This function also requires an object implementing the HTTPSender interface. For simple scenarios,
+passing nil for HTTPSender causes a standard Go http.Client object to be created and used to actually
+send the HTTP response over the network. For more advanced scenarios, you can pass your own HTTPSender
+object in. This allows sharing of http.Client objects or the use of custom-configured http.Client objects
+or other objects that can simulate the network requests for testing purposes.
+
+Now that you have a pipeline.Pipeline object, you can create a pipeline.Request object (which is a simple
+wrapper around Go's standard http.Request object) and pass it to Pipeline's Do method along with passing a
+context.Context for cancelling the HTTP request (if desired).
+
+   type Pipeline interface {
+      Do(ctx context.Context, methodFactory pipeline.Factory, request pipeline.Request) (pipeline.Response, error)
+   }
+
+Do iterates over the slice of Factory objects and tells each one to create its corresponding
+Policy object. After the linked-list of Policy objects have been created, Do calls the first
+Policy object passing it the Context & HTTP request parameters. These parameters now flow through
+all the Policy objects giving each object a chance to look at and/or mutate the HTTP request.
+The last Policy object sends the message over the network.
+
+When the network operation completes, the HTTP response and error return values pass
+back through the same Policy objects in reverse order. Most Policy objects ignore the
+response/error but some log the result, retry the operation (depending on the exact
+reason the operation failed), or deserialize the response's body. Your own Policy
+objects can do whatever they like when processing outgoing requests or incoming responses.
+
+Note that after an I/O request runs to completion, the Policy objects for that request
+are garbage collected. However, Pipeline object (like Factory objects) are goroutine-safe allowing
+them to be created once and reused over many I/O operations. This allows for efficient use of
+memory and also makes them safely usable by multiple goroutines concurrently.
+
+Inserting a Method-Specific Factory into the Linked-List of Policy Objects
+
+While Pipeline and Factory objects can be reused over many different operations, it is
+common to have special behavior for a specific operation/method. For example, a method
+may need to deserialize the response's body to an instance of a specific data type.
+To accommodate this, the Pipeline's Do method takes an additional method-specific
+Factory object. The Do method tells this Factory to create a Policy object and
+injects this method-specific Policy object into the linked-list of Policy objects.
+
+When creating a Pipeline object, the slice of Factory objects passed must have 1
+(and only 1) entry marking where the method-specific Factory should be injected.
+The Factory marker is obtained by calling the pipeline.MethodFactoryMarker() function:
+
+   func MethodFactoryMarker() pipeline.Factory
+
+Creating an HTTP Request Object
+
+The HTTP request object passed to Pipeline's Do method is not Go's http.Request struct.
+Instead, it is a pipeline.Request struct which is a simple wrapper around Go's standard
+http.Request. You create a pipeline.Request object by calling the pipeline.NewRequest function:
+
+   func NewRequest(method string, url url.URL, options pipeline.RequestOptions) (request pipeline.Request, err error)
+
+To this function, you must pass a pipeline.RequestOptions that looks like this:
+
+   type RequestOptions struct {
+      // The readable and seekable stream to be sent to the server as the request's body.
+      Body io.ReadSeeker
+
+      // The callback method (if not nil) to be invoked to report progress as the stream is uploaded in the HTTP request.
+      Progress ProgressReceiver
+   }
+
+The method and struct ensure that the request's body stream is a read/seekable stream.
+A seekable stream is required so that upon retry, the final Policy object can seek
+the stream back to the beginning before retrying the network request and re-uploading the
+body. In addition, you can associate a ProgressReceiver callback function which will be
+invoked periodically to report progress while bytes are being read from the body stream
+and sent over the network.
+
+Processing the HTTP Response
+
+When an HTTP response comes in from the network, a reference to Go's http.Response struct is
+embedded in a struct that implements the pipeline.Response interface:
+
+   type Response interface {
+      Response() *http.Response
+   }
+
+This interface is returned through all the Policy objects. Each Policy object can call the Response
+interface's Response method to examine (or mutate) the embedded http.Response object.
+
+A Policy object can internally define another struct (implementing the pipeline.Response interface)
+that embeds an http.Response and adds additional fields and return this structure to other Policy
+objects. This allows a Policy object to deserialize the body to some other struct and return the
+original http.Response and the additional struct back through the Policy chain. Other Policy objects
+can see the Response but cannot see the additional struct with the deserialized body. After all the
+Policy objects have returned, the pipeline.Response interface is returned by Pipeline's Do method.
+The caller of this method can perform a type assertion attempting to get back to the struct type
+really returned by the Policy object. If the type assertion is successful, the caller now has
+access to both the http.Response and the deserialized struct object.*/
+package pipeline

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/error.go

@@ -0,0 +1,121 @@
+package pipeline
+
+import (
+	"fmt"
+	"runtime"
+)
+
+type causer interface {
+	Cause() error
+}
+
+// ErrorNode can be an embedded field in a private error object. This field
+// adds Program Counter support and a 'cause' (reference to a preceding error).
+// When initializing a error type with this embedded field, initialize the
+// ErrorNode field by calling ErrorNode{}.Initialize(cause).
+type ErrorNode struct {
+	pc    uintptr // Represents a Program Counter that you can get symbols for.
+	cause error   // Refers to the preceding error (or nil)
+}
+
+// Error returns a string with the PC's symbols or "" if the PC is invalid.
+// When defining a new error type, have its Error method call this one passing
+// it the string representation of the error.
+func (e *ErrorNode) Error(msg string) string {
+	s := ""
+	if fn := runtime.FuncForPC(e.pc); fn != nil {
+		file, line := fn.FileLine(e.pc)
+		s = fmt.Sprintf("-> %v, %v:%v\n", fn.Name(), file, line)
+	}
+	s += msg + "\n\n"
+	if e.cause != nil {
+		s += e.cause.Error() + "\n"
+	}
+	return s
+}
+
+// Cause returns the error that preceded this error.
+func (e *ErrorNode) Cause() error { return e.cause }
+
+// Temporary returns true if the error occurred due to a temporary condition.
+func (e ErrorNode) Temporary() bool {
+	type temporary interface {
+		Temporary() bool
+	}
+
+	for err := e.cause; err != nil; {
+		if t, ok := err.(temporary); ok {
+			return t.Temporary()
+		}
+
+		if cause, ok := err.(causer); ok {
+			err = cause.Cause()
+		} else {
+			err = nil
+		}
+	}
+	return false
+}
+
+// Timeout returns true if the error occurred due to time expiring.
+func (e ErrorNode) Timeout() bool {
+	type timeout interface {
+		Timeout() bool
+	}
+
+	for err := e.cause; err != nil; {
+		if t, ok := err.(timeout); ok {
+			return t.Timeout()
+		}
+
+		if cause, ok := err.(causer); ok {
+			err = cause.Cause()
+		} else {
+			err = nil
+		}
+	}
+	return false
+}
+
+// Initialize is used to initialize an embedded ErrorNode field.
+// It captures the caller's program counter and saves the cause (preceding error).
+// To initialize the field, use "ErrorNode{}.Initialize(cause, 3)". A callersToSkip
+// value of 3 is very common; but, depending on your code nesting, you may need
+// a different value.
+func (ErrorNode) Initialize(cause error, callersToSkip int) ErrorNode {
+	// Get the PC of Initialize method's caller.
+	pc := [1]uintptr{}
+	_ = runtime.Callers(callersToSkip, pc[:])
+	return ErrorNode{pc: pc[0], cause: cause}
+}
+
+// Cause walks all the preceding errors and return the originating error.
+func Cause(err error) error {
+	for err != nil {
+		cause, ok := err.(causer)
+		if !ok {
+			break
+		}
+		err = cause.Cause()
+	}
+	return err
+}
+
+// NewError creates a simple string error (like Error.New). But, this
+// error also captures the caller's Program Counter and the preceding error.
+func NewError(cause error, msg string) error {
+	return &pcError{
+		ErrorNode: ErrorNode{}.Initialize(cause, 3),
+		msg:       msg,
+	}
+}
+
+// pcError is a simple string error (like error.New) with an ErrorNode (PC & cause).
+type pcError struct {
+	ErrorNode
+	msg string
+}
+
+// Error satisfies the error interface. It shows the error with Program Counter
+// symbols and calls Error on the preceding error so you can see the full error chain.
+func (e *pcError) Error() string { return e.ErrorNode.Error(e.msg) }

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/progress.go

@@ -0,0 +1,82 @@
+package pipeline
+
+import "io"
+
+// ********** The following is common between the request body AND the response body.
+
+// ProgressReceiver defines the signature of a callback function invoked as progress is reported.
+type ProgressReceiver func(bytesTransferred int64)
+
+// ********** The following are specific to the request body (a ReadSeekCloser)
+
+// This struct is used when sending a body to the network
+type requestBodyProgress struct {
+	requestBody io.ReadSeeker // Seeking is required to support retries
+	pr          ProgressReceiver
+}
+
+// NewRequestBodyProgress adds progress reporting to an HTTP request's body stream.
+func NewRequestBodyProgress(requestBody io.ReadSeeker, pr ProgressReceiver) io.ReadSeeker {
+	if pr == nil {
+		panic("pr must not be nil")
+	}
+	return &requestBodyProgress{requestBody: requestBody, pr: pr}
+}
+
+// Read reads a block of data from an inner stream and reports progress
+func (rbp *requestBodyProgress) Read(p []byte) (n int, err error) {
+	n, err = rbp.requestBody.Read(p)
+	if err != nil {
+		return
+	}
+	// Invokes the user's callback method to report progress
+	position, err := rbp.requestBody.Seek(0, io.SeekCurrent)
+	if err != nil {
+		panic(err)
+	}
+	rbp.pr(position)
+	return
+}
+
+func (rbp *requestBodyProgress) Seek(offset int64, whence int) (offsetFromStart int64, err error) {
+	return rbp.requestBody.Seek(offset, whence)
+}
+
+// requestBodyProgress supports Close but the underlying stream may not; if it does, Close will close it.
+func (rbp *requestBodyProgress) Close() error {
+	if c, ok := rbp.requestBody.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+// ********** The following are specific to the response body (a ReadCloser)
+
+// This struct is used when sending a body to the network
+type responseBodyProgress struct {
+	responseBody io.ReadCloser
+	pr           ProgressReceiver
+	offset       int64
+}
+
+// NewResponseBodyProgress adds progress reporting to an HTTP response's body stream.
+func NewResponseBodyProgress(responseBody io.ReadCloser, pr ProgressReceiver) io.ReadCloser {
+	if pr == nil {
+		panic("pr must not be nil")
+	}
+	return &responseBodyProgress{responseBody: responseBody, pr: pr, offset: 0}
+}
+
+// Read reads a block of data from an inner stream and reports progress
+func (rbp *responseBodyProgress) Read(p []byte) (n int, err error) {
+	n, err = rbp.responseBody.Read(p)
+	rbp.offset += int64(n)
+
+	// Invokes the user's callback method to report progress
+	rbp.pr(rbp.offset)
+	return
+}
+
+func (rbp *responseBodyProgress) Close() error {
+	return rbp.responseBody.Close()
+}

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/request.go

@@ -0,0 +1,147 @@
+package pipeline
+
+import (
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+// Request is a thin wrapper over an http.Request. The wrapper provides several helper methods.
+type Request struct {
+	*http.Request
+}
+
+// NewRequest initializes a new HTTP request object with any desired options.
+func NewRequest(method string, url url.URL, body io.ReadSeeker) (request Request, err error) {
+	// Note: the url is passed by value so that any pipeline operations that modify it do so on a copy.
+
+	// This code to construct an http.Request is copied from http.NewRequest(); we intentionally omitted removeEmptyPort for now.
+	request.Request = &http.Request{
+		Method:     method,
+		URL:        &url,
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header:     make(http.Header),
+		Host:       url.Host,
+	}
+
+	if body != nil {
+		err = request.SetBody(body)
+	}
+	return
+}
+
+// SetBody sets the body and content length, assumes body is not nil.
+func (r Request) SetBody(body io.ReadSeeker) error {
+	size, err := body.Seek(0, io.SeekEnd)
+	if err != nil {
+		return err
+	}
+
+	body.Seek(0, io.SeekStart)
+	r.ContentLength = size
+	r.Header["Content-Length"] = []string{strconv.FormatInt(size, 10)}
+
+	if size != 0 {
+		r.Body = &retryableRequestBody{body: body}
+		r.GetBody = func() (io.ReadCloser, error) {
+			_, err := body.Seek(0, io.SeekStart)
+			if err != nil {
+				return nil, err
+			}
+			return r.Body, nil
+		}
+	} else {
+		// in case the body is an empty stream, we need to use http.NoBody to explicitly provide no content
+		r.Body = http.NoBody
+		r.GetBody = func() (io.ReadCloser, error) {
+			return http.NoBody, nil
+		}
+
+		// close the user-provided empty body
+		if c, ok := body.(io.Closer); ok {
+			c.Close()
+		}
+	}
+
+	return nil
+}
+
+// Copy makes a copy of an http.Request. Specifically, it makes a deep copy
+// of its Method, URL, Host, Proto(Major/Minor), Header. ContentLength, Close,
+// RemoteAddr, RequestURI. Copy makes a shallow copy of the Body, GetBody, TLS,
+// Cancel, Response, and ctx fields. Copy panics if any of these fields are
+// not nil: TransferEncoding, Form, PostForm, MultipartForm, or Trailer.
+func (r Request) Copy() Request {
+	if r.TransferEncoding != nil || r.Form != nil || r.PostForm != nil || r.MultipartForm != nil || r.Trailer != nil {
+		panic("Can't make a deep copy of the http.Request because at least one of the following is not nil:" +
+			"TransferEncoding, Form, PostForm, MultipartForm, or Trailer.")
+	}
+	copy := *r.Request          // Copy the request
+	urlCopy := *(r.Request.URL) // Copy the URL
+	copy.URL = &urlCopy
+	copy.Header = http.Header{} // Copy the header
+	for k, vs := range r.Header {
+		for _, value := range vs {
+			copy.Header.Add(k, value)
+		}
+	}
+	return Request{Request: &copy} // Return the copy
+}
+
+func (r Request) close() error {
+	if r.Body != nil && r.Body != http.NoBody {
+		c, ok := r.Body.(*retryableRequestBody)
+		if !ok {
+			panic("unexpected request body type (should be *retryableReadSeekerCloser)")
+		}
+		return c.realClose()
+	}
+	return nil
+}
+
+// RewindBody seeks the request's Body stream back to the beginning so it can be resent when retrying an operation.
+func (r Request) RewindBody() error {
+	if r.Body != nil && r.Body != http.NoBody {
+		s, ok := r.Body.(io.Seeker)
+		if !ok {
+			panic("unexpected request body type (should be io.Seeker)")
+		}
+
+		// Reset the stream back to the beginning
+		_, err := s.Seek(0, io.SeekStart)
+		return err
+	}
+	return nil
+}
+
+// ********** The following type/methods implement the retryableRequestBody (a ReadSeekCloser)
+
+// This struct is used when sending a body to the network
+type retryableRequestBody struct {
+	body io.ReadSeeker // Seeking is required to support retries
+}
+
+// Read reads a block of data from an inner stream and reports progress
+func (b *retryableRequestBody) Read(p []byte) (n int, err error) {
+	return b.body.Read(p)
+}
+
+func (b *retryableRequestBody) Seek(offset int64, whence int) (offsetFromStart int64, err error) {
+	return b.body.Seek(offset, whence)
+}
+
+func (b *retryableRequestBody) Close() error {
+	// We don't want the underlying transport to close the request body on transient failures so this is a nop.
+	// The pipeline closes the request body upon success.
+	return nil
+}
+
+func (b *retryableRequestBody) realClose() error {
+	if c, ok := b.body.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/response.go

@@ -0,0 +1,74 @@
+package pipeline
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+// The Response interface exposes an http.Response object as it returns through the pipeline of Policy objects.
+// This ensures that Policy objects have access to the HTTP response. However, the object this interface encapsulates
+// might be a struct with additional fields that is created by a Policy object (typically a method-specific Factory).
+// The method that injected the method-specific Factory gets this returned Response and performs a type assertion
+// to the expected struct and returns the struct to its caller.
+type Response interface {
+	Response() *http.Response
+}
+
+// This is the default struct that has the http.Response.
+// A method can replace this struct with its own struct containing an http.Response
+// field and any other additional fields.
+type httpResponse struct {
+	response *http.Response
+}
+
+// NewHTTPResponse is typically called by a Policy object to return a Response object.
+func NewHTTPResponse(response *http.Response) Response {
+	return &httpResponse{response: response}
+}
+
+// This method satisfies the public Response interface's Response method
+func (r httpResponse) Response() *http.Response {
+	return r.response
+}
+
+// WriteRequestWithResponse appends a formatted HTTP request into a Buffer. If request and/or err are
+// not nil, then these are also written into the Buffer.
+func WriteRequestWithResponse(b *bytes.Buffer, request *http.Request, response *http.Response, err error) {
+	// Write the request into the buffer.
+	fmt.Fprint(b, "   "+request.Method+" "+request.URL.String()+"\n")
+	writeHeader(b, request.Header)
+	if response != nil {
+		fmt.Fprintln(b, "   --------------------------------------------------------------------------------")
+		fmt.Fprint(b, "   RESPONSE Status: "+response.Status+"\n")
+		writeHeader(b, response.Header)
+	}
+	if err != nil {
+		fmt.Fprintln(b, "   --------------------------------------------------------------------------------")
+		fmt.Fprint(b, "   ERROR:\n"+err.Error()+"\n")
+	}
+}
+
+// formatHeaders appends an HTTP request's or response's header into a Buffer.
+func writeHeader(b *bytes.Buffer, header map[string][]string) {
+	if len(header) == 0 {
+		b.WriteString("   (no headers)\n")
+		return
+	}
+	keys := make([]string, 0, len(header))
+	// Alphabetize the headers
+	for k := range header {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		// Redact the value of any Authorization header to prevent security information from persisting in logs
+		value := interface{}("REDACTED")
+		if !strings.EqualFold(k, "Authorization") {
+			value = header[k]
+		}
+		fmt.Fprintf(b, "   %s: %+v\n", k, value)
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-pipeline-go/pipeline/version.go

@@ -0,0 +1,9 @@
+package pipeline
+
+const (
+	// UserAgent is the string to be used in the user agent string when making requests.
+	UserAgent = "azure-pipeline-go/" + Version
+
+	// Version is the semantic version (see http://semver.org) of the pipeline package.
+	Version = "0.1.0"
+)

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/access_conditions.go

@@ -0,0 +1,67 @@
+package azblob
+
+import (
+	"time"
+)
+
+// HTTPAccessConditions identifies standard HTTP access conditions which you optionally set.
+type HTTPAccessConditions struct {
+	IfModifiedSince   time.Time
+	IfUnmodifiedSince time.Time
+	IfMatch           ETag
+	IfNoneMatch       ETag
+}
+
+// pointers is for internal infrastructure. It returns the fields as pointers.
+func (ac HTTPAccessConditions) pointers() (ims *time.Time, ius *time.Time, ime *ETag, inme *ETag) {
+	if !ac.IfModifiedSince.IsZero() {
+		ims = &ac.IfModifiedSince
+	}
+	if !ac.IfUnmodifiedSince.IsZero() {
+		ius = &ac.IfUnmodifiedSince
+	}
+	if ac.IfMatch != ETagNone {
+		ime = &ac.IfMatch
+	}
+	if ac.IfNoneMatch != ETagNone {
+		inme = &ac.IfNoneMatch
+	}
+	return
+}
+
+// ContainerAccessConditions identifies container-specific access conditions which you optionally set.
+type ContainerAccessConditions struct {
+	HTTPAccessConditions
+	LeaseAccessConditions
+}
+
+// BlobAccessConditions identifies blob-specific access conditions which you optionally set.
+type BlobAccessConditions struct {
+	HTTPAccessConditions
+	LeaseAccessConditions
+	AppendBlobAccessConditions
+	PageBlobAccessConditions
+}
+
+// LeaseAccessConditions identifies lease access conditions for a container or blob which you optionally set.
+type LeaseAccessConditions struct {
+	LeaseID string
+}
+
+// pointers is for internal infrastructure. It returns the fields as pointers.
+func (ac LeaseAccessConditions) pointers() (leaseID *string) {
+	if ac.LeaseID != "" {
+		leaseID = &ac.LeaseID
+	}
+	return
+}
+
+/*
+// getInt32 is for internal infrastructure. It is used with access condition values where
+// 0 (the default setting) is meaningful. The library interprets 0 as do not send the header
+// and the privately-storage field in the access condition object is stored as +1 higher than desired.
+// THis method returns true, if the value is > 0 (explicitly set) and the stored value - 1 (the set desired value).
+func getInt32(value int32) (bool, int32) {
+	return value > 0, value - 1
+}
+*/

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/atomicmorph.go

@@ -0,0 +1,79 @@
+package azblob
+
+import "sync/atomic"
+
+// AtomicMorpherInt32 identifies a method passed to and invoked by the AtomicMorphInt32 function.
+// The AtomicMorpher callback is passed a startValue and based on this value it returns
+// what the new value should be and the result that AtomicMorph should return to its caller.
+type AtomicMorpherInt32 func(startVal int32) (val int32, morphResult interface{})
+
+// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
+func AtomicMorphInt32(target *int32, morpher AtomicMorpherInt32) interface{} {
+	if target == nil || morpher == nil {
+		panic("target and morpher mut not be nil")
+	}
+	for {
+		currentVal := atomic.LoadInt32(target)
+		desiredVal, morphResult := morpher(currentVal)
+		if atomic.CompareAndSwapInt32(target, currentVal, desiredVal) {
+			return morphResult
+		}
+	}
+}
+
+// AtomicMorpherUint32 identifies a method passed to and invoked by the AtomicMorph function.
+// The AtomicMorpher callback is passed a startValue and based on this value it returns
+// what the new value should be and the result that AtomicMorph should return to its caller.
+type AtomicMorpherUint32 func(startVal uint32) (val uint32, morphResult interface{})
+
+// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
+func AtomicMorphUint32(target *uint32, morpher AtomicMorpherUint32) interface{} {
+	if target == nil || morpher == nil {
+		panic("target and morpher mut not be nil")
+	}
+	for {
+		currentVal := atomic.LoadUint32(target)
+		desiredVal, morphResult := morpher(currentVal)
+		if atomic.CompareAndSwapUint32(target, currentVal, desiredVal) {
+			return morphResult
+		}
+	}
+}
+
+// AtomicMorpherUint64 identifies a method passed to and invoked by the AtomicMorphUint64 function.
+// The AtomicMorpher callback is passed a startValue and based on this value it returns
+// what the new value should be and the result that AtomicMorph should return to its caller.
+type AtomicMorpherInt64 func(startVal int64) (val int64, morphResult interface{})
+
+// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
+func AtomicMorphInt64(target *int64, morpher AtomicMorpherInt64) interface{} {
+	if target == nil || morpher == nil {
+		panic("target and morpher mut not be nil")
+	}
+	for {
+		currentVal := atomic.LoadInt64(target)
+		desiredVal, morphResult := morpher(currentVal)
+		if atomic.CompareAndSwapInt64(target, currentVal, desiredVal) {
+			return morphResult
+		}
+	}
+}
+
+// AtomicMorpherUint64 identifies a method passed to and invoked by the AtomicMorphUint64 function.
+// The AtomicMorpher callback is passed a startValue and based on this value it returns
+// what the new value should be and the result that AtomicMorph should return to its caller.
+type AtomicMorpherUint64 func(startVal uint64) (val uint64, morphResult interface{})
+
+// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
+func AtomicMorphUint64(target *uint64, morpher AtomicMorpherUint64) interface{} {
+	if target == nil || morpher == nil {
+		panic("target and morpher mut not be nil")
+	}
+	for {
+		currentVal := atomic.LoadUint64(target)
+		desiredVal, morphResult := morpher(currentVal)
+		if atomic.CompareAndSwapUint64(target, currentVal, desiredVal) {
+			return morphResult
+		}
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/highlevel.go

@@ -0,0 +1,510 @@
+package azblob
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"net/http"
+
+	"bytes"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// CommonResponseHeaders returns the headers common to all blob REST API responses.
+type CommonResponse interface {
+	// ETag returns the value for header ETag.
+	ETag() ETag
+
+	// LastModified returns the value for header Last-Modified.
+	LastModified() time.Time
+
+	// RequestID returns the value for header x-ms-request-id.
+	RequestID() string
+
+	// Date returns the value for header Date.
+	Date() time.Time
+
+	// Version returns the value for header x-ms-version.
+	Version() string
+
+	// Response returns the raw HTTP response object.
+	Response() *http.Response
+}
+
+// UploadToBlockBlobOptions identifies options used by the UploadBufferToBlockBlob and UploadFileToBlockBlob functions.
+type UploadToBlockBlobOptions struct {
+	// BlockSize specifies the block size to use; the default (and maximum size) is BlockBlobMaxStageBlockBytes.
+	BlockSize int64
+
+	// Progress is a function that is invoked periodically as bytes are sent to the BlockBlobURL.
+	Progress pipeline.ProgressReceiver
+
+	// BlobHTTPHeaders indicates the HTTP headers to be associated with the blob.
+	BlobHTTPHeaders BlobHTTPHeaders
+
+	// Metadata indicates the metadata to be associated with the blob when PutBlockList is called.
+	Metadata Metadata
+
+	// AccessConditions indicates the access conditions for the block blob.
+	AccessConditions BlobAccessConditions
+
+	// Parallelism indicates the maximum number of blocks to upload in parallel (0=default)
+	Parallelism uint16
+}
+
+// UploadBufferToBlockBlob uploads a buffer in blocks to a block blob.
+func UploadBufferToBlockBlob(ctx context.Context, b []byte,
+	blockBlobURL BlockBlobURL, o UploadToBlockBlobOptions) (CommonResponse, error) {
+
+	// Validate parameters and set defaults
+	if o.BlockSize < 0 || o.BlockSize > BlockBlobMaxUploadBlobBytes {
+		panic(fmt.Sprintf("BlockSize option must be > 0 and <= %d", BlockBlobMaxUploadBlobBytes))
+	}
+	if o.BlockSize == 0 {
+		o.BlockSize = BlockBlobMaxUploadBlobBytes // Default if unspecified
+	}
+	size := int64(len(b))
+
+	if size <= BlockBlobMaxUploadBlobBytes {
+		// If the size can fit in 1 Upload call, do it this way
+		var body io.ReadSeeker = bytes.NewReader(b)
+		if o.Progress != nil {
+			body = pipeline.NewRequestBodyProgress(body, o.Progress)
+		}
+		return blockBlobURL.Upload(ctx, body, o.BlobHTTPHeaders, o.Metadata, o.AccessConditions)
+	}
+
+	var numBlocks = uint16(((size - 1) / o.BlockSize) + 1)
+	if numBlocks > BlockBlobMaxBlocks {
+		panic(fmt.Sprintf("The buffer's size is too big or the BlockSize is too small; the number of blocks must be <= %d", BlockBlobMaxBlocks))
+	}
+
+	blockIDList := make([]string, numBlocks) // Base-64 encoded block IDs
+	progress := int64(0)
+	progressLock := &sync.Mutex{}
+
+	err := doBatchTransfer(ctx, batchTransferOptions{
+		operationName: "UploadBufferToBlockBlob",
+		transferSize:  size,
+		chunkSize:     o.BlockSize,
+		parallelism:   o.Parallelism,
+		operation: func(offset int64, count int64) error {
+			// This function is called once per block.
+			// It is passed this block's offset within the buffer and its count of bytes
+			// Prepare to read the proper block/section of the buffer
+			var body io.ReadSeeker = bytes.NewReader(b[offset : offset+count])
+			blockNum := offset / o.BlockSize
+			if o.Progress != nil {
+				blockProgress := int64(0)
+				body = pipeline.NewRequestBodyProgress(body,
+					func(bytesTransferred int64) {
+						diff := bytesTransferred - blockProgress
+						blockProgress = bytesTransferred
+						progressLock.Lock() // 1 goroutine at a time gets a progress report
+						progress += diff
+						o.Progress(progress)
+						progressLock.Unlock()
+					})
+			}
+
+			// Block IDs are unique values to avoid issue if 2+ clients are uploading blocks
+			// at the same time causing PutBlockList to get a mix of blocks from all the clients.
+			blockIDList[blockNum] = base64.StdEncoding.EncodeToString(newUUID().bytes())
+			_, err := blockBlobURL.StageBlock(ctx, blockIDList[blockNum], body, o.AccessConditions.LeaseAccessConditions)
+			return err
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	// All put blocks were successful, call Put Block List to finalize the blob
+	return blockBlobURL.CommitBlockList(ctx, blockIDList, o.BlobHTTPHeaders, o.Metadata, o.AccessConditions)
+}
+
+// UploadFileToBlockBlob uploads a file in blocks to a block blob.
+func UploadFileToBlockBlob(ctx context.Context, file *os.File,
+	blockBlobURL BlockBlobURL, o UploadToBlockBlobOptions) (CommonResponse, error) {
+
+	stat, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+	m := mmf{} // Default to an empty slice; used for 0-size file
+	if stat.Size() != 0 {
+		m, err = newMMF(file, false, 0, int(stat.Size()))
+		if err != nil {
+			return nil, err
+		}
+		defer m.unmap()
+	}
+	return UploadBufferToBlockBlob(ctx, m, blockBlobURL, o)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+const BlobDefaultDownloadBlockSize = int64(4 * 1024 * 1024) // 4MB
+
+// DownloadFromAzureFileOptions identifies options used by the DownloadAzureFileToBuffer and DownloadAzureFileToFile functions.
+type DownloadFromBlobOptions struct {
+	// BlockSize specifies the block size to use for each parallel download; the default size is BlobDefaultDownloadBlockSize.
+	BlockSize int64
+
+	// Progress is a function that is invoked periodically as bytes are received.
+	Progress pipeline.ProgressReceiver
+
+	// AccessConditions indicates the access conditions used when making HTTP GET requests against the blob.
+	AccessConditions BlobAccessConditions
+
+	// Parallelism indicates the maximum number of blocks to download in parallel (0=default)
+	Parallelism uint16
+
+	// RetryReaderOptionsPerBlock is used when downloading each block.
+	RetryReaderOptionsPerBlock RetryReaderOptions
+}
+
+// downloadAzureFileToBuffer downloads an Azure file to a buffer with parallel.
+func downloadBlobToBuffer(ctx context.Context, blobURL BlobURL, offset int64, count int64,
+	ac BlobAccessConditions, b []byte, o DownloadFromBlobOptions,
+	initialDownloadResponse *DownloadResponse) error {
+	// Validate parameters, and set defaults.
+	if o.BlockSize < 0 {
+		panic("BlockSize option must be >= 0")
+	}
+	if o.BlockSize == 0 {
+		o.BlockSize = BlobDefaultDownloadBlockSize
+	}
+
+	if offset < 0 {
+		panic("offset option must be >= 0")
+	}
+
+	if count < 0 {
+		panic("count option must be >= 0")
+	}
+
+	if count == CountToEnd { // If size not specified, calculate it
+		if initialDownloadResponse != nil {
+			count = initialDownloadResponse.ContentLength() - offset // if we have the length, use it
+		} else {
+			// If we don't have the length at all, get it
+			dr, err := blobURL.Download(ctx, 0, CountToEnd, ac, false)
+			if err != nil {
+				return err
+			}
+			count = dr.ContentLength() - offset
+		}
+	}
+
+	if int64(len(b)) < count {
+		panic(fmt.Errorf("the buffer's size should be equal to or larger than the request count of bytes: %d", count))
+	}
+
+	// Prepare and do parallel download.
+	progress := int64(0)
+	progressLock := &sync.Mutex{}
+
+	err := doBatchTransfer(ctx, batchTransferOptions{
+		operationName: "downloadBlobToBuffer",
+		transferSize:    count,
+		chunkSize:     o.BlockSize,
+		parallelism:   o.Parallelism,
+		operation: func(chunkStart int64, count int64) error {
+			dr, err := blobURL.Download(ctx, chunkStart+ offset, count, ac, false)
+			body := dr.Body(o.RetryReaderOptionsPerBlock)
+			if o.Progress != nil {
+				rangeProgress := int64(0)
+				body = pipeline.NewResponseBodyProgress(
+					body,
+					func(bytesTransferred int64) {
+						diff := bytesTransferred - rangeProgress
+						rangeProgress = bytesTransferred
+						progressLock.Lock()
+						progress += diff
+						o.Progress(progress)
+						progressLock.Unlock()
+					})
+			}
+			_, err = io.ReadFull(body, b[chunkStart:chunkStart+count])
+			body.Close()
+			return err
+		},
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// DownloadAzureFileToBuffer downloads an Azure file to a buffer with parallel.
+// Offset and count are optional, pass 0 for both to download the entire blob.
+func DownloadBlobToBuffer(ctx context.Context, blobURL BlobURL, offset int64, count int64,
+	ac BlobAccessConditions, b []byte, o DownloadFromBlobOptions) error {
+	return downloadBlobToBuffer(ctx, blobURL, offset, count, ac, b, o, nil)
+}
+
+// DownloadBlobToFile downloads an Azure file to a local file.
+// The file would be truncated if the size doesn't match.
+// Offset and count are optional, pass 0 for both to download the entire blob.
+func DownloadBlobToFile(ctx context.Context, blobURL BlobURL, offset int64, count int64,
+	ac BlobAccessConditions, file *os.File, o DownloadFromBlobOptions) error {
+	// 1. Validate parameters.
+	if file == nil {
+		panic("file must not be nil")
+	}
+
+	// 2. Calculate the size of the destination file
+	var size int64
+
+	if count == CountToEnd {
+		// Try to get Azure file's size
+		props, err := blobURL.GetProperties(ctx, ac)
+		if err != nil {
+			return err
+		}
+		size = props.ContentLength() - offset
+	} else {
+		size = count
+	}
+
+	// 3. Compare and try to resize local file's size if it doesn't match Azure file's size.
+	stat, err := file.Stat()
+	if err != nil {
+		return err
+	}
+	if stat.Size() != size {
+		if err = file.Truncate(size); err != nil {
+			return err
+		}
+	}
+
+	if size > 0 {
+		// 4. Set mmap and call DownloadAzureFileToBuffer.
+		m, err := newMMF(file, true, 0, int(size))
+		if err != nil {
+			return err
+		}
+		defer m.unmap()
+		return downloadBlobToBuffer(ctx, blobURL, offset, size, ac, m, o, nil)
+	} else { // if the blob's size is 0, there is no need in downloading it
+		return nil
+	}
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+// BatchTransferOptions identifies options used by doBatchTransfer.
+type batchTransferOptions struct {
+	transferSize  int64
+	chunkSize     int64
+	parallelism   uint16
+	operation     func(offset int64, chunkSize int64) error
+	operationName string
+}
+
+// doBatchTransfer helps to execute operations in a batch manner.
+func doBatchTransfer(ctx context.Context, o batchTransferOptions) error {
+	// Prepare and do parallel operations.
+	numChunks := uint16(((o.transferSize - 1) / o.chunkSize) + 1)
+	operationChannel := make(chan func() error, o.parallelism) // Create the channel that release 'parallelism' goroutines concurrently
+	operationResponseChannel := make(chan error, numChunks)    // Holds each response
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	// Create the goroutines that process each operation (in parallel).
+	if o.parallelism == 0 {
+		o.parallelism = 5 // default parallelism
+	}
+	for g := uint16(0); g < o.parallelism; g++ {
+		//grIndex := g
+		go func() {
+			for f := range operationChannel {
+				//fmt.Printf("[%s] gr-%d start action\n", o.operationName, grIndex)
+				err := f()
+				operationResponseChannel <- err
+				//fmt.Printf("[%s] gr-%d end action\n", o.operationName, grIndex)
+			}
+		}()
+	}
+
+	// Add each chunk's operation to the channel.
+	for chunkNum := uint16(0); chunkNum < numChunks; chunkNum++ {
+		curChunkSize := o.chunkSize
+
+		if chunkNum == numChunks-1 { // Last chunk
+			curChunkSize = o.transferSize - (int64(chunkNum) * o.chunkSize) // Remove size of all transferred chunks from total
+		}
+		offset := int64(chunkNum) * o.chunkSize
+
+		operationChannel <- func() error {
+			return o.operation(offset, curChunkSize)
+		}
+	}
+	close(operationChannel)
+
+	// Wait for the operations to complete.
+	for chunkNum := uint16(0); chunkNum < numChunks; chunkNum++ {
+		responseError := <-operationResponseChannel
+		if responseError != nil {
+			cancel()             // As soon as any operation fails, cancel all remaining operation calls
+			return responseError // No need to process anymore responses
+		}
+	}
+	return nil
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+type UploadStreamToBlockBlobOptions struct {
+	BufferSize       int
+	MaxBuffers       int
+	BlobHTTPHeaders  BlobHTTPHeaders
+	Metadata         Metadata
+	AccessConditions BlobAccessConditions
+}
+
+func UploadStreamToBlockBlob(ctx context.Context, reader io.Reader, blockBlobURL BlockBlobURL,
+	o UploadStreamToBlockBlobOptions) (CommonResponse, error) {
+	result, err := uploadStream(ctx, reader,
+		UploadStreamOptions{BufferSize: o.BufferSize, MaxBuffers: o.MaxBuffers},
+		&uploadStreamToBlockBlobOptions{b: blockBlobURL, o: o, blockIDPrefix: newUUID()})
+	return result.(CommonResponse), err
+}
+
+type uploadStreamToBlockBlobOptions struct {
+	b             BlockBlobURL
+	o             UploadStreamToBlockBlobOptions
+	blockIDPrefix uuid   // UUID used with all blockIDs
+	maxBlockNum   uint32 // defaults to 0
+	firstBlock    []byte // Used only if maxBlockNum is 0
+}
+
+func (t *uploadStreamToBlockBlobOptions) start(ctx context.Context) (interface{}, error) {
+	return nil, nil
+}
+
+func (t *uploadStreamToBlockBlobOptions) chunk(ctx context.Context, num uint32, buffer []byte) error {
+	if num == 0 && len(buffer) < t.o.BufferSize {
+		// If whole payload fits in 1 block, don't stage it; End will upload it with 1 I/O operation
+		t.firstBlock = buffer
+		return nil
+	}
+	// Else, upload a staged block...
+	AtomicMorphUint32(&t.maxBlockNum, func(startVal uint32) (val uint32, morphResult interface{}) {
+		// Atomically remember (in t.numBlocks) the maximum block num we've ever seen
+		if startVal < num {
+			return num, nil
+		}
+		return startVal, nil
+	})
+	blockID := newUuidBlockID(t.blockIDPrefix).WithBlockNumber(num).ToBase64()
+	_, err := t.b.StageBlock(ctx, blockID, bytes.NewReader(buffer), LeaseAccessConditions{})
+	return err
+}
+
+func (t *uploadStreamToBlockBlobOptions) end(ctx context.Context) (interface{}, error) {
+	if t.maxBlockNum == 0 {
+		// If whole payload fits in 1 block (block #0), upload it with 1 I/O operation
+		return t.b.Upload(ctx, bytes.NewReader(t.firstBlock),
+			t.o.BlobHTTPHeaders, t.o.Metadata, t.o.AccessConditions)
+	}
+	// Multiple blocks staged, commit them all now
+	blockID := newUuidBlockID(t.blockIDPrefix)
+	blockIDs := make([]string, t.maxBlockNum + 1)
+	for bn := uint32(0); bn <= t.maxBlockNum; bn++ {
+		blockIDs[bn] = blockID.WithBlockNumber(bn).ToBase64()
+	}
+	return t.b.CommitBlockList(ctx, blockIDs, t.o.BlobHTTPHeaders, t.o.Metadata, t.o.AccessConditions)
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type iTransfer interface {
+	start(ctx context.Context) (interface{}, error)
+	chunk(ctx context.Context, num uint32, buffer []byte) error
+	end(ctx context.Context) (interface{}, error)
+}
+
+type UploadStreamOptions struct {
+	MaxBuffers int
+	BufferSize int
+}
+
+func uploadStream(ctx context.Context, reader io.Reader, o UploadStreamOptions, t iTransfer) (interface{}, error) {
+	ctx, cancel := context.WithCancel(ctx) // New context so that any failure cancels everything
+	defer cancel()
+	wg := sync.WaitGroup{} // Used to know when all outgoing messages have finished processing
+	type OutgoingMsg struct {
+		chunkNum uint32
+		buffer   []byte
+	}
+
+	// Create a channel to hold the buffers usable for incoming datsa
+	incoming := make(chan []byte, o.MaxBuffers)
+	outgoing := make(chan OutgoingMsg, o.MaxBuffers) // Channel holding outgoing buffers
+	if result, err := t.start(ctx); err != nil {
+		return result, err
+	}
+
+	numBuffers := 0 // The number of buffers & out going goroutines created so far
+	injectBuffer := func() {
+		// For each Buffer, create it and a goroutine to upload it
+		incoming <- make([]byte, o.BufferSize) // Add the new buffer to the incoming channel so this goroutine can from the reader into it
+		numBuffers++
+		go func() {
+			for outgoingMsg := range outgoing {
+				// Upload the outgoing buffer
+				err := t.chunk(ctx, outgoingMsg.chunkNum, outgoingMsg.buffer)
+				wg.Done() // Indicate this buffer was sent
+				if nil != err {
+					cancel()
+				}
+				incoming <- outgoingMsg.buffer // The goroutine reading from the stream can use reuse this buffer now
+			}
+		}()
+	}
+	injectBuffer() // Create our 1st buffer & outgoing goroutine
+
+	// This goroutine grabs a buffer, reads from the stream into the buffer,
+	// and inserts the buffer into the outgoing channel to be uploaded
+	for c := uint32(0); true; c++ { // Iterate once per chunk
+		var buffer []byte
+		if numBuffers < o.MaxBuffers {
+			select {
+			// We're not at max buffers, see if a previously-created buffer is available
+			case buffer = <-incoming:
+				break
+			default:
+				// No buffer available; inject a new buffer & go routine to process it
+				injectBuffer()
+				buffer = <-incoming // Grab the just-injected buffer
+			}
+		} else {
+			// We are at max buffers, block until we get to reuse one
+			buffer = <-incoming
+		}
+		n, err := io.ReadFull(reader, buffer)
+		if err != nil {
+			buffer = buffer[:n] // Make slice match the # of read bytes
+		}
+		if len(buffer) > 0 {
+			// Buffer not empty, upload it
+			wg.Add(1) // We're posting a buffer to be sent
+			outgoing <- OutgoingMsg{chunkNum: c, buffer: buffer}
+		}
+		if err != nil { // The reader is done, no more outgoing buffers
+			break
+		}
+	}
+	// NOTE: Don't close the incoming channel because the outgoing goroutines post buffers into it when they are done
+	close(outgoing) // Make all the outgoing goroutines terminate when this channel is empty
+	wg.Wait()       // Wait for all pending outgoing messages to complete
+	// After all blocks uploaded, commit them to the blob & return the result
+	return t.end(ctx)
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/parsing_urls.go

@@ -0,0 +1,111 @@
+package azblob
+
+import (
+	"net/url"
+	"strings"
+)
+
+const (
+	snapshot           = "snapshot"
+	SnapshotTimeFormat = "2006-01-02T15:04:05.0000000Z07:00"
+)
+
+// A BlobURLParts object represents the components that make up an Azure Storage Container/Blob URL. You parse an
+// existing URL into its parts by calling NewBlobURLParts(). You construct a URL from parts by calling URL().
+// NOTE: Changing any SAS-related field requires computing a new SAS signature.
+type BlobURLParts struct {
+	Scheme         string // Ex: "https://"
+	Host           string // Ex: "account.blob.core.windows.net"
+	ContainerName  string // "" if no container
+	BlobName       string // "" if no blob
+	Snapshot       string // "" if not a snapshot
+	SAS            SASQueryParameters
+	UnparsedParams string
+}
+
+// NewBlobURLParts parses a URL initializing BlobURLParts' fields including any SAS-related & snapshot query parameters. Any other
+// query parameters remain in the UnparsedParams field. This method overwrites all fields in the BlobURLParts object.
+func NewBlobURLParts(u url.URL) BlobURLParts {
+	up := BlobURLParts{
+		Scheme: u.Scheme,
+		Host:   u.Host,
+	}
+
+	// Find the container & blob names (if any)
+	if u.Path != "" {
+		path := u.Path
+		if path[0] == '/' {
+			path = path[1:] // If path starts with a slash, remove it
+		}
+
+		// Find the next slash (if it exists)
+		containerEndIndex := strings.Index(path, "/")
+		if containerEndIndex == -1 { // Slash not found; path has container name & no blob name
+			up.ContainerName = path
+		} else {
+			up.ContainerName = path[:containerEndIndex] // The container name is the part between the slashes
+			up.BlobName = path[containerEndIndex+1:]    // The blob name is after the container slash
+		}
+	}
+
+	// Convert the query parameters to a case-sensitive map & trim whitespace
+	paramsMap := u.Query()
+
+	up.Snapshot = "" // Assume no snapshot
+	if snapshotStr, ok := caseInsensitiveValues(paramsMap).Get(snapshot); ok {
+		up.Snapshot = snapshotStr[0]
+		// If we recognized the query parameter, remove it from the map
+		delete(paramsMap, snapshot)
+	}
+	up.SAS = newSASQueryParameters(paramsMap, true)
+	up.UnparsedParams = paramsMap.Encode()
+	return up
+}
+
+type caseInsensitiveValues url.Values // map[string][]string
+func (values caseInsensitiveValues) Get(key string) ([]string, bool) {
+	key = strings.ToLower(key)
+	for k, v := range values {
+		if strings.ToLower(k) == key {
+			return v, true
+		}
+	}
+	return []string{}, false
+}
+
+// URL returns a URL object whose fields are initialized from the BlobURLParts fields. The URL's RawQuery
+// field contains the SAS, snapshot, and unparsed query parameters.
+func (up BlobURLParts) URL() url.URL {
+	path := ""
+	// Concatenate container & blob names (if they exist)
+	if up.ContainerName != "" {
+		path += "/" + up.ContainerName
+		if up.BlobName != "" {
+			path += "/" + up.BlobName
+		}
+	}
+
+	rawQuery := up.UnparsedParams
+
+	// Concatenate blob snapshot query parameter (if it exists)
+	if up.Snapshot != "" {
+		if len(rawQuery) > 0 {
+			rawQuery += "&"
+		}
+		rawQuery += snapshot + "=" + up.Snapshot
+	}
+	sas := up.SAS.Encode()
+	if sas != "" {
+		if len(rawQuery) > 0 {
+			rawQuery += "&"
+		}
+		rawQuery += sas
+	}
+	u := url.URL{
+		Scheme:   up.Scheme,
+		Host:     up.Host,
+		Path:     path,
+		RawQuery: rawQuery,
+	}
+	return u
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/sas_service.go

@@ -0,0 +1,206 @@
+package azblob
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// BlobSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage container or blob.
+type BlobSASSignatureValues struct {
+	Version            string      `param:"sv"`  // If not specified, this defaults to SASVersion
+	Protocol           SASProtocol `param:"spr"` // See the SASProtocol* constants
+	StartTime          time.Time   `param:"st"`  // Not specified if IsZero
+	ExpiryTime         time.Time   `param:"se"`  // Not specified if IsZero
+	Permissions        string      `param:"sp"`  // Create by initializing a ContainerSASPermissions or BlobSASPermissions and then call String()
+	IPRange            IPRange     `param:"sip"`
+	Identifier         string      `param:"si"`
+	ContainerName      string
+	BlobName           string // Use "" to create a Container SAS
+	CacheControl       string // rscc
+	ContentDisposition string // rscd
+	ContentEncoding    string // rsce
+	ContentLanguage    string // rscl
+	ContentType        string // rsct
+}
+
+// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
+// the proper SAS query parameters.
+func (v BlobSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
+	if sharedKeyCredential == nil {
+		panic("sharedKeyCredential can't be nil")
+	}
+
+	resource := "c"
+	if v.BlobName == "" {
+		// Make sure the permission characters are in the correct order
+		perms := &ContainerSASPermissions{}
+		if err := perms.Parse(v.Permissions); err != nil {
+			panic(err)
+		}
+		v.Permissions = perms.String()
+	} else {
+		resource = "b"
+		// Make sure the permission characters are in the correct order
+		perms := &BlobSASPermissions{}
+		if err := perms.Parse(v.Permissions); err != nil {
+			panic(err)
+		}
+		v.Permissions = perms.String()
+	}
+	if v.Version == "" {
+		v.Version = SASVersion
+	}
+	startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
+
+	// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
+	stringToSign := strings.Join([]string{
+		v.Permissions,
+		startTime,
+		expiryTime,
+		getCanonicalName(sharedKeyCredential.AccountName(), v.ContainerName, v.BlobName),
+		v.Identifier,
+		v.IPRange.String(),
+		string(v.Protocol),
+		v.Version,
+		v.CacheControl,       // rscc
+		v.ContentDisposition, // rscd
+		v.ContentEncoding,    // rsce
+		v.ContentLanguage,    // rscl
+		v.ContentType},       // rsct
+		"\n")
+	signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
+
+	p := SASQueryParameters{
+		// Common SAS parameters
+		version:     v.Version,
+		protocol:    v.Protocol,
+		startTime:   v.StartTime,
+		expiryTime:  v.ExpiryTime,
+		permissions: v.Permissions,
+		ipRange:     v.IPRange,
+
+		// Container/Blob-specific SAS parameters
+		resource:   resource,
+		identifier: v.Identifier,
+
+		// Calculated SAS signature
+		signature: signature,
+	}
+	return p
+}
+
+// getCanonicalName computes the canonical name for a container or blob resource for SAS signing.
+func getCanonicalName(account string, containerName string, blobName string) string {
+	// Container: "/blob/account/containername"
+	// Blob:      "/blob/account/containername/blobname"
+	elements := []string{"/blob/", account, "/", containerName}
+	if blobName != "" {
+		elements = append(elements, "/", strings.Replace(blobName, "\\", "/", -1))
+	}
+	return strings.Join(elements, "")
+}
+
+// The ContainerSASPermissions type simplifies creating the permissions string for an Azure Storage container SAS.
+// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
+type ContainerSASPermissions struct {
+	Read, Add, Create, Write, Delete, List bool
+}
+
+// String produces the SAS permissions string for an Azure Storage container.
+// Call this method to set BlobSASSignatureValues's Permissions field.
+func (p ContainerSASPermissions) String() string {
+	var b bytes.Buffer
+	if p.Read {
+		b.WriteRune('r')
+	}
+	if p.Add {
+		b.WriteRune('a')
+	}
+	if p.Create {
+		b.WriteRune('c')
+	}
+	if p.Write {
+		b.WriteRune('w')
+	}
+	if p.Delete {
+		b.WriteRune('d')
+	}
+	if p.List {
+		b.WriteRune('l')
+	}
+	return b.String()
+}
+
+// Parse initializes the ContainerSASPermissions's fields from a string.
+func (p *ContainerSASPermissions) Parse(s string) error {
+	*p = ContainerSASPermissions{} // Clear the flags
+	for _, r := range s {
+		switch r {
+		case 'r':
+			p.Read = true
+		case 'a':
+			p.Add = true
+		case 'c':
+			p.Create = true
+		case 'w':
+			p.Write = true
+		case 'd':
+			p.Delete = true
+		case 'l':
+			p.List = true
+		default:
+			return fmt.Errorf("Invalid permission: '%v'", r)
+		}
+	}
+	return nil
+}
+
+// The BlobSASPermissions type simplifies creating the permissions string for an Azure Storage blob SAS.
+// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
+type BlobSASPermissions struct{ Read, Add, Create, Write, Delete bool }
+
+// String produces the SAS permissions string for an Azure Storage blob.
+// Call this method to set BlobSASSignatureValues's Permissions field.
+func (p BlobSASPermissions) String() string {
+	var b bytes.Buffer
+	if p.Read {
+		b.WriteRune('r')
+	}
+	if p.Add {
+		b.WriteRune('a')
+	}
+	if p.Create {
+		b.WriteRune('c')
+	}
+	if p.Write {
+		b.WriteRune('w')
+	}
+	if p.Delete {
+		b.WriteRune('d')
+	}
+	return b.String()
+}
+
+// Parse initializes the BlobSASPermissions's fields from a string.
+func (p *BlobSASPermissions) Parse(s string) error {
+	*p = BlobSASPermissions{} // Clear the flags
+	for _, r := range s {
+		switch r {
+		case 'r':
+			p.Read = true
+		case 'a':
+			p.Add = true
+		case 'c':
+			p.Create = true
+		case 'w':
+			p.Write = true
+		case 'd':
+			p.Delete = true
+		default:
+			return fmt.Errorf("Invalid permission: '%v'", r)
+		}
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/service_codes_blob.go

@@ -0,0 +1,195 @@
+package azblob
+
+// https://docs.microsoft.com/en-us/rest/api/storageservices/blob-service-error-codes
+
+// ServiceCode values indicate a service failure.
+const (
+	// ServiceCodeAppendPositionConditionNotMet means the append position condition specified was not met.
+	ServiceCodeAppendPositionConditionNotMet ServiceCodeType = "AppendPositionConditionNotMet"
+
+	// ServiceCodeBlobAlreadyExists means the specified blob already exists.
+	ServiceCodeBlobAlreadyExists ServiceCodeType = "BlobAlreadyExists"
+
+	// ServiceCodeBlobNotFound means the specified blob does not exist.
+	ServiceCodeBlobNotFound ServiceCodeType = "BlobNotFound"
+
+	// ServiceCodeBlobOverwritten means the blob has been recreated since the previous snapshot was taken.
+	ServiceCodeBlobOverwritten ServiceCodeType = "BlobOverwritten"
+
+	// ServiceCodeBlobTierInadequateForContentLength means the specified blob tier size limit cannot be less than content length.
+	ServiceCodeBlobTierInadequateForContentLength ServiceCodeType = "BlobTierInadequateForContentLength"
+
+	// ServiceCodeBlockCountExceedsLimit means the committed block count cannot exceed the maximum limit of 50,000 blocks
+	// or that the uncommitted block count cannot exceed the maximum limit of 100,000 blocks.
+	ServiceCodeBlockCountExceedsLimit ServiceCodeType = "BlockCountExceedsLimit"
+
+	// ServiceCodeBlockListTooLong means the block list may not contain more than 50,000 blocks.
+	ServiceCodeBlockListTooLong ServiceCodeType = "BlockListTooLong"
+
+	// ServiceCodeCannotChangeToLowerTier means that a higher blob tier has already been explicitly set.
+	ServiceCodeCannotChangeToLowerTier ServiceCodeType = "CannotChangeToLowerTier"
+
+	// ServiceCodeCannotVerifyCopySource means that the service could not verify the copy source within the specified time.
+	// Examine the HTTP status code and message for more information about the failure.
+	ServiceCodeCannotVerifyCopySource ServiceCodeType = "CannotVerifyCopySource"
+
+	// ServiceCodeContainerAlreadyExists means the specified container already exists.
+	ServiceCodeContainerAlreadyExists ServiceCodeType = "ContainerAlreadyExists"
+
+	// ServiceCodeContainerBeingDeleted means the specified container is being deleted.
+	ServiceCodeContainerBeingDeleted ServiceCodeType = "ContainerBeingDeleted"
+
+	// ServiceCodeContainerDisabled means the specified container has been disabled by the administrator.
+	ServiceCodeContainerDisabled ServiceCodeType = "ContainerDisabled"
+
+	// ServiceCodeContainerNotFound means the specified container does not exist.
+	ServiceCodeContainerNotFound ServiceCodeType = "ContainerNotFound"
+
+	// ServiceCodeContentLengthLargerThanTierLimit means the blob's content length cannot exceed its tier limit.
+	ServiceCodeContentLengthLargerThanTierLimit ServiceCodeType = "ContentLengthLargerThanTierLimit"
+
+	// ServiceCodeCopyAcrossAccountsNotSupported means the copy source account and destination account must be the same.
+	ServiceCodeCopyAcrossAccountsNotSupported ServiceCodeType = "CopyAcrossAccountsNotSupported"
+
+	// ServiceCodeCopyIDMismatch means the specified copy ID did not match the copy ID for the pending copy operation.
+	ServiceCodeCopyIDMismatch ServiceCodeType = "CopyIdMismatch"
+
+	// ServiceCodeFeatureVersionMismatch means the type of blob in the container is unrecognized by this version or
+	// that the operation for AppendBlob requires at least version 2015-02-21.
+	ServiceCodeFeatureVersionMismatch ServiceCodeType = "FeatureVersionMismatch"
+
+	// ServiceCodeIncrementalCopyBlobMismatch means the specified source blob is different than the copy source of the existing incremental copy blob.
+	ServiceCodeIncrementalCopyBlobMismatch ServiceCodeType = "IncrementalCopyBlobMismatch"
+
+	// ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed means the specified snapshot is earlier than the last snapshot copied into the incremental copy blob.
+	ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed ServiceCodeType = "IncrementalCopyOfEralierVersionSnapshotNotAllowed"
+
+	// ServiceCodeIncrementalCopySourceMustBeSnapshot means the source for incremental copy request must be a snapshot.
+	ServiceCodeIncrementalCopySourceMustBeSnapshot ServiceCodeType = "IncrementalCopySourceMustBeSnapshot"
+
+	// ServiceCodeInfiniteLeaseDurationRequired means the lease ID matched, but the specified lease must be an infinite-duration lease.
+	ServiceCodeInfiniteLeaseDurationRequired ServiceCodeType = "InfiniteLeaseDurationRequired"
+
+	// ServiceCodeInvalidBlobOrBlock means the specified blob or block content is invalid.
+	ServiceCodeInvalidBlobOrBlock ServiceCodeType = "InvalidBlobOrBlock"
+
+	// ServiceCodeInvalidBlobType means the blob type is invalid for this operation.
+	ServiceCodeInvalidBlobType ServiceCodeType = "InvalidBlobType"
+
+	// ServiceCodeInvalidBlockID means the specified block ID is invalid. The block ID must be Base64-encoded.
+	ServiceCodeInvalidBlockID ServiceCodeType = "InvalidBlockId"
+
+	// ServiceCodeInvalidBlockList means the specified block list is invalid.
+	ServiceCodeInvalidBlockList ServiceCodeType = "InvalidBlockList"
+
+	// ServiceCodeInvalidOperation means an invalid operation against a blob snapshot.
+	ServiceCodeInvalidOperation ServiceCodeType = "InvalidOperation"
+
+	// ServiceCodeInvalidPageRange means the page range specified is invalid.
+	ServiceCodeInvalidPageRange ServiceCodeType = "InvalidPageRange"
+
+	// ServiceCodeInvalidSourceBlobType means the copy source blob type is invalid for this operation.
+	ServiceCodeInvalidSourceBlobType ServiceCodeType = "InvalidSourceBlobType"
+
+	// ServiceCodeInvalidSourceBlobURL means the source URL for incremental copy request must be valid Azure Storage blob URL.
+	ServiceCodeInvalidSourceBlobURL ServiceCodeType = "InvalidSourceBlobUrl"
+
+	// ServiceCodeInvalidVersionForPageBlobOperation means that all operations on page blobs require at least version 2009-09-19.
+	ServiceCodeInvalidVersionForPageBlobOperation ServiceCodeType = "InvalidVersionForPageBlobOperation"
+
+	// ServiceCodeLeaseAlreadyPresent means there is already a lease present.
+	ServiceCodeLeaseAlreadyPresent ServiceCodeType = "LeaseAlreadyPresent"
+
+	// ServiceCodeLeaseAlreadyBroken means the lease has already been broken and cannot be broken again.
+	ServiceCodeLeaseAlreadyBroken ServiceCodeType = "LeaseAlreadyBroken"
+
+	// ServiceCodeLeaseIDMismatchWithBlobOperation means the lease ID specified did not match the lease ID for the blob.
+	ServiceCodeLeaseIDMismatchWithBlobOperation ServiceCodeType = "LeaseIdMismatchWithBlobOperation"
+
+	// ServiceCodeLeaseIDMismatchWithContainerOperation means the lease ID specified did not match the lease ID for the container.
+	ServiceCodeLeaseIDMismatchWithContainerOperation ServiceCodeType = "LeaseIdMismatchWithContainerOperation"
+
+	// ServiceCodeLeaseIDMismatchWithLeaseOperation means the lease ID specified did not match the lease ID for the blob/container.
+	ServiceCodeLeaseIDMismatchWithLeaseOperation ServiceCodeType = "LeaseIdMismatchWithLeaseOperation"
+
+	// ServiceCodeLeaseIDMissing means there is currently a lease on the blob/container and no lease ID was specified in the request.
+	ServiceCodeLeaseIDMissing ServiceCodeType = "LeaseIdMissing"
+
+	// ServiceCodeLeaseIsBreakingAndCannotBeAcquired means the lease ID matched, but the lease is currently in breaking state and cannot be acquired until it is broken.
+	ServiceCodeLeaseIsBreakingAndCannotBeAcquired ServiceCodeType = "LeaseIsBreakingAndCannotBeAcquired"
+
+	// ServiceCodeLeaseIsBreakingAndCannotBeChanged means the lease ID matched, but the lease is currently in breaking state and cannot be changed.
+	ServiceCodeLeaseIsBreakingAndCannotBeChanged ServiceCodeType = "LeaseIsBreakingAndCannotBeChanged"
+
+	// ServiceCodeLeaseIsBrokenAndCannotBeRenewed means the lease ID matched, but the lease has been broken explicitly and cannot be renewed.
+	ServiceCodeLeaseIsBrokenAndCannotBeRenewed ServiceCodeType = "LeaseIsBrokenAndCannotBeRenewed"
+
+	// ServiceCodeLeaseLost means a lease ID was specified, but the lease for the blob/container has expired.
+	ServiceCodeLeaseLost ServiceCodeType = "LeaseLost"
+
+	// ServiceCodeLeaseNotPresentWithBlobOperation means there is currently no lease on the blob.
+	ServiceCodeLeaseNotPresentWithBlobOperation ServiceCodeType = "LeaseNotPresentWithBlobOperation"
+
+	// ServiceCodeLeaseNotPresentWithContainerOperation means there is currently no lease on the container.
+	ServiceCodeLeaseNotPresentWithContainerOperation ServiceCodeType = "LeaseNotPresentWithContainerOperation"
+
+	// ServiceCodeLeaseNotPresentWithLeaseOperation means there is currently no lease on the blob/container.
+	ServiceCodeLeaseNotPresentWithLeaseOperation ServiceCodeType = "LeaseNotPresentWithLeaseOperation"
+
+	// ServiceCodeMaxBlobSizeConditionNotMet means the max blob size condition specified was not met.
+	ServiceCodeMaxBlobSizeConditionNotMet ServiceCodeType = "MaxBlobSizeConditionNotMet"
+
+	// ServiceCodeNoPendingCopyOperation means there is currently no pending copy operation.
+	ServiceCodeNoPendingCopyOperation ServiceCodeType = "NoPendingCopyOperation"
+
+	// ServiceCodeOperationNotAllowedOnIncrementalCopyBlob means the specified operation is not allowed on an incremental copy blob.
+	ServiceCodeOperationNotAllowedOnIncrementalCopyBlob ServiceCodeType = "OperationNotAllowedOnIncrementalCopyBlob"
+
+	// ServiceCodePendingCopyOperation means there is currently a pending copy operation.
+	ServiceCodePendingCopyOperation ServiceCodeType = "PendingCopyOperation"
+
+	// ServiceCodePreviousSnapshotCannotBeNewer means the prevsnapshot query parameter value cannot be newer than snapshot query parameter value.
+	ServiceCodePreviousSnapshotCannotBeNewer ServiceCodeType = "PreviousSnapshotCannotBeNewer"
+
+	// ServiceCodePreviousSnapshotNotFound means the previous snapshot is not found.
+	ServiceCodePreviousSnapshotNotFound ServiceCodeType = "PreviousSnapshotNotFound"
+
+	// ServiceCodePreviousSnapshotOperationNotSupported means that differential Get Page Ranges is not supported on the previous snapshot.
+	ServiceCodePreviousSnapshotOperationNotSupported ServiceCodeType = "PreviousSnapshotOperationNotSupported"
+
+	// ServiceCodeSequenceNumberConditionNotMet means the sequence number condition specified was not met.
+	ServiceCodeSequenceNumberConditionNotMet ServiceCodeType = "SequenceNumberConditionNotMet"
+
+	// ServiceCodeSequenceNumberIncrementTooLarge means the sequence number increment cannot be performed because it would result in overflow of the sequence number.
+	ServiceCodeSequenceNumberIncrementTooLarge ServiceCodeType = "SequenceNumberIncrementTooLarge"
+
+	// ServiceCodeSnapshotCountExceeded means the snapshot count against this blob has been exceeded.
+	ServiceCodeSnapshotCountExceeded ServiceCodeType = "SnapshotCountExceeded"
+
+	// ServiceCodeSnaphotOperationRateExceeded means the rate of snapshot operations against this blob has been exceeded.
+	ServiceCodeSnaphotOperationRateExceeded ServiceCodeType = "SnaphotOperationRateExceeded"
+
+	// ServiceCodeSnapshotsPresent means this operation is not permitted while the blob has snapshots.
+	ServiceCodeSnapshotsPresent ServiceCodeType = "SnapshotsPresent"
+
+	// ServiceCodeSourceConditionNotMet means the source condition specified using HTTP conditional header(s) is not met.
+	ServiceCodeSourceConditionNotMet ServiceCodeType = "SourceConditionNotMet"
+
+	// ServiceCodeSystemInUse means this blob is in use by the system.
+	ServiceCodeSystemInUse ServiceCodeType = "SystemInUse"
+
+	// ServiceCodeTargetConditionNotMet means the target condition specified using HTTP conditional header(s) is not met.
+	ServiceCodeTargetConditionNotMet ServiceCodeType = "TargetConditionNotMet"
+
+	// ServiceCodeUnauthorizedBlobOverwrite means this request is not authorized to perform blob overwrites.
+	ServiceCodeUnauthorizedBlobOverwrite ServiceCodeType = "UnauthorizedBlobOverwrite"
+
+	// ServiceCodeBlobBeingRehydrated means this operation is not permitted because the blob is being rehydrated.
+	ServiceCodeBlobBeingRehydrated ServiceCodeType = "BlobBeingRehydrated"
+
+	// ServiceCodeBlobArchived means this operation is not permitted on an archived blob.
+	ServiceCodeBlobArchived ServiceCodeType = "BlobArchived"
+
+	// ServiceCodeBlobNotArchived means this blob is currently not in the archived state.
+	ServiceCodeBlobNotArchived ServiceCodeType = "BlobNotArchived"
+)

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_append_blob.go

@@ -0,0 +1,112 @@
+package azblob
+
+import (
+	"context"
+	"io"
+	"net/url"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+const (
+	// AppendBlobMaxAppendBlockBytes indicates the maximum number of bytes that can be sent in a call to AppendBlock.
+	AppendBlobMaxAppendBlockBytes = 4 * 1024 * 1024 // 4MB
+
+	// AppendBlobMaxBlocks indicates the maximum number of blocks allowed in an append blob.
+	AppendBlobMaxBlocks = 50000
+)
+
+// AppendBlobURL defines a set of operations applicable to append blobs.
+type AppendBlobURL struct {
+	BlobURL
+	abClient appendBlobClient
+}
+
+// NewAppendBlobURL creates an AppendBlobURL object using the specified URL and request policy pipeline.
+func NewAppendBlobURL(url url.URL, p pipeline.Pipeline) AppendBlobURL {
+	blobClient := newBlobClient(url, p)
+	abClient := newAppendBlobClient(url, p)
+	return AppendBlobURL{BlobURL: BlobURL{blobClient: blobClient}, abClient: abClient}
+}
+
+// WithPipeline creates a new AppendBlobURL object identical to the source but with the specific request policy pipeline.
+func (ab AppendBlobURL) WithPipeline(p pipeline.Pipeline) AppendBlobURL {
+	return NewAppendBlobURL(ab.blobClient.URL(), p)
+}
+
+// WithSnapshot creates a new AppendBlobURL object identical to the source but with the specified snapshot timestamp.
+// Pass "" to remove the snapshot returning a URL to the base blob.
+func (ab AppendBlobURL) WithSnapshot(snapshot string) AppendBlobURL {
+	p := NewBlobURLParts(ab.URL())
+	p.Snapshot = snapshot
+	return NewAppendBlobURL(p.URL(), ab.blobClient.Pipeline())
+}
+
+// Create creates a 0-length append blob. Call AppendBlock to append data to an append blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
+func (ab AppendBlobURL) Create(ctx context.Context, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*AppendBlobCreateResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch := ac.HTTPAccessConditions.pointers()
+	return ab.abClient.Create(ctx, 0, nil,
+		&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
+		&h.CacheControl, metadata, ac.LeaseAccessConditions.pointers(), &h.ContentDisposition,
+		ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch, nil)
+}
+
+// AppendBlock writes a stream to a new block of data to the end of the existing append blob.
+// This method panics if the stream is not at position 0.
+// Note that the http client closes the body stream after the request is sent to the service.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/append-block.
+func (ab AppendBlobURL) AppendBlock(ctx context.Context, body io.ReadSeeker, ac BlobAccessConditions) (*AppendBlobAppendBlockResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	ifAppendPositionEqual, ifMaxSizeLessThanOrEqual := ac.AppendBlobAccessConditions.pointers()
+	return ab.abClient.AppendBlock(ctx, body, validateSeekableStreamAt0AndGetCount(body), nil,
+		ac.LeaseAccessConditions.pointers(),
+		ifMaxSizeLessThanOrEqual, ifAppendPositionEqual,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// AppendBlobAccessConditions identifies append blob-specific access conditions which you optionally set.
+type AppendBlobAccessConditions struct {
+	// IfAppendPositionEqual ensures that the AppendBlock operation succeeds
+	// only if the append position is equal to a value.
+	// IfAppendPositionEqual=0 means no 'IfAppendPositionEqual' header specified.
+	// IfAppendPositionEqual>0 means 'IfAppendPositionEqual' header specified with its value
+	// IfAppendPositionEqual==-1 means IfAppendPositionEqual' header specified with a value of 0
+	IfAppendPositionEqual int64
+
+	// IfMaxSizeLessThanOrEqual ensures that the AppendBlock operation succeeds
+	// only if the append blob's size is less than or equal to a value.
+	// IfMaxSizeLessThanOrEqual=0 means no 'IfMaxSizeLessThanOrEqual' header specified.
+	// IfMaxSizeLessThanOrEqual>0 means 'IfMaxSizeLessThanOrEqual' header specified with its value
+	// IfMaxSizeLessThanOrEqual==-1 means 'IfMaxSizeLessThanOrEqual' header specified with a value of 0
+	IfMaxSizeLessThanOrEqual int64
+}
+
+// pointers is for internal infrastructure. It returns the fields as pointers.
+func (ac AppendBlobAccessConditions) pointers() (iape *int64, imsltoe *int64) {
+	if ac.IfAppendPositionEqual < -1 {
+		panic("IfAppendPositionEqual can't be less than -1")
+	}
+	if ac.IfMaxSizeLessThanOrEqual < -1 {
+		panic("IfMaxSizeLessThanOrEqual can't be less than -1")
+	}
+	var zero int64 // defaults to 0
+	switch ac.IfAppendPositionEqual {
+	case -1:
+		iape = &zero
+	case 0:
+		iape = nil
+	default:
+		iape = &ac.IfAppendPositionEqual
+	}
+
+	switch ac.IfMaxSizeLessThanOrEqual {
+	case -1:
+		imsltoe = &zero
+	case 0:
+		imsltoe = nil
+	default:
+		imsltoe = &ac.IfMaxSizeLessThanOrEqual
+	}
+	return
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_blob.go

@@ -0,0 +1,222 @@
+package azblob
+
+import (
+	"context"
+	"net/url"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// A BlobURL represents a URL to an Azure Storage blob; the blob may be a block blob, append blob, or page blob.
+type BlobURL struct {
+	blobClient blobClient
+}
+
+// NewBlobURL creates a BlobURL object using the specified URL and request policy pipeline.
+func NewBlobURL(url url.URL, p pipeline.Pipeline) BlobURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	blobClient := newBlobClient(url, p)
+	return BlobURL{blobClient: blobClient}
+}
+
+// URL returns the URL endpoint used by the BlobURL object.
+func (b BlobURL) URL() url.URL {
+	return b.blobClient.URL()
+}
+
+// String returns the URL as a string.
+func (b BlobURL) String() string {
+	u := b.URL()
+	return u.String()
+}
+
+// WithPipeline creates a new BlobURL object identical to the source but with the specified request policy pipeline.
+func (b BlobURL) WithPipeline(p pipeline.Pipeline) BlobURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	return NewBlobURL(b.blobClient.URL(), p)
+}
+
+// WithSnapshot creates a new BlobURL object identical to the source but with the specified snapshot timestamp.
+// Pass "" to remove the snapshot returning a URL to the base blob.
+func (b BlobURL) WithSnapshot(snapshot string) BlobURL {
+	p := NewBlobURLParts(b.URL())
+	p.Snapshot = snapshot
+	return NewBlobURL(p.URL(), b.blobClient.Pipeline())
+}
+
+// ToAppendBlobURL creates an AppendBlobURL using the source's URL and pipeline.
+func (b BlobURL) ToAppendBlobURL() AppendBlobURL {
+	return NewAppendBlobURL(b.URL(), b.blobClient.Pipeline())
+}
+
+// ToBlockBlobURL creates a BlockBlobURL using the source's URL and pipeline.
+func (b BlobURL) ToBlockBlobURL() BlockBlobURL {
+	return NewBlockBlobURL(b.URL(), b.blobClient.Pipeline())
+}
+
+// ToPageBlobURL creates a PageBlobURL using the source's URL and pipeline.
+func (b BlobURL) ToPageBlobURL() PageBlobURL {
+	return NewPageBlobURL(b.URL(), b.blobClient.Pipeline())
+}
+
+// DownloadBlob reads a range of bytes from a blob. The response also includes the blob's properties and metadata.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-blob.
+func (b BlobURL) Download(ctx context.Context, offset int64, count int64, ac BlobAccessConditions, rangeGetContentMD5 bool) (*DownloadResponse, error) {
+	var xRangeGetContentMD5 *bool
+	if rangeGetContentMD5 {
+		xRangeGetContentMD5 = &rangeGetContentMD5
+	}
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	dr, err := b.blobClient.Download(ctx, nil, nil,
+		httpRange{offset: offset, count: count}.pointers(),
+		ac.LeaseAccessConditions.pointers(), xRangeGetContentMD5,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DownloadResponse{
+		b:       b,
+		r:       dr,
+		ctx:     ctx,
+		getInfo: HTTPGetterInfo{Offset: offset, Count: count, ETag: dr.ETag()},
+	}, err
+}
+
+// DeleteBlob marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection.
+// Note that deleting a blob also deletes all its snapshots.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/delete-blob.
+func (b BlobURL) Delete(ctx context.Context, deleteOptions DeleteSnapshotsOptionType, ac BlobAccessConditions) (*BlobDeleteResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return b.blobClient.Delete(ctx, nil, nil, ac.LeaseAccessConditions.pointers(), deleteOptions,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// Undelete restores the contents and metadata of a soft-deleted blob and any associated soft-deleted snapshots.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/undelete-blob.
+func (b BlobURL) Undelete(ctx context.Context) (*BlobUndeleteResponse, error) {
+	return b.blobClient.Undelete(ctx, nil, nil)
+}
+
+// SetTier operation sets the tier on a blob. The operation is allowed on a page
+// blob in a premium storage account and on a block blob in a blob storage account (locally
+// redundant storage only). A premium page blob's tier determines the allowed size, IOPS, and
+// bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive storage type. This operation
+// does not update the blob's ETag.
+// For detailed information about block blob level tiering see https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blob-storage-tiers.
+func (b BlobURL) SetTier(ctx context.Context, tier AccessTierType) (*BlobSetTierResponse, error) {
+	return b.blobClient.SetTier(ctx, tier, nil, nil)
+}
+
+// GetBlobProperties returns the blob's properties.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-blob-properties.
+func (b BlobURL) GetProperties(ctx context.Context, ac BlobAccessConditions) (*BlobGetPropertiesResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return b.blobClient.GetProperties(ctx, nil, nil, ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// SetBlobHTTPHeaders changes a blob's HTTP headers.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-blob-properties.
+func (b BlobURL) SetHTTPHeaders(ctx context.Context, h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobSetHTTPHeadersResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return b.blobClient.SetHTTPHeaders(ctx, nil,
+		&h.CacheControl, &h.ContentType, h.ContentMD5, &h.ContentEncoding, &h.ContentLanguage,
+		ac.LeaseAccessConditions.pointers(), ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
+		&h.ContentDisposition, nil)
+}
+
+// SetBlobMetadata changes a blob's metadata.
+// https://docs.microsoft.com/rest/api/storageservices/set-blob-metadata.
+func (b BlobURL) SetMetadata(ctx context.Context, metadata Metadata, ac BlobAccessConditions) (*BlobSetMetadataResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return b.blobClient.SetMetadata(ctx, nil, metadata, ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// CreateSnapshot creates a read-only snapshot of a blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/snapshot-blob.
+func (b BlobURL) CreateSnapshot(ctx context.Context, metadata Metadata, ac BlobAccessConditions) (*BlobCreateSnapshotResponse, error) {
+	// CreateSnapshot does NOT panic if the user tries to create a snapshot using a URL that already has a snapshot query parameter
+	// because checking this would be a performance hit for a VERY unusual path and I don't think the common case should suffer this
+	// performance hit.
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return b.blobClient.CreateSnapshot(ctx, nil, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, ac.LeaseAccessConditions.pointers(), nil)
+}
+
+// AcquireLease acquires a lease on the blob for write and delete operations. The lease duration must be between
+// 15 to 60 seconds, or infinite (-1).
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
+func (b BlobURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*BlobAcquireLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
+	return b.blobClient.AcquireLease(ctx, nil, &duration, &proposedID,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// RenewLease renews the blob's previously-acquired lease.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
+func (b BlobURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobRenewLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
+	return b.blobClient.RenewLease(ctx, leaseID, nil,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// ReleaseLease releases the blob's previously-acquired lease.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
+func (b BlobURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobReleaseLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
+	return b.blobClient.ReleaseLease(ctx, leaseID, nil,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// BreakLease breaks the blob's previously-acquired lease (if it exists). Pass the LeaseBreakDefault (-1)
+// constant to break a fixed-duration lease when it expires or an infinite lease immediately.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
+func (b BlobURL) BreakLease(ctx context.Context, breakPeriodInSeconds int32, ac HTTPAccessConditions) (*BlobBreakLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
+	return b.blobClient.BreakLease(ctx, nil, leasePeriodPointer(breakPeriodInSeconds),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// ChangeLease changes the blob's lease ID.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
+func (b BlobURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*BlobChangeLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
+	return b.blobClient.ChangeLease(ctx, leaseID, proposedID,
+		nil, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// LeaseBreakNaturally tells ContainerURL's or BlobURL's BreakLease method to break the lease using service semantics.
+const LeaseBreakNaturally = -1
+
+func leasePeriodPointer(period int32) (p *int32) {
+	if period != LeaseBreakNaturally {
+		p = &period
+	}
+	return nil
+}
+
+// StartCopyFromURL copies the data at the source URL to a blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/copy-blob.
+func (b BlobURL) StartCopyFromURL(ctx context.Context, source url.URL, metadata Metadata, srcac BlobAccessConditions, dstac BlobAccessConditions) (*BlobStartCopyFromURLResponse, error) {
+	srcIfModifiedSince, srcIfUnmodifiedSince, srcIfMatchETag, srcIfNoneMatchETag := srcac.HTTPAccessConditions.pointers()
+	dstIfModifiedSince, dstIfUnmodifiedSince, dstIfMatchETag, dstIfNoneMatchETag := dstac.HTTPAccessConditions.pointers()
+	srcLeaseID := srcac.LeaseAccessConditions.pointers()
+	dstLeaseID := dstac.LeaseAccessConditions.pointers()
+
+	return b.blobClient.StartCopyFromURL(ctx, source.String(), nil, metadata,
+		srcIfModifiedSince, srcIfUnmodifiedSince,
+		srcIfMatchETag, srcIfNoneMatchETag,
+		dstIfModifiedSince, dstIfUnmodifiedSince,
+		dstIfMatchETag, dstIfNoneMatchETag,
+		dstLeaseID, srcLeaseID, nil)
+}
+
+// AbortCopyFromURL stops a pending copy that was previously started and leaves a destination blob with 0 length and metadata.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/abort-copy-blob.
+func (b BlobURL) AbortCopyFromURL(ctx context.Context, copyID string, ac LeaseAccessConditions) (*BlobAbortCopyFromURLResponse, error) {
+	return b.blobClient.AbortCopyFromURL(ctx, copyID, nil, ac.pointers(), nil)
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_block_blob.go

@@ -0,0 +1,157 @@
+package azblob
+
+import (
+	"context"
+	"io"
+	"net/url"
+
+	"encoding/base64"
+	"encoding/binary"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+const (
+	// BlockBlobMaxPutBlobBytes indicates the maximum number of bytes that can be sent in a call to Upload.
+	BlockBlobMaxUploadBlobBytes = 256 * 1024 * 1024 // 256MB
+
+	// BlockBlobMaxStageBlockBytes indicates the maximum number of bytes that can be sent in a call to StageBlock.
+	BlockBlobMaxStageBlockBytes = 100 * 1024 * 1024 // 100MB
+
+	// BlockBlobMaxBlocks indicates the maximum number of blocks allowed in a block blob.
+	BlockBlobMaxBlocks = 50000
+)
+
+// BlockBlobURL defines a set of operations applicable to block blobs.
+type BlockBlobURL struct {
+	BlobURL
+	bbClient blockBlobClient
+}
+
+// NewBlockBlobURL creates a BlockBlobURL object using the specified URL and request policy pipeline.
+func NewBlockBlobURL(url url.URL, p pipeline.Pipeline) BlockBlobURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	blobClient := newBlobClient(url, p)
+	bbClient := newBlockBlobClient(url, p)
+	return BlockBlobURL{BlobURL: BlobURL{blobClient: blobClient}, bbClient: bbClient}
+}
+
+// WithPipeline creates a new BlockBlobURL object identical to the source but with the specific request policy pipeline.
+func (bb BlockBlobURL) WithPipeline(p pipeline.Pipeline) BlockBlobURL {
+	return NewBlockBlobURL(bb.blobClient.URL(), p)
+}
+
+// WithSnapshot creates a new BlockBlobURL object identical to the source but with the specified snapshot timestamp.
+// Pass "" to remove the snapshot returning a URL to the base blob.
+func (bb BlockBlobURL) WithSnapshot(snapshot string) BlockBlobURL {
+	p := NewBlobURLParts(bb.URL())
+	p.Snapshot = snapshot
+	return NewBlockBlobURL(p.URL(), bb.blobClient.Pipeline())
+}
+
+// Upload creates a new block blob or overwrites an existing block blob.
+// Updating an existing block blob overwrites any existing metadata on the blob. Partial updates are not
+// supported with Upload; the content of the existing blob is overwritten with the new content. To
+// perform a partial update of a block blob, use StageBlock and CommitBlockList.
+// This method panics if the stream is not at position 0.
+// Note that the http client closes the body stream after the request is sent to the service.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
+func (bb BlockBlobURL) Upload(ctx context.Context, body io.ReadSeeker, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*BlockBlobUploadResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return bb.bbClient.Upload(ctx, body, validateSeekableStreamAt0AndGetCount(body), nil,
+		&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
+		&h.CacheControl, metadata, ac.LeaseAccessConditions.pointers(),
+		&h.ContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
+		nil)
+}
+
+// StageBlock uploads the specified block to the block blob's "staging area" to be later committed by a call to CommitBlockList.
+// Note that the http client closes the body stream after the request is sent to the service.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block.
+func (bb BlockBlobURL) StageBlock(ctx context.Context, base64BlockID string, body io.ReadSeeker, ac LeaseAccessConditions) (*BlockBlobStageBlockResponse, error) {
+	return bb.bbClient.StageBlock(ctx, base64BlockID, validateSeekableStreamAt0AndGetCount(body), body, nil, ac.pointers(), nil)
+}
+
+// StageBlockFromURL copies the specified block from a source URL to the block blob's "staging area" to be later committed by a call to CommitBlockList.
+// If count is CountToEnd (0), then data is read from specified offset to the end.
+// For more information, see https://docs.microsoft.com/en-us/rest/api/storageservices/put-block-from-url.
+func (bb BlockBlobURL) StageBlockFromURL(ctx context.Context, base64BlockID string, sourceURL url.URL, offset int64, count int64, ac LeaseAccessConditions) (*BlockBlobStageBlockFromURLResponse, error) {
+	sourceURLStr := sourceURL.String()
+	return bb.bbClient.StageBlockFromURL(ctx, base64BlockID, 0, &sourceURLStr, httpRange{offset: offset, count: count}.pointers(), nil, nil, ac.pointers(), nil)
+}
+
+// CommitBlockList writes a blob by specifying the list of block IDs that make up the blob.
+// In order to be written as part of a blob, a block must have been successfully written
+// to the server in a prior PutBlock operation. You can call PutBlockList to update a blob
+// by uploading only those blocks that have changed, then committing the new and existing
+// blocks together. Any blocks not specified in the block list and permanently deleted.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block-list.
+func (bb BlockBlobURL) CommitBlockList(ctx context.Context, base64BlockIDs []string, h BlobHTTPHeaders,
+	metadata Metadata, ac BlobAccessConditions) (*BlockBlobCommitBlockListResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return bb.bbClient.CommitBlockList(ctx, BlockLookupList{Latest: base64BlockIDs}, nil,
+		&h.CacheControl, &h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
+		metadata, ac.LeaseAccessConditions.pointers(), &h.ContentDisposition,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// GetBlockList returns the list of blocks that have been uploaded as part of a block blob using the specified block list filter.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-block-list.
+func (bb BlockBlobURL) GetBlockList(ctx context.Context, listType BlockListType, ac LeaseAccessConditions) (*BlockList, error) {
+	return bb.bbClient.GetBlockList(ctx, listType, nil, nil, ac.pointers(), nil)
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type BlockID [64]byte
+
+func (blockID BlockID) ToBase64() string {
+	return base64.StdEncoding.EncodeToString(blockID[:])
+}
+
+func (blockID *BlockID) FromBase64(s string) error {
+	*blockID = BlockID{} // Zero out the block ID
+	_, err := base64.StdEncoding.Decode(blockID[:], ([]byte)(s))
+	return err
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type uuidBlockID BlockID
+
+func (ubi uuidBlockID) UUID() uuid {
+	u := uuid{}
+	copy(u[:], ubi[:len(u)])
+	return u
+}
+
+func (ubi uuidBlockID) Number() uint32 {
+	return binary.BigEndian.Uint32(ubi[len(uuid{}):])
+}
+
+func newUuidBlockID(u uuid) uuidBlockID {
+	ubi := uuidBlockID{}     // Create a new uuidBlockID
+	copy(ubi[:len(u)], u[:]) // Copy the specified UUID into it
+	// Block number defaults to 0
+	return ubi
+}
+
+func (ubi *uuidBlockID) SetUUID(u uuid) *uuidBlockID {
+	copy(ubi[:len(u)], u[:])
+	return ubi
+}
+
+func (ubi uuidBlockID) WithBlockNumber(blockNumber uint32) uuidBlockID {
+	binary.BigEndian.PutUint32(ubi[len(uuid{}):], blockNumber) // Put block number after UUID
+	return ubi                                                 // Return the passed-in copy
+}
+
+func (ubi uuidBlockID) ToBase64() string {
+	return BlockID(ubi).ToBase64()
+}
+
+func (ubi *uuidBlockID) FromBase64(s string) error {
+	return (*BlockID)(ubi).FromBase64(s)
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_container.go

@@ -0,0 +1,300 @@
+package azblob
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// A ContainerURL represents a URL to the Azure Storage container allowing you to manipulate its blobs.
+type ContainerURL struct {
+	client containerClient
+}
+
+// NewContainerURL creates a ContainerURL object using the specified URL and request policy pipeline.
+func NewContainerURL(url url.URL, p pipeline.Pipeline) ContainerURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	client := newContainerClient(url, p)
+	return ContainerURL{client: client}
+}
+
+// URL returns the URL endpoint used by the ContainerURL object.
+func (c ContainerURL) URL() url.URL {
+	return c.client.URL()
+}
+
+// String returns the URL as a string.
+func (c ContainerURL) String() string {
+	u := c.URL()
+	return u.String()
+}
+
+// WithPipeline creates a new ContainerURL object identical to the source but with the specified request policy pipeline.
+func (c ContainerURL) WithPipeline(p pipeline.Pipeline) ContainerURL {
+	return NewContainerURL(c.URL(), p)
+}
+
+// NewBlobURL creates a new BlobURL object by concatenating blobName to the end of
+// ContainerURL's URL. The new BlobURL uses the same request policy pipeline as the ContainerURL.
+// To change the pipeline, create the BlobURL and then call its WithPipeline method passing in the
+// desired pipeline object. Or, call this package's NewBlobURL instead of calling this object's
+// NewBlobURL method.
+func (c ContainerURL) NewBlobURL(blobName string) BlobURL {
+	blobURL := appendToURLPath(c.URL(), blobName)
+	return NewBlobURL(blobURL, c.client.Pipeline())
+}
+
+// NewAppendBlobURL creates a new AppendBlobURL object by concatenating blobName to the end of
+// ContainerURL's URL. The new AppendBlobURL uses the same request policy pipeline as the ContainerURL.
+// To change the pipeline, create the AppendBlobURL and then call its WithPipeline method passing in the
+// desired pipeline object. Or, call this package's NewAppendBlobURL instead of calling this object's
+// NewAppendBlobURL method.
+func (c ContainerURL) NewAppendBlobURL(blobName string) AppendBlobURL {
+	blobURL := appendToURLPath(c.URL(), blobName)
+	return NewAppendBlobURL(blobURL, c.client.Pipeline())
+}
+
+// NewBlockBlobURL creates a new BlockBlobURL object by concatenating blobName to the end of
+// ContainerURL's URL. The new BlockBlobURL uses the same request policy pipeline as the ContainerURL.
+// To change the pipeline, create the BlockBlobURL and then call its WithPipeline method passing in the
+// desired pipeline object. Or, call this package's NewBlockBlobURL instead of calling this object's
+// NewBlockBlobURL method.
+func (c ContainerURL) NewBlockBlobURL(blobName string) BlockBlobURL {
+	blobURL := appendToURLPath(c.URL(), blobName)
+	return NewBlockBlobURL(blobURL, c.client.Pipeline())
+}
+
+// NewPageBlobURL creates a new PageBlobURL object by concatenating blobName to the end of
+// ContainerURL's URL. The new PageBlobURL uses the same request policy pipeline as the ContainerURL.
+// To change the pipeline, create the PageBlobURL and then call its WithPipeline method passing in the
+// desired pipeline object. Or, call this package's NewPageBlobURL instead of calling this object's
+// NewPageBlobURL method.
+func (c ContainerURL) NewPageBlobURL(blobName string) PageBlobURL {
+	blobURL := appendToURLPath(c.URL(), blobName)
+	return NewPageBlobURL(blobURL, c.client.Pipeline())
+}
+
+// Create creates a new container within a storage account. If a container with the same name already exists, the operation fails.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/create-container.
+func (c ContainerURL) Create(ctx context.Context, metadata Metadata, publicAccessType PublicAccessType) (*ContainerCreateResponse, error) {
+	return c.client.Create(ctx, nil, metadata, publicAccessType, nil)
+}
+
+// Delete marks the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/delete-container.
+func (c ContainerURL) Delete(ctx context.Context, ac ContainerAccessConditions) (*ContainerDeleteResponse, error) {
+	if ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
+		panic("the IfMatch and IfNoneMatch access conditions must have their default values because they are ignored by the service")
+	}
+
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.HTTPAccessConditions.pointers()
+	return c.client.Delete(ctx, nil, ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// GetProperties returns the container's properties.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-container-metadata.
+func (c ContainerURL) GetProperties(ctx context.Context, ac LeaseAccessConditions) (*ContainerGetPropertiesResponse, error) {
+	// NOTE: GetMetadata actually calls GetProperties internally because GetProperties returns the metadata AND the properties.
+	// This allows us to not expose a GetProperties method at all simplifying the API.
+	return c.client.GetProperties(ctx, nil, ac.pointers(), nil)
+}
+
+// SetMetadata sets the container's metadata.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-container-metadata.
+func (c ContainerURL) SetMetadata(ctx context.Context, metadata Metadata, ac ContainerAccessConditions) (*ContainerSetMetadataResponse, error) {
+	if !ac.IfUnmodifiedSince.IsZero() || ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
+		panic("the IfUnmodifiedSince, IfMatch, and IfNoneMatch must have their default values because they are ignored by the blob service")
+	}
+	ifModifiedSince, _, _, _ := ac.HTTPAccessConditions.pointers()
+	return c.client.SetMetadata(ctx, nil, ac.LeaseAccessConditions.pointers(), metadata, ifModifiedSince, nil)
+}
+
+// GetAccessPolicy returns the container's access policy. The access policy indicates whether container's blobs may be accessed publicly.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-container-acl.
+func (c ContainerURL) GetAccessPolicy(ctx context.Context, ac LeaseAccessConditions) (*SignedIdentifiers, error) {
+	return c.client.GetAccessPolicy(ctx, nil, ac.pointers(), nil)
+}
+
+// The AccessPolicyPermission type simplifies creating the permissions string for a container's access policy.
+// Initialize an instance of this type and then call its String method to set AccessPolicy's Permission field.
+type AccessPolicyPermission struct {
+	Read, Add, Create, Write, Delete, List bool
+}
+
+// String produces the access policy permission string for an Azure Storage container.
+// Call this method to set AccessPolicy's Permission field.
+func (p AccessPolicyPermission) String() string {
+	var b bytes.Buffer
+	if p.Read {
+		b.WriteRune('r')
+	}
+	if p.Add {
+		b.WriteRune('a')
+	}
+	if p.Create {
+		b.WriteRune('c')
+	}
+	if p.Write {
+		b.WriteRune('w')
+	}
+	if p.Delete {
+		b.WriteRune('d')
+	}
+	if p.List {
+		b.WriteRune('l')
+	}
+	return b.String()
+}
+
+// Parse initializes the AccessPolicyPermission's fields from a string.
+func (p *AccessPolicyPermission) Parse(s string) error {
+	*p = AccessPolicyPermission{} // Clear the flags
+	for _, r := range s {
+		switch r {
+		case 'r':
+			p.Read = true
+		case 'a':
+			p.Add = true
+		case 'c':
+			p.Create = true
+		case 'w':
+			p.Write = true
+		case 'd':
+			p.Delete = true
+		case 'l':
+			p.List = true
+		default:
+			return fmt.Errorf("invalid permission: '%v'", r)
+		}
+	}
+	return nil
+}
+
+// SetAccessPolicy sets the container's permissions. The access policy indicates whether blobs in a container may be accessed publicly.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-container-acl.
+func (c ContainerURL) SetAccessPolicy(ctx context.Context, accessType PublicAccessType, si []SignedIdentifier,
+	ac ContainerAccessConditions) (*ContainerSetAccessPolicyResponse, error) {
+	if ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
+		panic("the IfMatch and IfNoneMatch access conditions must have their default values because they are ignored by the service")
+	}
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.HTTPAccessConditions.pointers()
+	return c.client.SetAccessPolicy(ctx, si, nil, ac.LeaseAccessConditions.pointers(),
+		accessType, ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// AcquireLease acquires a lease on the container for delete operations. The lease duration must be between 15 to 60 seconds, or infinite (-1).
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
+func (c ContainerURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*ContainerAcquireLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
+	return c.client.AcquireLease(ctx, nil, &duration, &proposedID,
+		ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// RenewLease renews the container's previously-acquired lease.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
+func (c ContainerURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainerRenewLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
+	return c.client.RenewLease(ctx, leaseID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// ReleaseLease releases the container's previously-acquired lease.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
+func (c ContainerURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainerReleaseLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
+	return c.client.ReleaseLease(ctx, leaseID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// BreakLease breaks the container's previously-acquired lease (if it exists).
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
+func (c ContainerURL) BreakLease(ctx context.Context, period int32, ac HTTPAccessConditions) (*ContainerBreakLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
+	return c.client.BreakLease(ctx, nil, leasePeriodPointer(period), ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// ChangeLease changes the container's lease ID.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
+func (c ContainerURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*ContainerChangeLeaseResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
+	return c.client.ChangeLease(ctx, leaseID, proposedID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
+}
+
+// ListBlobsFlatSegment returns a single segment of blobs starting from the specified Marker. Use an empty
+// Marker to start enumeration from the beginning. Blob names are returned in lexicographic order.
+// After getting a segment, process it, and then call ListBlobsFlatSegment again (passing the the
+// previously-returned Marker) to get the next segment.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/list-blobs.
+func (c ContainerURL) ListBlobsFlatSegment(ctx context.Context, marker Marker, o ListBlobsSegmentOptions) (*ListBlobsFlatSegmentResponse, error) {
+	prefix, include, maxResults := o.pointers()
+	return c.client.ListBlobFlatSegment(ctx, prefix, marker.val, maxResults, include, nil, nil)
+}
+
+// ListBlobsHierarchySegment returns a single segment of blobs starting from the specified Marker. Use an empty
+// Marker to start enumeration from the beginning. Blob names are returned in lexicographic order.
+// After getting a segment, process it, and then call ListBlobsHierarchicalSegment again (passing the the
+// previously-returned Marker) to get the next segment.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/list-blobs.
+func (c ContainerURL) ListBlobsHierarchySegment(ctx context.Context, marker Marker, delimiter string, o ListBlobsSegmentOptions) (*ListBlobsHierarchySegmentResponse, error) {
+	if o.Details.Snapshots {
+		panic("snapshots are not supported in this listing operation")
+	}
+	prefix, include, maxResults := o.pointers()
+	return c.client.ListBlobHierarchySegment(ctx, delimiter, prefix, marker.val, maxResults, include, nil, nil)
+}
+
+// ListBlobsSegmentOptions defines options available when calling ListBlobs.
+type ListBlobsSegmentOptions struct {
+	Details BlobListingDetails // No IncludeType header is produced if ""
+	Prefix  string             // No Prefix header is produced if ""
+
+	// SetMaxResults sets the maximum desired results you want the service to return. Note, the
+	// service may return fewer results than requested.
+	// MaxResults=0 means no 'MaxResults' header specified.
+	MaxResults int32
+}
+
+func (o *ListBlobsSegmentOptions) pointers() (prefix *string, include []ListBlobsIncludeItemType, maxResults *int32) {
+	if o.Prefix != "" {
+		prefix = &o.Prefix
+	}
+	include = o.Details.slice()
+	if o.MaxResults != 0 {
+		if o.MaxResults < 0 {
+			panic("MaxResults must be >= 0")
+		}
+		maxResults = &o.MaxResults
+	}
+	return
+}
+
+// BlobListingDetails indicates what additional information the service should return with each blob.
+type BlobListingDetails struct {
+	Copy, Metadata, Snapshots, UncommittedBlobs, Deleted bool
+}
+
+// string produces the Include query parameter's value.
+func (d *BlobListingDetails) slice() []ListBlobsIncludeItemType {
+	items := []ListBlobsIncludeItemType{}
+	// NOTE: Multiple strings MUST be appended in alphabetic order or signing the string for authentication fails!
+	if d.Copy {
+		items = append(items, ListBlobsIncludeItemCopy)
+	}
+	if d.Deleted {
+		items = append(items, ListBlobsIncludeItemDeleted)
+	}
+	if d.Metadata {
+		items = append(items, ListBlobsIncludeItemMetadata)
+	}
+	if d.Snapshots {
+		items = append(items, ListBlobsIncludeItemSnapshots)
+	}
+	if d.UncommittedBlobs {
+		items = append(items, ListBlobsIncludeItemUncommittedblobs)
+	}
+	return items
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_page_blob.go

@@ -0,0 +1,236 @@
+package azblob
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/url"
+	"strconv"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+const (
+	// PageBlobPageBytes indicates the number of bytes in a page (512).
+	PageBlobPageBytes = 512
+
+	// PageBlobMaxPutPagesBytes indicates the maximum number of bytes that can be sent in a call to PutPage.
+	PageBlobMaxUploadPagesBytes = 4 * 1024 * 1024 // 4MB
+)
+
+// PageBlobURL defines a set of operations applicable to page blobs.
+type PageBlobURL struct {
+	BlobURL
+	pbClient pageBlobClient
+}
+
+// NewPageBlobURL creates a PageBlobURL object using the specified URL and request policy pipeline.
+func NewPageBlobURL(url url.URL, p pipeline.Pipeline) PageBlobURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	blobClient := newBlobClient(url, p)
+	pbClient := newPageBlobClient(url, p)
+	return PageBlobURL{BlobURL: BlobURL{blobClient: blobClient}, pbClient: pbClient}
+}
+
+// WithPipeline creates a new PageBlobURL object identical to the source but with the specific request policy pipeline.
+func (pb PageBlobURL) WithPipeline(p pipeline.Pipeline) PageBlobURL {
+	return NewPageBlobURL(pb.blobClient.URL(), p)
+}
+
+// WithSnapshot creates a new PageBlobURL object identical to the source but with the specified snapshot timestamp.
+// Pass "" to remove the snapshot returning a URL to the base blob.
+func (pb PageBlobURL) WithSnapshot(snapshot string) PageBlobURL {
+	p := NewBlobURLParts(pb.URL())
+	p.Snapshot = snapshot
+	return NewPageBlobURL(p.URL(), pb.blobClient.Pipeline())
+}
+
+// CreatePageBlob creates a page blob of the specified length. Call PutPage to upload data data to a page blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
+func (pb PageBlobURL) Create(ctx context.Context, size int64, sequenceNumber int64, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*PageBlobCreateResponse, error) {
+	if sequenceNumber < 0 {
+		panic("sequenceNumber must be greater than or equal to 0")
+	}
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return pb.pbClient.Create(ctx, 0, nil,
+		&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5, &h.CacheControl,
+		metadata, ac.LeaseAccessConditions.pointers(),
+		&h.ContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, &size, &sequenceNumber, nil)
+}
+
+// UploadPages writes 1 or more pages to the page blob. The start offset and the stream size must be a multiple of 512 bytes.
+// This method panics if the stream is not at position 0.
+// Note that the http client closes the body stream after the request is sent to the service.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-page.
+func (pb PageBlobURL) UploadPages(ctx context.Context, offset int64, body io.ReadSeeker, ac BlobAccessConditions) (*PageBlobUploadPagesResponse, error) {
+	count := validateSeekableStreamAt0AndGetCount(body)
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual := ac.PageBlobAccessConditions.pointers()
+	return pb.pbClient.UploadPages(ctx, body, count, nil,
+		PageRange{Start: offset, End: offset + count - 1}.pointers(),
+		ac.LeaseAccessConditions.pointers(),
+		ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// ClearPages frees the specified pages from the page blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-page.
+func (pb PageBlobURL) ClearPages(ctx context.Context, offset int64, count int64, ac BlobAccessConditions) (*PageBlobClearPagesResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual := ac.PageBlobAccessConditions.pointers()
+	return pb.pbClient.ClearPages(ctx, 0, nil,
+		PageRange{Start: offset, End: offset + count - 1}.pointers(),
+		ac.LeaseAccessConditions.pointers(),
+		ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan,
+		ifSequenceNumberEqual, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// GetPageRanges returns the list of valid page ranges for a page blob or snapshot of a page blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-page-ranges.
+func (pb PageBlobURL) GetPageRanges(ctx context.Context, offset int64, count int64, ac BlobAccessConditions) (*PageList, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return pb.pbClient.GetPageRanges(ctx, nil, nil,
+		httpRange{offset: offset, count: count}.pointers(),
+		ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// GetPageRangesDiff gets the collection of page ranges that differ between a specified snapshot and this page blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-page-ranges.
+func (pb PageBlobURL) GetPageRangesDiff(ctx context.Context, offset int64, count int64, prevSnapshot string, ac BlobAccessConditions) (*PageList, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return pb.pbClient.GetPageRangesDiff(ctx, nil, nil, &prevSnapshot,
+		httpRange{offset: offset, count: count}.pointers(),
+		ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
+		nil)
+}
+
+// Resize resizes the page blob to the specified size (which must be a multiple of 512).
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-blob-properties.
+func (pb PageBlobURL) Resize(ctx context.Context, size int64, ac BlobAccessConditions) (*PageBlobResizeResponse, error) {
+	if size%PageBlobPageBytes != 0 {
+		panic("Size must be a multiple of PageBlobPageBytes (512)")
+	}
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	return pb.pbClient.Resize(ctx, size, nil, ac.LeaseAccessConditions.pointers(),
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+// SetSequenceNumber sets the page blob's sequence number.
+func (pb PageBlobURL) UpdateSequenceNumber(ctx context.Context, action SequenceNumberActionType, sequenceNumber int64,
+	ac BlobAccessConditions) (*PageBlobUpdateSequenceNumberResponse, error) {
+	if sequenceNumber < 0 {
+		panic("sequenceNumber must be greater than or equal to 0")
+	}
+	sn := &sequenceNumber
+	if action == SequenceNumberActionIncrement {
+		sn = nil
+	}
+	ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch := ac.HTTPAccessConditions.pointers()
+	return pb.pbClient.UpdateSequenceNumber(ctx, action, nil,
+		ac.LeaseAccessConditions.pointers(), ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch,
+		sn, nil)
+}
+
+// StartIncrementalCopy begins an operation to start an incremental copy from one page blob's snapshot to this page blob.
+// The snapshot is copied such that only the differential changes between the previously copied snapshot are transferred to the destination.
+// The copied snapshots are complete copies of the original snapshot and can be read or copied from as usual.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/incremental-copy-blob and
+// https://docs.microsoft.com/en-us/azure/virtual-machines/windows/incremental-snapshots.
+func (pb PageBlobURL) StartCopyIncremental(ctx context.Context, source url.URL, snapshot string, ac BlobAccessConditions) (*PageBlobCopyIncrementalResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
+	qp := source.Query()
+	qp.Set("snapshot", snapshot)
+	source.RawQuery = qp.Encode()
+	return pb.pbClient.CopyIncremental(ctx, source.String(), nil, nil,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
+func (pr PageRange) pointers() *string {
+	if pr.Start < 0 {
+		panic("PageRange's Start value must be greater than or equal to 0")
+	}
+	if pr.End <= 0 {
+		panic("PageRange's End value must be greater than 0")
+	}
+	if pr.Start%PageBlobPageBytes != 0 {
+		panic("PageRange's Start value must be a multiple of 512")
+	}
+	if pr.End%PageBlobPageBytes != (PageBlobPageBytes - 1) {
+		panic("PageRange's End value must be 1 less than a multiple of 512")
+	}
+	if pr.End <= pr.Start {
+		panic("PageRange's End value must be after the start")
+	}
+	endOffset := strconv.FormatInt(int64(pr.End), 10)
+	asString := fmt.Sprintf("bytes=%v-%s", pr.Start, endOffset)
+	return &asString
+}
+
+// PageBlobAccessConditions identifies page blob-specific access conditions which you optionally set.
+type PageBlobAccessConditions struct {
+	// IfSequenceNumberLessThan ensures that the page blob operation succeeds
+	// only if the blob's sequence number is less than a value.
+	// IfSequenceNumberLessThan=0 means no 'IfSequenceNumberLessThan' header specified.
+	// IfSequenceNumberLessThan>0 means 'IfSequenceNumberLessThan' header specified with its value
+	// IfSequenceNumberLessThan==-1 means 'IfSequenceNumberLessThan' header specified with a value of 0
+	IfSequenceNumberLessThan int64
+
+	// IfSequenceNumberLessThanOrEqual ensures that the page blob operation succeeds
+	// only if the blob's sequence number is less than or equal to a value.
+	// IfSequenceNumberLessThanOrEqual=0 means no 'IfSequenceNumberLessThanOrEqual' header specified.
+	// IfSequenceNumberLessThanOrEqual>0 means 'IfSequenceNumberLessThanOrEqual' header specified with its value
+	// IfSequenceNumberLessThanOrEqual=-1 means 'IfSequenceNumberLessThanOrEqual' header specified with a value of 0
+	IfSequenceNumberLessThanOrEqual int64
+
+	// IfSequenceNumberEqual ensures that the page blob operation succeeds
+	// only if the blob's sequence number is equal to a value.
+	// IfSequenceNumberEqual=0 means no 'IfSequenceNumberEqual' header specified.
+	// IfSequenceNumberEqual>0 means 'IfSequenceNumberEqual' header specified with its value
+	// IfSequenceNumberEqual=-1 means 'IfSequenceNumberEqual' header specified with a value of 0
+	IfSequenceNumberEqual int64
+}
+
+// pointers is for internal infrastructure. It returns the fields as pointers.
+func (ac PageBlobAccessConditions) pointers() (snltoe *int64, snlt *int64, sne *int64) {
+	if ac.IfSequenceNumberLessThan < -1 {
+		panic("Ifsequencenumberlessthan can't be less than -1")
+	}
+	if ac.IfSequenceNumberLessThanOrEqual < -1 {
+		panic("IfSequenceNumberLessThanOrEqual can't be less than -1")
+	}
+	if ac.IfSequenceNumberEqual < -1 {
+		panic("IfSequenceNumberEqual can't be less than -1")
+	}
+
+	var zero int64 // Defaults to 0
+	switch ac.IfSequenceNumberLessThan {
+	case -1:
+		snlt = &zero
+	case 0:
+		snlt = nil
+	default:
+		snlt = &ac.IfSequenceNumberLessThan
+	}
+
+	switch ac.IfSequenceNumberLessThanOrEqual {
+	case -1:
+		snltoe = &zero
+	case 0:
+		snltoe = nil
+	default:
+		snltoe = &ac.IfSequenceNumberLessThanOrEqual
+	}
+	switch ac.IfSequenceNumberEqual {
+	case -1:
+		sne = &zero
+	case 0:
+		sne = nil
+	default:
+		sne = &ac.IfSequenceNumberEqual
+	}
+	return
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/url_service.go

@@ -0,0 +1,140 @@
+package azblob
+
+import (
+	"context"
+	"net/url"
+	"strings"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+const (
+	// ContainerNameRoot is the special Azure Storage name used to identify a storage account's root container.
+	ContainerNameRoot = "$root"
+
+	// ContainerNameLogs is the special Azure Storage name used to identify a storage account's logs container.
+	ContainerNameLogs = "$logs"
+)
+
+// A ServiceURL represents a URL to the Azure Storage Blob service allowing you to manipulate blob containers.
+type ServiceURL struct {
+	client serviceClient
+}
+
+// NewServiceURL creates a ServiceURL object using the specified URL and request policy pipeline.
+func NewServiceURL(primaryURL url.URL, p pipeline.Pipeline) ServiceURL {
+	if p == nil {
+		panic("p can't be nil")
+	}
+	client := newServiceClient(primaryURL, p)
+	return ServiceURL{client: client}
+}
+
+// URL returns the URL endpoint used by the ServiceURL object.
+func (s ServiceURL) URL() url.URL {
+	return s.client.URL()
+}
+
+// String returns the URL as a string.
+func (s ServiceURL) String() string {
+	u := s.URL()
+	return u.String()
+}
+
+// WithPipeline creates a new ServiceURL object identical to the source but with the specified request policy pipeline.
+func (s ServiceURL) WithPipeline(p pipeline.Pipeline) ServiceURL {
+	return NewServiceURL(s.URL(), p)
+}
+
+// NewContainerURL creates a new ContainerURL object by concatenating containerName to the end of
+// ServiceURL's URL. The new ContainerURL uses the same request policy pipeline as the ServiceURL.
+// To change the pipeline, create the ContainerURL and then call its WithPipeline method passing in the
+// desired pipeline object. Or, call this package's NewContainerURL instead of calling this object's
+// NewContainerURL method.
+func (s ServiceURL) NewContainerURL(containerName string) ContainerURL {
+	containerURL := appendToURLPath(s.URL(), containerName)
+	return NewContainerURL(containerURL, s.client.Pipeline())
+}
+
+// appendToURLPath appends a string to the end of a URL's path (prefixing the string with a '/' if required)
+func appendToURLPath(u url.URL, name string) url.URL {
+	// e.g. "https://ms.com/a/b/?k1=v1&k2=v2#f"
+	// When you call url.Parse() this is what you'll get:
+	//     Scheme: "https"
+	//     Opaque: ""
+	//       User: nil
+	//       Host: "ms.com"
+	//       Path: "/a/b/"	This should start with a / and it might or might not have a trailing slash
+	//    RawPath: ""
+	// ForceQuery: false
+	//   RawQuery: "k1=v1&k2=v2"
+	//   Fragment: "f"
+	if len(u.Path) == 0 || u.Path[len(u.Path)-1] != '/' {
+		u.Path += "/" // Append "/" to end before appending name
+	}
+	u.Path += name
+	return u
+}
+
+// ListContainersFlatSegment returns a single segment of containers starting from the specified Marker. Use an empty
+// Marker to start enumeration from the beginning. Container names are returned in lexicographic order.
+// After getting a segment, process it, and then call ListContainersFlatSegment again (passing the the
+// previously-returned Marker) to get the next segment. For more information, see
+// https://docs.microsoft.com/rest/api/storageservices/list-containers2.
+func (s ServiceURL) ListContainersSegment(ctx context.Context, marker Marker, o ListContainersSegmentOptions) (*ListContainersResponse, error) {
+	prefix, include, maxResults := o.pointers()
+	return s.client.ListContainersSegment(ctx, prefix, marker.val, maxResults, include, nil, nil)
+}
+
+// ListContainersOptions defines options available when calling ListContainers.
+type ListContainersSegmentOptions struct {
+	Detail     ListContainersDetail // No IncludeType header is produced if ""
+	Prefix     string                   // No Prefix header is produced if ""
+	MaxResults int32                    // 0 means unspecified
+	// TODO: update swagger to generate this type?
+}
+
+func (o *ListContainersSegmentOptions) pointers() (prefix *string, include ListContainersIncludeType, maxResults *int32) {
+	if o.Prefix != "" {
+		prefix = &o.Prefix
+	}
+	if o.MaxResults != 0 {
+		if o.MaxResults < 0 {
+			panic("MaxResults must be >= 0")
+		}
+		maxResults = &o.MaxResults
+	}
+	include = ListContainersIncludeType(o.Detail.string())
+	return
+}
+
+// ListContainersFlatDetail indicates what additional information the service should return with each container.
+type ListContainersDetail struct {
+	// Tells the service whether to return metadata for each container.
+	Metadata bool
+}
+
+// string produces the Include query parameter's value.
+func (d *ListContainersDetail) string() string {
+	items := make([]string, 0, 1)
+	// NOTE: Multiple strings MUST be appended in alphabetic order or signing the string for authentication fails!
+	if d.Metadata {
+		items = append(items, string(ListContainersIncludeMetadata))
+	}
+	if len(items) > 0 {
+		return strings.Join(items, ",")
+	}
+	return string(ListContainersIncludeNone)
+}
+
+func (bsu ServiceURL) GetProperties(ctx context.Context) (*StorageServiceProperties, error) {
+	return bsu.client.GetProperties(ctx, nil, nil)
+}
+
+func (bsu ServiceURL) SetProperties(ctx context.Context, properties StorageServiceProperties) (*ServiceSetPropertiesResponse, error) {
+	return bsu.client.SetProperties(ctx, properties, nil, nil)
+}
+
+func (bsu ServiceURL) GetStatistics(ctx context.Context) (*StorageServiceStats, error) {
+	return bsu.client.GetStatistics(ctx, nil, nil)
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/version.go

@@ -0,0 +1,3 @@
+package azblob
+
+const serviceLibVersion = "0.1"

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_credential_anonymous.go

@@ -0,0 +1,55 @@
+package azblob
+
+import (
+	"context"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// Credential represent any credential type; it is used to create a credential policy Factory.
+type Credential interface {
+	pipeline.Factory
+	credentialMarker()
+}
+
+type credentialFunc pipeline.FactoryFunc
+
+func (f credentialFunc) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return f(next, po)
+}
+
+// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
+func (credentialFunc) credentialMarker() {}
+
+//////////////////////////////
+
+// NewAnonymousCredential creates an anonymous credential for use with HTTP(S) requests that read public resource
+// or for use with Shared Access Signatures (SAS).
+func NewAnonymousCredential() Credential {
+	return anonymousCredentialFactory
+}
+
+var anonymousCredentialFactory Credential = &anonymousCredentialPolicyFactory{} // Singleton
+
+// anonymousCredentialPolicyFactory is the credential's policy factory.
+type anonymousCredentialPolicyFactory struct {
+}
+
+// New creates a credential policy object.
+func (f *anonymousCredentialPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return &anonymousCredentialPolicy{next: next}
+}
+
+// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
+func (*anonymousCredentialPolicyFactory) credentialMarker() {}
+
+// anonymousCredentialPolicy is the credential's policy object.
+type anonymousCredentialPolicy struct {
+	next pipeline.Policy
+}
+
+// Do implements the credential's policy interface.
+func (p anonymousCredentialPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+	// For anonymous credentials, this is effectively a no-op
+	return p.next.Do(ctx, request)
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_credential_shared_key.go

@@ -0,0 +1,187 @@
+package azblob
+
+import (
+	"bytes"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"net/http"
+	"net/url"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// NewSharedKeyCredential creates an immutable SharedKeyCredential containing the
+// storage account's name and either its primary or secondary key.
+func NewSharedKeyCredential(accountName, accountKey string) *SharedKeyCredential {
+	bytes, err := base64.StdEncoding.DecodeString(accountKey)
+	if err != nil {
+		panic(err)
+	}
+	return &SharedKeyCredential{accountName: accountName, accountKey: bytes}
+}
+
+// SharedKeyCredential contains an account's name and its primary or secondary key.
+// It is immutable making it shareable and goroutine-safe.
+type SharedKeyCredential struct {
+	// Only the NewSharedKeyCredential method should set these; all other methods should treat them as read-only
+	accountName string
+	accountKey  []byte
+}
+
+// AccountName returns the Storage account's name.
+func (f SharedKeyCredential) AccountName() string {
+	return f.accountName
+}
+
+// New creates a credential policy object.
+func (f *SharedKeyCredential) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return pipeline.PolicyFunc(func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+		// Add a x-ms-date header if it doesn't already exist
+		if d := request.Header.Get(headerXmsDate); d == "" {
+			request.Header[headerXmsDate] = []string{time.Now().UTC().Format(http.TimeFormat)}
+		}
+		stringToSign := f.buildStringToSign(request)
+		signature := f.ComputeHMACSHA256(stringToSign)
+		authHeader := strings.Join([]string{"SharedKey ", f.accountName, ":", signature}, "")
+		request.Header[headerAuthorization] = []string{authHeader}
+
+		response, err := next.Do(ctx, request)
+		if err != nil && response != nil && response.Response() != nil && response.Response().StatusCode == http.StatusForbidden {
+			// Service failed to authenticate request, log it
+			po.Log(pipeline.LogError, "===== HTTP Forbidden status, String-to-Sign:\n"+stringToSign+"\n===============================\n")
+		}
+		return response, err
+	})
+}
+
+// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
+func (*SharedKeyCredential) credentialMarker() {}
+
+// Constants ensuring that header names are correctly spelled and consistently cased.
+const (
+	headerAuthorization      = "Authorization"
+	headerCacheControl       = "Cache-Control"
+	headerContentEncoding    = "Content-Encoding"
+	headerContentDisposition = "Content-Disposition"
+	headerContentLanguage    = "Content-Language"
+	headerContentLength      = "Content-Length"
+	headerContentMD5         = "Content-MD5"
+	headerContentType        = "Content-Type"
+	headerDate               = "Date"
+	headerIfMatch            = "If-Match"
+	headerIfModifiedSince    = "If-Modified-Since"
+	headerIfNoneMatch        = "If-None-Match"
+	headerIfUnmodifiedSince  = "If-Unmodified-Since"
+	headerRange              = "Range"
+	headerUserAgent          = "User-Agent"
+	headerXmsDate            = "x-ms-date"
+	headerXmsVersion         = "x-ms-version"
+)
+
+// ComputeHMACSHA256 generates a hash signature for an HTTP request or for a SAS.
+func (f *SharedKeyCredential) ComputeHMACSHA256(message string) (base64String string) {
+	h := hmac.New(sha256.New, f.accountKey)
+	h.Write([]byte(message))
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func (f *SharedKeyCredential) buildStringToSign(request pipeline.Request) string {
+	// https://docs.microsoft.com/en-us/rest/api/storageservices/authentication-for-the-azure-storage-services
+	headers := request.Header
+	contentLength := headers.Get(headerContentLength)
+	if contentLength == "0" {
+		contentLength = ""
+	}
+
+	stringToSign := strings.Join([]string{
+		request.Method,
+		headers.Get(headerContentEncoding),
+		headers.Get(headerContentLanguage),
+		contentLength,
+		headers.Get(headerContentMD5),
+		headers.Get(headerContentType),
+		"", // Empty date because x-ms-date is expected (as per web page above)
+		headers.Get(headerIfModifiedSince),
+		headers.Get(headerIfMatch),
+		headers.Get(headerIfNoneMatch),
+		headers.Get(headerIfUnmodifiedSince),
+		headers.Get(headerRange),
+		buildCanonicalizedHeader(headers),
+		f.buildCanonicalizedResource(request.URL),
+	}, "\n")
+	return stringToSign
+}
+
+func buildCanonicalizedHeader(headers http.Header) string {
+	cm := map[string][]string{}
+	for k, v := range headers {
+		headerName := strings.TrimSpace(strings.ToLower(k))
+		if strings.HasPrefix(headerName, "x-ms-") {
+			cm[headerName] = v // NOTE: the value must not have any whitespace around it.
+		}
+	}
+	if len(cm) == 0 {
+		return ""
+	}
+
+	keys := make([]string, 0, len(cm))
+	for key := range cm {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	ch := bytes.NewBufferString("")
+	for i, key := range keys {
+		if i > 0 {
+			ch.WriteRune('\n')
+		}
+		ch.WriteString(key)
+		ch.WriteRune(':')
+		ch.WriteString(strings.Join(cm[key], ","))
+	}
+	return string(ch.Bytes())
+}
+
+func (f *SharedKeyCredential) buildCanonicalizedResource(u *url.URL) string {
+	// https://docs.microsoft.com/en-us/rest/api/storageservices/authentication-for-the-azure-storage-services
+	cr := bytes.NewBufferString("/")
+	cr.WriteString(f.accountName)
+
+	if len(u.Path) > 0 {
+		// Any portion of the CanonicalizedResource string that is derived from
+		// the resource's URI should be encoded exactly as it is in the URI.
+		// -- https://msdn.microsoft.com/en-gb/library/azure/dd179428.aspx
+		cr.WriteString(u.EscapedPath())
+	} else {
+		// a slash is required to indicate the root path
+		cr.WriteString("/")
+	}
+
+	// params is a map[string][]string; param name is key; params values is []string
+	params, err := url.ParseQuery(u.RawQuery) // Returns URL decoded values
+	if err != nil {
+		panic(err)
+	}
+
+	if len(params) > 0 { // There is at least 1 query parameter
+		paramNames := []string{} // We use this to sort the parameter key names
+		for paramName := range params {
+			paramNames = append(paramNames, paramName) // paramNames must be lowercase
+		}
+		sort.Strings(paramNames)
+
+		for _, paramName := range paramNames {
+			paramValues := params[paramName]
+			sort.Strings(paramValues)
+
+			// Join the sorted key values separated by ','
+			// Then prepend "keyName:"; then add this string to the buffer
+			cr.WriteString("\n" + paramName + ":" + strings.Join(paramValues, ","))
+		}
+	}
+	return string(cr.Bytes())
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_credential_token.go

@@ -0,0 +1,126 @@
+package azblob
+
+import (
+	"context"
+	"sync/atomic"
+
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// TokenCredential represents a token credential (which is also a pipeline.Factory).
+type TokenCredential interface {
+	Credential
+	Token() string
+	SetToken(newToken string)
+}
+
+// NewTokenCredential creates a token credential for use with role-based access control (RBAC) access to Azure Storage
+// resources. You initialize the TokenCredential with an initial token value. If you pass a non-nil value for
+// tokenRefresher, then the function you pass will be called immediately (so it can refresh and change the
+// TokenCredential's token value by calling SetToken; your tokenRefresher function must return a time.Duration
+// indicating how long the TokenCredential object should wait before calling your tokenRefresher function again.
+func NewTokenCredential(initialToken string, tokenRefresher func(credential TokenCredential) time.Duration) TokenCredential {
+	tc := &tokenCredential{}
+	tc.SetToken(initialToken) // We dont' set it above to guarantee atomicity
+	if tokenRefresher == nil {
+		return tc // If no callback specified, return the simple tokenCredential
+	}
+
+	tcwr := &tokenCredentialWithRefresh{token: tc}
+	tcwr.token.startRefresh(tokenRefresher)
+	runtime.SetFinalizer(tcwr, func(deadTC *tokenCredentialWithRefresh) {
+		deadTC.token.stopRefresh()
+		deadTC.token = nil //  Sanity (not really required)
+	})
+	return tcwr
+}
+
+// tokenCredentialWithRefresh is a wrapper over a token credential.
+// When this wrapper object gets GC'd, it stops the tokenCredential's timer
+// which allows the tokenCredential object to also be GC'd.
+type tokenCredentialWithRefresh struct {
+	token *tokenCredential
+}
+
+// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
+func (*tokenCredentialWithRefresh) credentialMarker() {}
+
+// Token returns the current token value
+func (f *tokenCredentialWithRefresh) Token() string { return f.token.Token() }
+
+// SetToken changes the current token value
+func (f *tokenCredentialWithRefresh) SetToken(token string) { f.token.SetToken(token) }
+
+// New satisfies pipeline.Factory's New method creating a pipeline policy object.
+func (f *tokenCredentialWithRefresh) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return f.token.New(next, po)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// tokenCredential is a pipeline.Factory is the credential's policy factory.
+type tokenCredential struct {
+	token atomic.Value
+
+	// The members below are only used if the user specified a tokenRefresher callback function.
+	timer          *time.Timer
+	tokenRefresher func(c TokenCredential) time.Duration
+	lock           sync.Mutex
+	stopped        bool
+}
+
+// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
+func (*tokenCredential) credentialMarker() {}
+
+// Token returns the current token value
+func (f *tokenCredential) Token() string { return f.token.Load().(string) }
+
+// SetToken changes the current token value
+func (f *tokenCredential) SetToken(token string) { f.token.Store(token) }
+
+// startRefresh calls refresh which immediately calls tokenRefresher
+// and then starts a timer to call tokenRefresher in the future.
+func (f *tokenCredential) startRefresh(tokenRefresher func(c TokenCredential) time.Duration) {
+	f.tokenRefresher = tokenRefresher
+	f.stopped = false // In case user calls StartRefresh, StopRefresh, & then StartRefresh again
+	f.refresh()
+}
+
+// refresh calls the user's tokenRefresher so they can refresh the token (by
+// calling SetToken) and then starts another time (based on the returned duration)
+// in order to refresh the token again in the future.
+func (f *tokenCredential) refresh() {
+	d := f.tokenRefresher(f) // Invoke the user's refresh callback outside of the lock
+	f.lock.Lock()
+	if !f.stopped {
+		f.timer = time.AfterFunc(d, f.refresh)
+	}
+	f.lock.Unlock()
+}
+
+// stopRefresh stops any pending timer and sets stopped field to true to prevent
+// any new timer from starting.
+// NOTE: Stopping the timer allows the GC to destroy the tokenCredential object.
+func (f *tokenCredential) stopRefresh() {
+	f.lock.Lock()
+	f.stopped = true
+	if f.timer != nil {
+		f.timer.Stop()
+	}
+	f.lock.Unlock()
+}
+
+// New satisfies pipeline.Factory's New method creating a pipeline policy object.
+func (f *tokenCredential) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return pipeline.PolicyFunc(func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+		if request.URL.Scheme != "https" {
+			panic("Token credentials require a URL using the https protocol scheme.")
+		}
+		request.Header[headerAuthorization] = []string{"Bearer " + f.Token()}
+		return next.Do(ctx, request)
+	})
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_mmf_unix.go

@@ -0,0 +1,27 @@
+// +build linux darwin freebsd
+
+package azblob
+
+import (
+	"os"
+	"syscall"
+)
+
+type mmf []byte
+
+func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
+	prot, flags := syscall.PROT_READ, syscall.MAP_SHARED // Assume read-only
+	if writable {
+		prot, flags = syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED
+	}
+	addr, err := syscall.Mmap(int(file.Fd()), offset, length, prot, flags)
+	return mmf(addr), err
+}
+
+func (m *mmf) unmap() {
+	err := syscall.Munmap(*m)
+	*m = nil
+	if err != nil {
+		panic(err)
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_mmf_windows.go

@@ -0,0 +1,38 @@
+package azblob
+
+import (
+	"os"
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+type mmf []byte
+
+func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
+	prot, access := uint32(syscall.PAGE_READONLY), uint32(syscall.FILE_MAP_READ) // Assume read-only
+	if writable {
+		prot, access = uint32(syscall.PAGE_READWRITE), uint32(syscall.FILE_MAP_WRITE)
+	}
+	hMMF, errno := syscall.CreateFileMapping(syscall.Handle(file.Fd()), nil, prot, uint32(int64(length)>>32), uint32(int64(length)&0xffffffff), nil)
+	if hMMF == 0 {
+		return nil, os.NewSyscallError("CreateFileMapping", errno)
+	}
+	defer syscall.CloseHandle(hMMF)
+	addr, errno := syscall.MapViewOfFile(hMMF, access, uint32(offset>>32), uint32(offset&0xffffffff), uintptr(length))
+	m := mmf{}
+	h := (*reflect.SliceHeader)(unsafe.Pointer(&m))
+	h.Data = addr
+	h.Len = length
+	h.Cap = h.Len
+	return m, nil
+}
+
+func (m *mmf) unmap() {
+	addr := uintptr(unsafe.Pointer(&(([]byte)(*m)[0])))
+	*m = mmf{}
+	err := syscall.UnmapViewOfFile(addr)
+	if err != nil {
+		panic(err)
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_pipeline.go

@@ -0,0 +1,46 @@
+package azblob
+
+import (
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// PipelineOptions is used to configure a request policy pipeline's retry policy and logging.
+type PipelineOptions struct {
+	// Log configures the pipeline's logging infrastructure indicating what information is logged and where.
+	Log pipeline.LogOptions
+
+	// Retry configures the built-in retry policy behavior.
+	Retry RetryOptions
+
+	// RequestLog configures the built-in request logging policy.
+	RequestLog RequestLogOptions
+
+	// Telemetry configures the built-in telemetry policy behavior.
+	Telemetry TelemetryOptions
+}
+
+// NewPipeline creates a Pipeline using the specified credentials and options.
+func NewPipeline(c Credential, o PipelineOptions) pipeline.Pipeline {
+	if c == nil {
+		panic("c can't be nil")
+	}
+
+	// Closest to API goes first; closest to the wire goes last
+	f := []pipeline.Factory{
+		NewTelemetryPolicyFactory(o.Telemetry),
+		NewUniqueRequestIDPolicyFactory(),
+		NewRetryPolicyFactory(o.Retry),
+	}
+
+	if _, ok := c.(*anonymousCredentialPolicyFactory); !ok {
+		// For AnonymousCredential, we optimize out the policy factory since it doesn't do anything
+		// NOTE: The credential's policy factory must appear close to the wire so it can sign any
+		// changes made by other factories (like UniqueRequestIDPolicyFactory)
+		f = append(f, c)
+	}
+	f = append(f,
+		pipeline.MethodFactoryMarker(), // indicates at what stage in the pipeline the method factory is invoked
+		NewRequestLogPolicyFactory(o.RequestLog))
+
+	return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: nil, Log: o.Log})
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_policy_request_log.go

@@ -0,0 +1,150 @@
+package azblob
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// RequestLogOptions configures the retry policy's behavior.
+type RequestLogOptions struct {
+	// LogWarningIfTryOverThreshold logs a warning if a tried operation takes longer than the specified
+	// duration (-1=no logging; 0=default threshold).
+	LogWarningIfTryOverThreshold time.Duration
+}
+
+func (o RequestLogOptions) defaults() RequestLogOptions {
+	if o.LogWarningIfTryOverThreshold == 0 {
+		// It would be good to relate this to https://azure.microsoft.com/en-us/support/legal/sla/storage/v1_2/
+		// But this monitors the time to get the HTTP response; NOT the time to download the response body.
+		o.LogWarningIfTryOverThreshold = 3 * time.Second // Default to 3 seconds
+	}
+	return o
+}
+
+// NewRequestLogPolicyFactory creates a RequestLogPolicyFactory object configured using the specified options.
+func NewRequestLogPolicyFactory(o RequestLogOptions) pipeline.Factory {
+	o = o.defaults() // Force defaults to be calculated
+	return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
+		// These variables are per-policy; shared by multiple calls to Do
+		var try int32
+		operationStart := time.Now() // If this is the 1st try, record the operation state time
+		return func(ctx context.Context, request pipeline.Request) (response pipeline.Response, err error) {
+			try++ // The first try is #1 (not #0)
+
+			// Log the outgoing request as informational
+			if po.ShouldLog(pipeline.LogInfo) {
+				b := &bytes.Buffer{}
+				fmt.Fprintf(b, "==> OUTGOING REQUEST (Try=%d)\n", try)
+				pipeline.WriteRequestWithResponse(b, prepareRequestForLogging(request), nil, nil)
+				po.Log(pipeline.LogInfo, b.String())
+			}
+
+			// Set the time for this particular retry operation and then Do the operation.
+			tryStart := time.Now()
+			response, err = next.Do(ctx, request) // Make the request
+			tryEnd := time.Now()
+			tryDuration := tryEnd.Sub(tryStart)
+			opDuration := tryEnd.Sub(operationStart)
+
+			logLevel, forceLog := pipeline.LogInfo, false // Default logging information
+
+			// If the response took too long, we'll upgrade to warning.
+			if o.LogWarningIfTryOverThreshold > 0 && tryDuration > o.LogWarningIfTryOverThreshold {
+				// Log a warning if the try duration exceeded the specified threshold
+				logLevel, forceLog = pipeline.LogWarning, true
+			}
+
+			if err == nil { // We got a response from the service
+				sc := response.Response().StatusCode
+				if ((sc >= 400 && sc <= 499) && sc != http.StatusNotFound && sc != http.StatusConflict && sc != http.StatusPreconditionFailed && sc != http.StatusRequestedRangeNotSatisfiable) || (sc >= 500 && sc <= 599) {
+					logLevel, forceLog = pipeline.LogError, true // Promote to Error any 4xx (except those listed is an error) or any 5xx
+				} else {
+					// For other status codes, we leave the level as is.
+				}
+			} else { // This error did not get an HTTP response from the service; upgrade the severity to Error
+				logLevel, forceLog = pipeline.LogError, true
+			}
+
+			if shouldLog := po.ShouldLog(logLevel); forceLog || shouldLog {
+				// We're going to log this; build the string to log
+				b := &bytes.Buffer{}
+				slow := ""
+				if o.LogWarningIfTryOverThreshold > 0 && tryDuration > o.LogWarningIfTryOverThreshold {
+					slow = fmt.Sprintf("[SLOW >%v]", o.LogWarningIfTryOverThreshold)
+				}
+				fmt.Fprintf(b, "==> REQUEST/RESPONSE (Try=%d/%v%s, OpTime=%v) -- ", try, tryDuration, slow, opDuration)
+				if err != nil { // This HTTP request did not get a response from the service
+					fmt.Fprint(b, "REQUEST ERROR\n")
+				} else {
+					if logLevel == pipeline.LogError {
+						fmt.Fprint(b, "RESPONSE STATUS CODE ERROR\n")
+					} else {
+						fmt.Fprint(b, "RESPONSE SUCCESSFULLY RECEIVED\n")
+					}
+				}
+
+				pipeline.WriteRequestWithResponse(b, prepareRequestForLogging(request), response.Response(), err)
+				if logLevel <= pipeline.LogError {
+					b.Write(stack()) // For errors (or lower levels), we append the stack trace (an expensive operation)
+				}
+				msg := b.String()
+
+				if forceLog {
+					pipeline.ForceLog(logLevel, msg)
+				}
+				if shouldLog {
+					po.Log(logLevel, msg)
+				}
+			}
+			return response, err
+		}
+	})
+}
+
+func redactSigQueryParam(rawQuery string) (bool, string) {
+	rawQuery = strings.ToLower(rawQuery) // lowercase the string so we can look for ?sig= and &sig=
+	sigFound := strings.Contains(rawQuery, "?sig=")
+	if !sigFound {
+		sigFound = strings.Contains(rawQuery, "&sig=")
+		if !sigFound {
+			return sigFound, rawQuery // [?|&]sig= not found; return same rawQuery passed in (no memory allocation)
+		}
+	}
+	// [?|&]sig= found, redact its value
+	values, _ := url.ParseQuery(rawQuery)
+	for name := range values {
+		if strings.EqualFold(name, "sig") {
+			values[name] = []string{"REDACTED"}
+		}
+	}
+	return sigFound, values.Encode()
+}
+
+func prepareRequestForLogging(request pipeline.Request) *http.Request {
+	req := request
+	if sigFound, rawQuery := redactSigQueryParam(req.URL.RawQuery); sigFound {
+		// Make copy so we don't destroy the query parameters we actually need to send in the request
+		req = request.Copy()
+		req.Request.URL.RawQuery = rawQuery
+	}
+	return req.Request
+}
+
+func stack() []byte {
+	buf := make([]byte, 1024)
+	for {
+		n := runtime.Stack(buf, false)
+		if n < len(buf) {
+			return buf[:n]
+		}
+		buf = make([]byte, 2*len(buf))
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_policy_retry.go

@@ -0,0 +1,318 @@
+package azblob
+
+import (
+	"context"
+	"math/rand"
+	"net"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io/ioutil"
+	"io"
+)
+
+// RetryPolicy tells the pipeline what kind of retry policy to use. See the RetryPolicy* constants.
+type RetryPolicy int32
+
+const (
+	// RetryPolicyExponential tells the pipeline to use an exponential back-off retry policy
+	RetryPolicyExponential RetryPolicy = 0
+
+	// RetryPolicyFixed tells the pipeline to use a fixed back-off retry policy
+	RetryPolicyFixed RetryPolicy = 1
+)
+
+// RetryOptions configures the retry policy's behavior.
+type RetryOptions struct {
+	// Policy tells the pipeline what kind of retry policy to use. See the RetryPolicy* constants.\
+	// A value of zero means that you accept our default policy.
+	Policy RetryPolicy
+
+	// MaxTries specifies the maximum number of attempts an operation will be tried before producing an error (0=default).
+	// A value of zero means that you accept our default policy. A value of 1 means 1 try and no retries.
+	MaxTries int32
+
+	// TryTimeout indicates the maximum time allowed for any single try of an HTTP request.
+	// A value of zero means that you accept our default timeout. NOTE: When transferring large amounts
+	// of data, the default TryTimeout will probably not be sufficient. You should override this value
+	// based on the bandwidth available to the host machine and proximity to the Storage service. A good
+	// starting point may be something like (60 seconds per MB of anticipated-payload-size).
+	TryTimeout time.Duration
+
+	// RetryDelay specifies the amount of delay to use before retrying an operation (0=default).
+	// When RetryPolicy is specified as RetryPolicyExponential, the delay increases exponentially
+	// with each retry up to a maximum specified by MaxRetryDelay.
+	// If you specify 0, then you must also specify 0 for MaxRetryDelay.
+	// If you specify RetryDelay, then you must also specify MaxRetryDelay, and MaxRetryDelay should be
+	// equal to or greater than RetryDelay.
+	RetryDelay time.Duration
+
+	// MaxRetryDelay specifies the maximum delay allowed before retrying an operation (0=default).
+	// If you specify 0, then you must also specify 0 for RetryDelay.
+	MaxRetryDelay time.Duration
+
+	// RetryReadsFromSecondaryHost specifies whether the retry policy should retry a read operation against another host.
+	// If RetryReadsFromSecondaryHost is "" (the default) then operations are not retried against another host.
+	// NOTE: Before setting this field, make sure you understand the issues around reading stale & potentially-inconsistent
+	// data at this webpage: https://docs.microsoft.com/en-us/azure/storage/common/storage-designing-ha-apps-with-ragrs
+	RetryReadsFromSecondaryHost string	// Comment this our for non-Blob SDKs
+}
+
+func (o RetryOptions) retryReadsFromSecondaryHost() string {
+	return o.RetryReadsFromSecondaryHost	// This is for the Blob SDK only
+	//return "" // This is for non-blob SDKs
+}
+
+func (o RetryOptions) defaults() RetryOptions {
+	if o.Policy != RetryPolicyExponential && o.Policy != RetryPolicyFixed {
+		panic("RetryPolicy must be RetryPolicyExponential or RetryPolicyFixed")
+	}
+	if o.MaxTries < 0 {
+		panic("MaxTries must be >= 0")
+	}
+	if o.TryTimeout < 0 || o.RetryDelay < 0 || o.MaxRetryDelay < 0 {
+		panic("TryTimeout, RetryDelay, and MaxRetryDelay must all be >= 0")
+	}
+	if o.RetryDelay > o.MaxRetryDelay {
+		panic("RetryDelay must be <= MaxRetryDelay")
+	}
+	if (o.RetryDelay == 0 && o.MaxRetryDelay != 0) || (o.RetryDelay != 0 && o.MaxRetryDelay == 0) {
+		panic("Both RetryDelay and MaxRetryDelay must be 0 or neither can be 0")
+	}
+
+	IfDefault := func(current *time.Duration, desired time.Duration) {
+		if *current == time.Duration(0) {
+			*current = desired
+		}
+	}
+
+	// Set defaults if unspecified
+	if o.MaxTries == 0 {
+		o.MaxTries = 4
+	}
+	switch o.Policy {
+	case RetryPolicyExponential:
+		IfDefault(&o.TryTimeout, 1*time.Minute)
+		IfDefault(&o.RetryDelay, 4*time.Second)
+		IfDefault(&o.MaxRetryDelay, 120*time.Second)
+
+	case RetryPolicyFixed:
+		IfDefault(&o.TryTimeout, 1*time.Minute)
+		IfDefault(&o.RetryDelay, 30*time.Second)
+		IfDefault(&o.MaxRetryDelay, 120*time.Second)
+	}
+	return o
+}
+
+func (o RetryOptions) calcDelay(try int32) time.Duration { // try is >=1; never 0
+	pow := func(number int64, exponent int32) int64 { // pow is nested helper function
+		var result int64 = 1
+		for n := int32(0); n < exponent; n++ {
+			result *= number
+		}
+		return result
+	}
+
+	delay := time.Duration(0)
+	switch o.Policy {
+	case RetryPolicyExponential:
+		delay = time.Duration(pow(2, try-1)-1) * o.RetryDelay
+
+	case RetryPolicyFixed:
+		if try > 1 { // Any try after the 1st uses the fixed delay
+			delay = o.RetryDelay
+		}
+	}
+
+	// Introduce some jitter:  [0.0, 1.0) / 2 = [0.0, 0.5) + 0.8 = [0.8, 1.3)
+	delay = time.Duration(delay.Seconds() * (rand.Float64()/2 + 0.8) * float64(time.Second)) // NOTE: We want math/rand; not crypto/rand
+	if delay > o.MaxRetryDelay {
+		delay = o.MaxRetryDelay
+	}
+	return delay
+}
+
+// NewRetryPolicyFactory creates a RetryPolicyFactory object configured using the specified options.
+func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
+	o = o.defaults() // Force defaults to be calculated
+	return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
+		return func(ctx context.Context, request pipeline.Request) (response pipeline.Response, err error) {
+			// Before each try, we'll select either the primary or secondary URL.
+			primaryTry := int32(0) // This indicates how many tries we've attempted against the primary DC
+
+			// We only consider retrying against a secondary if we have a read request (GET/HEAD) AND this policy has a Secondary URL it can use
+			considerSecondary := (request.Method == http.MethodGet || request.Method == http.MethodHead) && o.retryReadsFromSecondaryHost() != ""
+
+			// Exponential retry algorithm: ((2 ^ attempt) - 1) * delay * random(0.8, 1.2)
+			// When to retry: connection failure or temporary/timeout. NOTE: StorageError considers HTTP 500/503 as temporary & is therefore retryable
+			// If using a secondary:
+			//    Even tries go against primary; odd tries go against the secondary
+			//    For a primary wait ((2 ^ primaryTries - 1) * delay * random(0.8, 1.2)
+			//    If secondary gets a 404, don't fail, retry but future retries are only against the primary
+			//    When retrying against a secondary, ignore the retry count and wait (.1 second * random(0.8, 1.2))
+			for try := int32(1); try <= o.MaxTries; try++ {
+				logf("\n=====> Try=%d\n", try)
+
+				// Determine which endpoint to try. It's primary if there is no secondary or if it is an add # attempt.
+				tryingPrimary := !considerSecondary || (try%2 == 1)
+				// Select the correct host and delay
+				if tryingPrimary {
+					primaryTry++
+					delay := o.calcDelay(primaryTry)
+					logf("Primary try=%d, Delay=%v\n", primaryTry, delay)
+					time.Sleep(delay) // The 1st try returns 0 delay
+				} else {
+					delay := time.Second * time.Duration(rand.Float32()/2+0.8)
+					logf("Secondary try=%d, Delay=%v\n", try-primaryTry, delay)
+					time.Sleep(delay) // Delay with some jitter before trying secondary
+				}
+
+				// Clone the original request to ensure that each try starts with the original (unmutated) request.
+				requestCopy := request.Copy()
+
+				// For each try, seek to the beginning of the Body stream. We do this even for the 1st try because
+				// the stream may not be at offset 0 when we first get it and we want the same behavior for the
+				// 1st try as for additional tries.
+				if err = requestCopy.RewindBody(); err != nil {
+					panic(err)
+				}
+				if !tryingPrimary {
+					requestCopy.Request.URL.Host = o.retryReadsFromSecondaryHost()
+				}
+
+				// Set the server-side timeout query parameter "timeout=[seconds]"
+				timeout := int32(o.TryTimeout.Seconds()) // Max seconds per try
+				if deadline, ok := ctx.Deadline(); ok {  // If user's ctx has a deadline, make the timeout the smaller of the two
+					t := int32(deadline.Sub(time.Now()).Seconds()) // Duration from now until user's ctx reaches its deadline
+					logf("MaxTryTimeout=%d secs, TimeTilDeadline=%d sec\n", timeout, t)
+					if t < timeout {
+						timeout = t
+					}
+					if timeout < 0 {
+						timeout = 0 // If timeout ever goes negative, set it to zero; this happen while debugging
+					}
+					logf("TryTimeout adjusted to=%d sec\n", timeout)
+				}
+				q := requestCopy.Request.URL.Query()
+				q.Set("timeout", strconv.Itoa(int(timeout+1))) // Add 1 to "round up"
+				requestCopy.Request.URL.RawQuery = q.Encode()
+				logf("Url=%s\n", requestCopy.Request.URL.String())
+
+				// Set the time for this particular retry operation and then Do the operation.
+				tryCtx, tryCancel := context.WithTimeout(ctx, time.Second*time.Duration(timeout))
+				//requestCopy.Body = &deadlineExceededReadCloser{r: requestCopy.Request.Body}
+				response, err = next.Do(tryCtx, requestCopy) // Make the request
+				/*err = improveDeadlineExceeded(err)
+				if err == nil {
+					response.Response().Body = &deadlineExceededReadCloser{r: response.Response().Body}
+				}*/
+				logf("Err=%v, response=%v\n", err, response)
+
+				action := "" // This MUST get changed within the switch code below
+				switch {
+				case ctx.Err() != nil:
+					action = "NoRetry: Op timeout"
+				case !tryingPrimary && response != nil && response.Response().StatusCode == http.StatusNotFound:
+					// If attempt was against the secondary & it returned a StatusNotFound (404), then
+					// the resource was not found. This may be due to replication delay. So, in this
+					// case, we'll never try the secondary again for this operation.
+					considerSecondary = false
+					action = "Retry: Secondary URL returned 404"
+				case err != nil:
+					// NOTE: Protocol Responder returns non-nil if REST API returns invalid status code for the invoked operation
+					if netErr, ok := err.(net.Error); ok && (netErr.Temporary() || netErr.Timeout()) {
+						action = "Retry: net.Error and Temporary() or Timeout()"
+					} else {
+						action = "NoRetry: unrecognized error"
+					}
+				default:
+					action = "NoRetry: successful HTTP request" // no error
+				}
+
+				logf("Action=%s\n", action)
+				// fmt.Println(action + "\n") // This is where we could log the retry operation; action is why we're retrying
+				if action[0] != 'R' { // Retry only if action starts with 'R'
+					if err != nil {
+						tryCancel() // If we're returning an error, cancel this current/last per-retry timeout context
+					} else {
+						// TODO: Right now, we've decided to leak the per-try Context until the user's Context is canceled.
+						// Another option is that we wrap the last per-try context in a body and overwrite the Response's Body field with our wrapper.
+						// So, when the user closes the Body, the our per-try context gets closed too.
+						// Another option, is that the Last Policy do this wrapping for a per-retry context (not for the user's context)
+						_ = tryCancel // So, for now, we don't call cancel: cancel()
+					}
+					break // Don't retry
+				}
+				if response != nil && response.Response() != nil && response.Response().Body != nil {
+					// If we're going to retry and we got a previous response, then flush its body to avoid leaking its TCP connection
+					body := response.Response().Body
+					io.Copy(ioutil.Discard, body)
+					body.Close()
+				}
+				// If retrying, cancel the current per-try timeout context
+				tryCancel()
+			}
+			return response, err // Not retryable or too many retries; return the last response/error
+		}
+	})
+}
+
+// According to https://github.com/golang/go/wiki/CompilerOptimizations, the compiler will inline this method and hopefully optimize all calls to it away
+var logf = func(format string, a ...interface{}) {}
+
+// Use this version to see the retry method's code path (import "fmt")
+//var logf = fmt.Printf
+
+/*
+type deadlineExceededReadCloser struct {
+	r io.ReadCloser
+}
+
+func (r *deadlineExceededReadCloser) Read(p []byte) (int, error) {
+	n, err := 0, io.EOF
+	if r.r != nil {
+		n, err = r.r.Read(p)
+	}
+	return n, improveDeadlineExceeded(err)
+}
+func (r *deadlineExceededReadCloser) Seek(offset int64, whence int) (int64, error) {
+	// For an HTTP request, the ReadCloser MUST also implement seek
+	// For an HTTP response, Seek MUST not be called (or this will panic)
+	o, err := r.r.(io.Seeker).Seek(offset, whence)
+	return o, improveDeadlineExceeded(err)
+}
+func (r *deadlineExceededReadCloser) Close() error {
+	if c, ok := r.r.(io.Closer); ok {
+		c.Close()
+	}
+	return nil
+}
+
+// timeoutError is the internal struct that implements our richer timeout error.
+type deadlineExceeded struct {
+	responseError
+}
+
+var _ net.Error = (*deadlineExceeded)(nil) // Ensure deadlineExceeded implements the net.Error interface at compile time
+
+// improveDeadlineExceeded creates a timeoutError object that implements the error interface IF cause is a context.DeadlineExceeded error.
+func improveDeadlineExceeded(cause error) error {
+	// If cause is not DeadlineExceeded, return the same error passed in.
+	if cause != context.DeadlineExceeded {
+		return cause
+	}
+	// Else, convert DeadlineExceeded to our timeoutError which gives a richer string message
+	return &deadlineExceeded{
+		responseError: responseError{
+			ErrorNode: pipeline.ErrorNode{}.Initialize(cause, 3),
+		},
+	}
+}
+
+// Error implements the error interface's Error method to return a string representation of the error.
+func (e *deadlineExceeded) Error() string {
+	return e.ErrorNode.Error("context deadline exceeded; when creating a pipeline, consider increasing RetryOptions' TryTimeout field")
+}
+*/

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_policy_telemetry.go

@@ -0,0 +1,51 @@
+package azblob
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// TelemetryOptions configures the telemetry policy's behavior.
+type TelemetryOptions struct {
+	// Value is a string prepended to each request's User-Agent and sent to the service.
+	// The service records the user-agent in logs for diagnostics and tracking of client requests.
+	Value string
+}
+
+// NewTelemetryPolicyFactory creates a factory that can create telemetry policy objects
+// which add telemetry information to outgoing HTTP requests.
+func NewTelemetryPolicyFactory(o TelemetryOptions) pipeline.Factory {
+	b := &bytes.Buffer{}
+	b.WriteString(o.Value)
+	if b.Len() > 0 {
+		b.WriteRune(' ')
+	}
+	fmt.Fprintf(b, "Azure-Storage/%s %s", serviceLibVersion, platformInfo)
+	telemetryValue := b.String()
+
+	return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
+		return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+			request.Header.Set("User-Agent", telemetryValue)
+			return next.Do(ctx, request)
+		}
+	})
+}
+
+// NOTE: the ONLY function that should write to this variable is this func
+var platformInfo = func() string {
+	// Azure-Storage/version (runtime; os type and version)”
+	// Azure-Storage/1.4.0 (NODE-VERSION v4.5.0; Windows_NT 10.0.14393)'
+	operatingSystem := runtime.GOOS // Default OS string
+	switch operatingSystem {
+	case "windows":
+		operatingSystem = os.Getenv("OS") // Get more specific OS information
+	case "linux": // accept default OS info
+	case "freebsd": //  accept default OS info
+	}
+	return fmt.Sprintf("(%s; %s)", runtime.Version(), operatingSystem)
+}()

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_policy_unique_request_id.go

@@ -0,0 +1,24 @@
+package azblob
+
+import (
+	"context"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+// NewUniqueRequestIDPolicyFactory creates a UniqueRequestIDPolicyFactory object
+// that sets the request's x-ms-client-request-id header if it doesn't already exist.
+func NewUniqueRequestIDPolicyFactory() pipeline.Factory {
+	return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
+		// This is Policy's Do method:
+		return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+			id := request.Header.Get(xMsClientRequestID)
+			if id == "" { // Add a unique request ID if the caller didn't specify one already
+				request.Header.Set(xMsClientRequestID, newUUID().String())
+			}
+			return next.Do(ctx, request)
+		}
+	})
+}
+
+const xMsClientRequestID = "x-ms-client-request-id"

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_retry_reader.go

@@ -0,0 +1,122 @@
+package azblob
+
+import (
+	"context"
+	"io"
+	"net"
+	"net/http"
+)
+
+const CountToEnd = 0
+
+// HTTPGetter is a function type that refers to a method that performs an HTTP GET operation.
+type HTTPGetter func(ctx context.Context, i HTTPGetterInfo) (*http.Response, error)
+
+// HTTPGetterInfo is passed to an HTTPGetter function passing it parameters
+// that should be used to make an HTTP GET request.
+type HTTPGetterInfo struct {
+	// Offset specifies the start offset that should be used when
+	// creating the HTTP GET request's Range header
+	Offset int64
+
+	// Count specifies the count of bytes that should be used to calculate
+	// the end offset when creating the HTTP GET request's Range header
+	Count int64
+
+	// ETag specifies the resource's etag that should be used when creating
+	// the HTTP GET request's If-Match header
+	ETag ETag
+}
+
+// RetryReaderOptions contains properties which can help to decide when to do retry.
+type RetryReaderOptions struct {
+	// MaxRetryRequests specifies the maximum number of HTTP GET requests that will be made
+	// while reading from a RetryReader. A value of zero means that no additional HTTP
+	// GET requests will be made.
+	MaxRetryRequests   int
+	doInjectError      bool
+	doInjectErrorRound int
+}
+
+// retryReader implements io.ReaderCloser methods.
+// retryReader tries to read from response, and if there is retriable network error
+// returned during reading, it will retry according to retry reader option through executing
+// user defined action with provided data to get a new response, and continue the overall reading process
+// through reading from the new response.
+type retryReader struct {
+	ctx             context.Context
+	response        *http.Response
+	info            HTTPGetterInfo
+	countWasBounded bool
+	o               RetryReaderOptions
+	getter          HTTPGetter
+}
+
+// NewRetryReader creates a retry reader.
+func NewRetryReader(ctx context.Context, initialResponse *http.Response,
+	info HTTPGetterInfo, o RetryReaderOptions, getter HTTPGetter) io.ReadCloser {
+	if getter == nil {
+		panic("getter must not be nil")
+	}
+	if info.Count < 0 {
+		panic("info.Count must be >= 0")
+	}
+	if o.MaxRetryRequests < 0 {
+		panic("o.MaxRetryRequests must be >= 0")
+	}
+	return &retryReader{ctx: ctx, getter: getter, info: info, countWasBounded: info.Count != CountToEnd, response: initialResponse, o: o}
+}
+
+func (s *retryReader) Read(p []byte) (n int, err error) {
+	for try := 0; ; try++ {
+		//fmt.Println(try)       // Comment out for debugging.
+		if s.countWasBounded && s.info.Count == CountToEnd {
+			// User specified an original count and the remaining bytes are 0, return 0, EOF
+			return 0, io.EOF
+		}
+
+		if s.response == nil { // We don't have a response stream to read from, try to get one.
+			response, err := s.getter(s.ctx, s.info)
+			if err != nil {
+				return 0, err
+			}
+			// Successful GET; this is the network stream we'll read from.
+			s.response = response
+		}
+		n, err := s.response.Body.Read(p) // Read from the stream
+
+		// Injection mechanism for testing.
+		if s.o.doInjectError && try == s.o.doInjectErrorRound {
+			err = &net.DNSError{IsTemporary: true}
+		}
+
+		// We successfully read data or end EOF.
+		if err == nil || err == io.EOF {
+			s.info.Offset += int64(n) // Increments the start offset in case we need to make a new HTTP request in the future
+			if s.info.Count != CountToEnd {
+				s.info.Count -= int64(n) // Decrement the count in case we need to make a new HTTP request in the future
+			}
+			return n, err // Return the return to the caller
+		}
+		s.Close()        // Error, close stream
+		s.response = nil // Our stream is no longer good
+
+		// Check the retry count and error code, and decide whether to retry.
+		if try >= s.o.MaxRetryRequests {
+			return n, err // All retries exhausted
+		}
+
+		if netErr, ok := err.(net.Error); ok && (netErr.Timeout() || netErr.Temporary()) {
+			continue
+			// Loop around and try to get and read from new stream.
+		}
+		return n, err // Not retryable, just return
+	}
+}
+
+func (s *retryReader) Close() error {
+	if s.response != nil && s.response.Body != nil {
+		return s.response.Body.Close()
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_sas_account.go

@@ -0,0 +1,217 @@
+package azblob
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"time"
+)
+
+// AccountSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage account.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/constructing-an-account-sas
+type AccountSASSignatureValues struct {
+	Version       string      `param:"sv"`  // If not specified, this defaults to SASVersion
+	Protocol      SASProtocol `param:"spr"` // See the SASProtocol* constants
+	StartTime     time.Time   `param:"st"`  // Not specified if IsZero
+	ExpiryTime    time.Time   `param:"se"`  // Not specified if IsZero
+	Permissions   string      `param:"sp"`  // Create by initializing a AccountSASPermissions and then call String()
+	IPRange       IPRange     `param:"sip"`
+	Services      string      `param:"ss"`  // Create by initializing AccountSASServices and then call String()
+	ResourceTypes string      `param:"srt"` // Create by initializing AccountSASResourceTypes and then call String()
+}
+
+// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
+// the proper SAS query parameters.
+func (v AccountSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
+	// https://docs.microsoft.com/en-us/rest/api/storageservices/Constructing-an-Account-SAS
+	if v.ExpiryTime.IsZero() || v.Permissions == "" || v.ResourceTypes == "" || v.Services == "" {
+		panic("Account SAS is missing at least one of these: ExpiryTime, Permissions, Service, or ResourceType")
+	}
+	if v.Version == "" {
+		v.Version = SASVersion
+	}
+	perms := &AccountSASPermissions{}
+	if err := perms.Parse(v.Permissions); err != nil {
+		panic(err)
+	}
+	v.Permissions = perms.String()
+
+	startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
+
+	stringToSign := strings.Join([]string{
+		sharedKeyCredential.AccountName(),
+		v.Permissions,
+		v.Services,
+		v.ResourceTypes,
+		startTime,
+		expiryTime,
+		v.IPRange.String(),
+		string(v.Protocol),
+		v.Version,
+		""}, // That right, the account SAS requires a terminating extra newline
+		"\n")
+
+	signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
+	p := SASQueryParameters{
+		// Common SAS parameters
+		version:     v.Version,
+		protocol:    v.Protocol,
+		startTime:   v.StartTime,
+		expiryTime:  v.ExpiryTime,
+		permissions: v.Permissions,
+		ipRange:     v.IPRange,
+
+		// Account-specific SAS parameters
+		services:      v.Services,
+		resourceTypes: v.ResourceTypes,
+
+		// Calculated SAS signature
+		signature: signature,
+	}
+	return p
+}
+
+// The AccountSASPermissions type simplifies creating the permissions string for an Azure Storage Account SAS.
+// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Permissions field.
+type AccountSASPermissions struct {
+	Read, Write, Delete, List, Add, Create, Update, Process bool
+}
+
+// String produces the SAS permissions string for an Azure Storage account.
+// Call this method to set AccountSASSignatureValues's Permissions field.
+func (p AccountSASPermissions) String() string {
+	var buffer bytes.Buffer
+	if p.Read {
+		buffer.WriteRune('r')
+	}
+	if p.Write {
+		buffer.WriteRune('w')
+	}
+	if p.Delete {
+		buffer.WriteRune('d')
+	}
+	if p.List {
+		buffer.WriteRune('l')
+	}
+	if p.Add {
+		buffer.WriteRune('a')
+	}
+	if p.Create {
+		buffer.WriteRune('c')
+	}
+	if p.Update {
+		buffer.WriteRune('u')
+	}
+	if p.Process {
+		buffer.WriteRune('p')
+	}
+	return buffer.String()
+}
+
+// Parse initializes the AccountSASPermissions's fields from a string.
+func (p *AccountSASPermissions) Parse(s string) error {
+	*p = AccountSASPermissions{} // Clear out the flags
+	for _, r := range s {
+		switch r {
+		case 'r':
+			p.Read = true
+		case 'w':
+			p.Write = true
+		case 'd':
+			p.Delete = true
+		case 'l':
+			p.List = true
+		case 'a':
+			p.Add = true
+		case 'c':
+			p.Create = true
+		case 'u':
+			p.Update = true
+		case 'p':
+			p.Process = true
+		default:
+			return fmt.Errorf("Invalid permission character: '%v'", r)
+		}
+	}
+	return nil
+}
+
+// The AccountSASServices type simplifies creating the services string for an Azure Storage Account SAS.
+// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Services field.
+type AccountSASServices struct {
+	Blob, Queue, File bool
+}
+
+// String produces the SAS services string for an Azure Storage account.
+// Call this method to set AccountSASSignatureValues's Services field.
+func (s AccountSASServices) String() string {
+	var buffer bytes.Buffer
+	if s.Blob {
+		buffer.WriteRune('b')
+	}
+	if s.Queue {
+		buffer.WriteRune('q')
+	}
+	if s.File {
+		buffer.WriteRune('f')
+	}
+	return buffer.String()
+}
+
+// Parse initializes the AccountSASServices' fields from a string.
+func (a *AccountSASServices) Parse(s string) error {
+	*a = AccountSASServices{} // Clear out the flags
+	for _, r := range s {
+		switch r {
+		case 'b':
+			a.Blob = true
+		case 'q':
+			a.Queue = true
+		case 'f':
+			a.File = true
+		default:
+			return fmt.Errorf("Invalid service character: '%v'", r)
+		}
+	}
+	return nil
+}
+
+// The AccountSASResourceTypes type simplifies creating the resource types string for an Azure Storage Account SAS.
+// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's ResourceTypes field.
+type AccountSASResourceTypes struct {
+	Service, Container, Object bool
+}
+
+// String produces the SAS resource types string for an Azure Storage account.
+// Call this method to set AccountSASSignatureValues's ResourceTypes field.
+func (rt AccountSASResourceTypes) String() string {
+	var buffer bytes.Buffer
+	if rt.Service {
+		buffer.WriteRune('s')
+	}
+	if rt.Container {
+		buffer.WriteRune('c')
+	}
+	if rt.Object {
+		buffer.WriteRune('o')
+	}
+	return buffer.String()
+}
+
+// Parse initializes the AccountSASResourceType's fields from a string.
+func (rt *AccountSASResourceTypes) Parse(s string) error {
+	*rt = AccountSASResourceTypes{} // Clear out the flags
+	for _, r := range s {
+		switch r {
+		case 's':
+			rt.Service = true
+		case 'q':
+			rt.Container = true
+		case 'o':
+			rt.Object = true
+		default:
+			return fmt.Errorf("Invalid resource type: '%v'", r)
+		}
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_sas_query_params.go

@@ -0,0 +1,211 @@
+package azblob
+
+import (
+	"net"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// SASVersion indicates the SAS version.
+const SASVersion = ServiceVersion
+
+type SASProtocol string
+
+const (
+	// SASProtocolHTTPS can be specified for a SAS protocol
+	SASProtocolHTTPS SASProtocol = "https"
+
+	// SASProtocolHTTPSandHTTP can be specified for a SAS protocol
+	SASProtocolHTTPSandHTTP SASProtocol = "https,http"
+)
+
+// FormatTimesForSASSigning converts a time.Time to a snapshotTimeFormat string suitable for a
+// SASField's StartTime or ExpiryTime fields. Returns "" if value.IsZero().
+func FormatTimesForSASSigning(startTime, expiryTime time.Time) (string, string) {
+	ss := ""
+	if !startTime.IsZero() {
+		ss = startTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
+	}
+	se := ""
+	if !expiryTime.IsZero() {
+		se = expiryTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
+	}
+	return ss, se
+}
+
+// SASTimeFormat represents the format of a SAS start or expiry time. Use it when formatting/parsing a time.Time.
+const SASTimeFormat = "2006-01-02T15:04:05Z" //"2017-07-27T00:00:00Z" // ISO 8601
+
+// https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
+
+// A SASQueryParameters object represents the components that make up an Azure Storage SAS' query parameters.
+// You parse a map of query parameters into its fields by calling NewSASQueryParameters(). You add the components
+// to a query parameter map by calling AddToValues().
+// NOTE: Changing any field requires computing a new SAS signature using a XxxSASSignatureValues type.
+//
+// This type defines the components used by all Azure Storage resources (Containers, Blobs, Files, & Queues).
+type SASQueryParameters struct {
+	// All members are immutable or values so copies of this struct are goroutine-safe.
+	version       string      `param:"sv"`
+	services      string      `param:"ss"`
+	resourceTypes string      `param:"srt"`
+	protocol      SASProtocol `param:"spr"`
+	startTime     time.Time   `param:"st"`
+	expiryTime    time.Time   `param:"se"`
+	ipRange       IPRange     `param:"sip"`
+	identifier    string      `param:"si"`
+	resource      string      `param:"sr"`
+	permissions   string      `param:"sp"`
+	signature     string      `param:"sig"`
+}
+
+func (p *SASQueryParameters) Version() string {
+	return p.version
+}
+
+func (p *SASQueryParameters) Services() string {
+	return p.services
+}
+func (p *SASQueryParameters) ResourceTypes() string {
+	return p.resourceTypes
+}
+func (p *SASQueryParameters) Protocol() SASProtocol {
+	return p.protocol
+}
+func (p *SASQueryParameters) StartTime() time.Time {
+	return p.startTime
+}
+func (p *SASQueryParameters) ExpiryTime() time.Time {
+	return p.expiryTime
+}
+
+func (p *SASQueryParameters) IPRange() IPRange {
+	return p.ipRange
+}
+
+func (p *SASQueryParameters) Identifier() string {
+	return p.identifier
+}
+
+func (p *SASQueryParameters) Resource() string {
+	return p.resource
+}
+func (p *SASQueryParameters) Permissions() string {
+	return p.permissions
+}
+
+func (p *SASQueryParameters) Signature() string {
+	return p.signature
+}
+
+// IPRange represents a SAS IP range's start IP and (optionally) end IP.
+type IPRange struct {
+	Start net.IP // Not specified if length = 0
+	End   net.IP // Not specified if length = 0
+}
+
+// String returns a string representation of an IPRange.
+func (ipr *IPRange) String() string {
+	if len(ipr.Start) == 0 {
+		return ""
+	}
+	start := ipr.Start.String()
+	if len(ipr.End) == 0 {
+		return start
+	}
+	return start + "-" + ipr.End.String()
+}
+
+// NewSASQueryParameters creates and initializes a SASQueryParameters object based on the
+// query parameter map's passed-in values. If deleteSASParametersFromValues is true,
+// all SAS-related query parameters are removed from the passed-in map. If
+// deleteSASParametersFromValues is false, the map passed-in map is unaltered.
+func newSASQueryParameters(values url.Values, deleteSASParametersFromValues bool) SASQueryParameters {
+	p := SASQueryParameters{}
+	for k, v := range values {
+		val := v[0]
+		isSASKey := true
+		switch strings.ToLower(k) {
+		case "sv":
+			p.version = val
+		case "ss":
+			p.services = val
+		case "srt":
+			p.resourceTypes = val
+		case "spr":
+			p.protocol = SASProtocol(val)
+		case "st":
+			p.startTime, _ = time.Parse(SASTimeFormat, val)
+		case "se":
+			p.expiryTime, _ = time.Parse(SASTimeFormat, val)
+		case "sip":
+			dashIndex := strings.Index(val, "-")
+			if dashIndex == -1 {
+				p.ipRange.Start = net.ParseIP(val)
+			} else {
+				p.ipRange.Start = net.ParseIP(val[:dashIndex])
+				p.ipRange.End = net.ParseIP(val[dashIndex+1:])
+			}
+		case "si":
+			p.identifier = val
+		case "sr":
+			p.resource = val
+		case "sp":
+			p.permissions = val
+		case "sig":
+			p.signature = val
+		default:
+			isSASKey = false // We didn't recognize the query parameter
+		}
+		if isSASKey && deleteSASParametersFromValues {
+			delete(values, k)
+		}
+	}
+	return p
+}
+
+// AddToValues adds the SAS components to the specified query parameters map.
+func (p *SASQueryParameters) addToValues(v url.Values) url.Values {
+	if p.version != "" {
+		v.Add("sv", p.version)
+	}
+	if p.services != "" {
+		v.Add("ss", p.services)
+	}
+	if p.resourceTypes != "" {
+		v.Add("srt", p.resourceTypes)
+	}
+	if p.protocol != "" {
+		v.Add("spr", string(p.protocol))
+	}
+	if !p.startTime.IsZero() {
+		v.Add("st", p.startTime.Format(SASTimeFormat))
+	}
+	if !p.expiryTime.IsZero() {
+		v.Add("se", p.expiryTime.Format(SASTimeFormat))
+	}
+	if len(p.ipRange.Start) > 0 {
+		v.Add("sip", p.ipRange.String())
+	}
+	if p.identifier != "" {
+		v.Add("si", p.identifier)
+	}
+	if p.resource != "" {
+		v.Add("sr", p.resource)
+	}
+	if p.permissions != "" {
+		v.Add("sp", p.permissions)
+	}
+	if p.signature != "" {
+		v.Add("sig", p.signature)
+	}
+	return v
+}
+
+// Encode encodes the SAS query parameters into URL encoded form sorted by key.
+func (p *SASQueryParameters) Encode() string {
+	v := url.Values{}
+	p.addToValues(v)
+	return v.Encode()
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_service_codes_common.go

@@ -0,0 +1,131 @@
+package azblob
+
+// https://docs.microsoft.com/en-us/rest/api/storageservices/common-rest-api-error-codes
+
+const (
+	// ServiceCodeNone is the default value. It indicates that the error was related to the service or that the service didn't return a code.
+	ServiceCodeNone ServiceCodeType = ""
+
+	// ServiceCodeAccountAlreadyExists means the specified account already exists.
+	ServiceCodeAccountAlreadyExists ServiceCodeType = "AccountAlreadyExists"
+
+	// ServiceCodeAccountBeingCreated means the specified account is in the process of being created (403).
+	ServiceCodeAccountBeingCreated ServiceCodeType = "AccountBeingCreated"
+
+	// ServiceCodeAccountIsDisabled means the specified account is disabled (403).
+	ServiceCodeAccountIsDisabled ServiceCodeType = "AccountIsDisabled"
+
+	// ServiceCodeAuthenticationFailed means the server failed to authenticate the request. Make sure the value of the Authorization header is formed correctly including the signature (403).
+	ServiceCodeAuthenticationFailed ServiceCodeType = "AuthenticationFailed"
+
+	// ServiceCodeConditionHeadersNotSupported means the condition headers are not supported (400).
+	ServiceCodeConditionHeadersNotSupported ServiceCodeType = "ConditionHeadersNotSupported"
+
+	// ServiceCodeConditionNotMet means the condition specified in the conditional header(s) was not met for a read/write operation (304/412).
+	ServiceCodeConditionNotMet ServiceCodeType = "ConditionNotMet"
+
+	// ServiceCodeEmptyMetadataKey means the key for one of the metadata key-value pairs is empty (400).
+	ServiceCodeEmptyMetadataKey ServiceCodeType = "EmptyMetadataKey"
+
+	// ServiceCodeInsufficientAccountPermissions means read operations are currently disabled or Write operations are not allowed or The account being accessed does not have sufficient permissions to execute this operation (403).
+	ServiceCodeInsufficientAccountPermissions ServiceCodeType = "InsufficientAccountPermissions"
+
+	// ServiceCodeInternalError means the server encountered an internal error. Please retry the request (500).
+	ServiceCodeInternalError ServiceCodeType = "InternalError"
+
+	// ServiceCodeInvalidAuthenticationInfo means the authentication information was not provided in the correct format. Verify the value of Authorization header (400).
+	ServiceCodeInvalidAuthenticationInfo ServiceCodeType = "InvalidAuthenticationInfo"
+
+	// ServiceCodeInvalidHeaderValue means the value provided for one of the HTTP headers was not in the correct format (400).
+	ServiceCodeInvalidHeaderValue ServiceCodeType = "InvalidHeaderValue"
+
+	// ServiceCodeInvalidHTTPVerb means the HTTP verb specified was not recognized by the server (400).
+	ServiceCodeInvalidHTTPVerb ServiceCodeType = "InvalidHttpVerb"
+
+	// ServiceCodeInvalidInput means one of the request inputs is not valid (400).
+	ServiceCodeInvalidInput ServiceCodeType = "InvalidInput"
+
+	// ServiceCodeInvalidMd5 means the MD5 value specified in the request is invalid. The MD5 value must be 128 bits and Base64-encoded (400).
+	ServiceCodeInvalidMd5 ServiceCodeType = "InvalidMd5"
+
+	// ServiceCodeInvalidMetadata means the specified metadata is invalid. It includes characters that are not permitted (400).
+	ServiceCodeInvalidMetadata ServiceCodeType = "InvalidMetadata"
+
+	// ServiceCodeInvalidQueryParameterValue means an invalid value was specified for one of the query parameters in the request URI (400).
+	ServiceCodeInvalidQueryParameterValue ServiceCodeType = "InvalidQueryParameterValue"
+
+	// ServiceCodeInvalidRange means the range specified is invalid for the current size of the resource (416).
+	ServiceCodeInvalidRange ServiceCodeType = "InvalidRange"
+
+	// ServiceCodeInvalidResourceName means the specified resource name contains invalid characters (400).
+	ServiceCodeInvalidResourceName ServiceCodeType = "InvalidResourceName"
+
+	// ServiceCodeInvalidURI means the requested URI does not represent any resource on the server (400).
+	ServiceCodeInvalidURI ServiceCodeType = "InvalidUri"
+
+	// ServiceCodeInvalidXMLDocument means the specified XML is not syntactically valid (400).
+	ServiceCodeInvalidXMLDocument ServiceCodeType = "InvalidXmlDocument"
+
+	// ServiceCodeInvalidXMLNodeValue means the value provided for one of the XML nodes in the request body was not in the correct format (400).
+	ServiceCodeInvalidXMLNodeValue ServiceCodeType = "InvalidXmlNodeValue"
+
+	// ServiceCodeMd5Mismatch means the MD5 value specified in the request did not match the MD5 value calculated by the server (400).
+	ServiceCodeMd5Mismatch ServiceCodeType = "Md5Mismatch"
+
+	// ServiceCodeMetadataTooLarge means the size of the specified metadata exceeds the maximum size permitted (400).
+	ServiceCodeMetadataTooLarge ServiceCodeType = "MetadataTooLarge"
+
+	// ServiceCodeMissingContentLengthHeader means the Content-Length header was not specified (411).
+	ServiceCodeMissingContentLengthHeader ServiceCodeType = "MissingContentLengthHeader"
+
+	// ServiceCodeMissingRequiredQueryParameter means a required query parameter was not specified for this request (400).
+	ServiceCodeMissingRequiredQueryParameter ServiceCodeType = "MissingRequiredQueryParameter"
+
+	// ServiceCodeMissingRequiredHeader means a required HTTP header was not specified (400).
+	ServiceCodeMissingRequiredHeader ServiceCodeType = "MissingRequiredHeader"
+
+	// ServiceCodeMissingRequiredXMLNode means a required XML node was not specified in the request body (400).
+	ServiceCodeMissingRequiredXMLNode ServiceCodeType = "MissingRequiredXmlNode"
+
+	// ServiceCodeMultipleConditionHeadersNotSupported means multiple condition headers are not supported (400).
+	ServiceCodeMultipleConditionHeadersNotSupported ServiceCodeType = "MultipleConditionHeadersNotSupported"
+
+	// ServiceCodeOperationTimedOut means the operation could not be completed within the permitted time (500).
+	ServiceCodeOperationTimedOut ServiceCodeType = "OperationTimedOut"
+
+	// ServiceCodeOutOfRangeInput means one of the request inputs is out of range (400).
+	ServiceCodeOutOfRangeInput ServiceCodeType = "OutOfRangeInput"
+
+	// ServiceCodeOutOfRangeQueryParameterValue means a query parameter specified in the request URI is outside the permissible range (400).
+	ServiceCodeOutOfRangeQueryParameterValue ServiceCodeType = "OutOfRangeQueryParameterValue"
+
+	// ServiceCodeRequestBodyTooLarge means the size of the request body exceeds the maximum size permitted (413).
+	ServiceCodeRequestBodyTooLarge ServiceCodeType = "RequestBodyTooLarge"
+
+	// ServiceCodeResourceTypeMismatch means the specified resource type does not match the type of the existing resource (409).
+	ServiceCodeResourceTypeMismatch ServiceCodeType = "ResourceTypeMismatch"
+
+	// ServiceCodeRequestURLFailedToParse means the url in the request could not be parsed (400).
+	ServiceCodeRequestURLFailedToParse ServiceCodeType = "RequestUrlFailedToParse"
+
+	// ServiceCodeResourceAlreadyExists means the specified resource already exists (409).
+	ServiceCodeResourceAlreadyExists ServiceCodeType = "ResourceAlreadyExists"
+
+	// ServiceCodeResourceNotFound means the specified resource does not exist (404).
+	ServiceCodeResourceNotFound ServiceCodeType = "ResourceNotFound"
+
+	// ServiceCodeServerBusy means the server is currently unable to receive requests. Please retry your request or Ingress/egress is over the account limit or operations per second is over the account limit (503).
+	ServiceCodeServerBusy ServiceCodeType = "ServerBusy"
+
+	// ServiceCodeUnsupportedHeader means one of the HTTP headers specified in the request is not supported (400).
+	ServiceCodeUnsupportedHeader ServiceCodeType = "UnsupportedHeader"
+
+	// ServiceCodeUnsupportedXMLNode means one of the XML nodes specified in the request body is not supported (400).
+	ServiceCodeUnsupportedXMLNode ServiceCodeType = "UnsupportedXmlNode"
+
+	// ServiceCodeUnsupportedQueryParameter means one of the query parameters specified in the request URI is not supported (400).
+	ServiceCodeUnsupportedQueryParameter ServiceCodeType = "UnsupportedQueryParameter"
+
+	// ServiceCodeUnsupportedHTTPVerb means the resource doesn't support the specified HTTP verb (405).
+	ServiceCodeUnsupportedHTTPVerb ServiceCodeType = "UnsupportedHttpVerb"
+)

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_storage_error.go

@@ -0,0 +1,110 @@
+package azblob
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"net/http"
+	"sort"
+
+	"github.com/Azure/azure-pipeline-go/pipeline"
+)
+
+func init() {
+	// wire up our custom error handling constructor
+	responseErrorFactory = newStorageError
+}
+
+// ServiceCodeType is a string identifying a storage service error.
+// For more information, see https://docs.microsoft.com/en-us/rest/api/storageservices/status-and-error-codes2
+type ServiceCodeType string
+
+// StorageError identifies a responder-generated network or response parsing error.
+type StorageError interface {
+	// ResponseError implements error's Error(), net.Error's Temporary() and Timeout() methods & Response().
+	ResponseError
+
+	// ServiceCode returns a service error code. Your code can use this to make error recovery decisions.
+	ServiceCode() ServiceCodeType
+}
+
+// storageError is the internal struct that implements the public StorageError interface.
+type storageError struct {
+	responseError
+	serviceCode ServiceCodeType
+	details     map[string]string
+}
+
+// newStorageError creates an error object that implements the error interface.
+func newStorageError(cause error, response *http.Response, description string) error {
+	return &storageError{
+		responseError: responseError{
+			ErrorNode:   pipeline.ErrorNode{}.Initialize(cause, 3),
+			response:    response,
+			description: description,
+		},
+	}
+}
+
+// ServiceCode returns service-error information. The caller may examine these values but should not modify any of them.
+func (e *storageError) ServiceCode() ServiceCodeType { return e.serviceCode }
+
+// Error implements the error interface's Error method to return a string representation of the error.
+func (e *storageError) Error() string {
+	b := &bytes.Buffer{}
+	fmt.Fprintf(b, "===== RESPONSE ERROR (ServiceCode=%s) =====\n", e.serviceCode)
+	fmt.Fprintf(b, "Description=%s, Details: ", e.description)
+	if len(e.details) == 0 {
+		b.WriteString("(none)\n")
+	} else {
+		b.WriteRune('\n')
+		keys := make([]string, 0, len(e.details))
+		// Alphabetize the details
+		for k := range e.details {
+			keys = append(keys, k)
+		}
+		sort.Strings(keys)
+		for _, k := range keys {
+			fmt.Fprintf(b, "   %s: %+v\n", k, e.details[k])
+		}
+	}
+	req := pipeline.Request{Request: e.response.Request}.Copy() // Make a copy of the response's request
+	pipeline.WriteRequestWithResponse(b, prepareRequestForLogging(req), e.response, nil)
+	return e.ErrorNode.Error(b.String())
+}
+
+// Temporary returns true if the error occurred due to a temporary condition (including an HTTP status of 500 or 503).
+func (e *storageError) Temporary() bool {
+	if e.response != nil {
+		if (e.response.StatusCode == http.StatusInternalServerError) || (e.response.StatusCode == http.StatusServiceUnavailable) {
+			return true
+		}
+	}
+	return e.ErrorNode.Temporary()
+}
+
+// UnmarshalXML performs custom unmarshalling of XML-formatted Azure storage request errors.
+func (e *storageError) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
+	tokName := ""
+	var t xml.Token
+	for t, err = d.Token(); err == nil; t, err = d.Token() {
+		switch tt := t.(type) {
+		case xml.StartElement:
+			tokName = tt.Name.Local
+			break
+		case xml.CharData:
+			switch tokName {
+			case "Code":
+				e.serviceCode = ServiceCodeType(tt)
+			case "Message":
+				e.description = string(tt)
+			default:
+				if e.details == nil {
+					e.details = map[string]string{}
+				}
+				e.details[tokName] = string(tt)
+			}
+		}
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_util_validate.go

@@ -0,0 +1,61 @@
+package azblob
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strconv"
+)
+
+// httpRange defines a range of bytes within an HTTP resource, starting at offset and
+// ending at offset+count. A zero-value httpRange indicates the entire resource. An httpRange
+// which has an offset but na zero value count indicates from the offset to the resource's end.
+type httpRange struct {
+	offset int64
+	count  int64
+}
+
+func (r httpRange) pointers() *string {
+	if r.offset == 0 && r.count == 0 { // Do common case first for performance
+		return nil	// No specified range
+	}
+	if r.offset < 0 {
+		panic("The range offset must be >= 0")
+	}
+	if r.count < 0 {
+		panic("The range count must be >= 0")
+	}
+	endOffset := "" // if count == 0
+	if r.count > 0 {
+		endOffset = strconv.FormatInt((r.offset+r.count)-1, 10)
+	}
+	dataRange := fmt.Sprintf("bytes=%v-%s", r.offset, endOffset)
+	return &dataRange
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func validateSeekableStreamAt0AndGetCount(body io.ReadSeeker) int64 {
+	if body == nil { // nil body's are "logically" seekable to 0 and are 0 bytes long
+		return 0
+	}
+	validateSeekableStreamAt0(body)
+	count, err := body.Seek(0, io.SeekEnd)
+	if err != nil {
+		panic("failed to seek stream")
+	}
+	body.Seek(0, io.SeekStart)
+	return count
+}
+
+func validateSeekableStreamAt0(body io.ReadSeeker) {
+	if body == nil { // nil body's are "logically" seekable to 0
+		return
+	}
+	if pos, err := body.Seek(0, io.SeekCurrent); pos != 0 || err != nil {
+		if err != nil {
+			panic(err)
+		}
+		panic(errors.New("stream must be set to position 0"))
+	}
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zc_uuid.go

@@ -0,0 +1,80 @@
+package azblob
+
+import (
+	"crypto/rand"
+	"fmt"
+	"strconv"
+)
+
+// The UUID reserved variants.
+const (
+	reservedNCS       byte = 0x80
+	reservedRFC4122   byte = 0x40
+	reservedMicrosoft byte = 0x20
+	reservedFuture    byte = 0x00
+)
+
+// A UUID representation compliant with specification in RFC 4122 document.
+type uuid [16]byte
+
+// NewUUID returns a new uuid using RFC 4122 algorithm.
+func newUUID() (u uuid) {
+	u = uuid{}
+	// Set all bits to randomly (or pseudo-randomly) chosen values.
+	_, err := rand.Read(u[:])
+	if err != nil {
+		panic("ran.Read failed")
+	}
+	u[8] = (u[8] | reservedRFC4122) & 0x7F // u.setVariant(ReservedRFC4122)
+
+	var version byte = 4
+	u[6] = (u[6] & 0xF) | (version << 4) // u.setVersion(4)
+	return
+}
+
+// String returns an unparsed version of the generated UUID sequence.
+func (u uuid) String() string {
+	return fmt.Sprintf("%x-%x-%x-%x-%x", u[0:4], u[4:6], u[6:8], u[8:10], u[10:])
+}
+
+// ParseUUID parses a string formatted as "003020100-0504-0706-0809-0a0b0c0d0e0f"
+// or "{03020100-0504-0706-0809-0a0b0c0d0e0f}" into a UUID.
+func parseUUID(uuidStr string) uuid {
+	char := func(hexString string) byte {
+		i, _ := strconv.ParseUint(hexString, 16, 8)
+		return byte(i)
+	}
+	if uuidStr[0] == '{' {
+		uuidStr = uuidStr[1:] // Skip over the '{'
+	}
+	// 03020100 - 05 04 - 07 06 - 08 09 - 0a 0b 0c 0d 0e 0f
+	//             1 11 1 11 11 1 12 22 2 22 22 22 33 33 33
+	// 01234567 8 90 12 3 45 67 8 90 12 3 45 67 89 01 23 45
+	uuidVal := uuid{
+		char(uuidStr[0:2]),
+		char(uuidStr[2:4]),
+		char(uuidStr[4:6]),
+		char(uuidStr[6:8]),
+
+		char(uuidStr[9:11]),
+		char(uuidStr[11:13]),
+
+		char(uuidStr[14:16]),
+		char(uuidStr[16:18]),
+
+		char(uuidStr[19:21]),
+		char(uuidStr[21:23]),
+
+		char(uuidStr[24:26]),
+		char(uuidStr[26:28]),
+		char(uuidStr[28:30]),
+		char(uuidStr[30:32]),
+		char(uuidStr[32:34]),
+		char(uuidStr[34:36]),
+	}
+	return uuidVal
+}
+
+func (u uuid) bytes() []byte {
+	return u[:]
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zt_doc.go

@@ -0,0 +1,89 @@
+// Copyright 2017 Microsoft Corporation. All rights reserved.
+// Use of this source code is governed by an MIT
+// license that can be found in the LICENSE file.
+
+/*
+Package azblob allows you to manipulate Azure Storage containers and blobs objects.
+
+URL Types
+
+The most common types you'll work with are the XxxURL types. The methods of these types make requests
+against the Azure Storage Service.
+
+ - ServiceURL's          methods perform operations on a storage account.
+    - ContainerURL's     methods perform operations on an account's container.
+       - BlockBlobURL's  methods perform operations on a container's block blob.
+       - AppendBlobURL's methods perform operations on a container's append blob.
+       - PageBlobURL's   methods perform operations on a container's page blob.
+       - BlobURL's       methods perform operations on a container's blob regardless of the blob's type.
+
+Internally, each XxxURL object contains a URL and a request pipeline. The URL indicates the endpoint where each HTTP
+request is sent and the pipeline indicates how the outgoing HTTP request and incoming HTTP response is processed.
+The pipeline specifies things like retry policies, logging, deserialization of HTTP response payloads, and more.
+
+Pipelines are threadsafe and may be shared by multiple XxxURL objects. When you create a ServiceURL, you pass
+an initial pipeline. When you call ServiceURL's NewContainerURL method, the new ContainerURL object has its own
+URL but it shares the same pipeline as the parent ServiceURL object.
+
+To work with a blob, call one of ContainerURL's 4 NewXxxBlobURL methods depending on how you want to treat the blob.
+To treat the blob as a block blob, append blob, or page blob, call NewBlockBlobURL, NewAppendBlobURL, or NewPageBlobURL
+respectively. These three types are all identical except for the methods they expose; each type exposes the methods
+relevant to the type of blob represented. If you're not sure how you want to treat a blob, you can call NewBlobURL;
+this returns an object whose methods are relevant to any kind of blob. When you call ContainerURL's NewXxxBlobURL,
+the new XxxBlobURL object has its own URL but it shares the same pipeline as the parent ContainerURL object. You
+can easily switch between blob types (method sets) by calling a ToXxxBlobURL method.
+
+If you'd like to use a different pipeline with a ServiceURL, ContainerURL, or XxxBlobURL object, then call the XxxURL
+object's WithPipeline method passing in the desired pipeline. The WithPipeline methods create a new XxxURL object
+with the same URL as the original but with the specified pipeline.
+
+Note that XxxURL objects use little memory, are goroutine-safe, and many objects share the same pipeline. This means that
+XxxURL objects share a lot of system resources making them very efficient.
+
+All of XxxURL's methods that make HTTP requests return rich error handling information so you can discern network failures,
+transient failures, timeout failures, service failures, etc. See the StorageError interface for more information and an
+example of how to do deal with errors.
+
+URL and Shared Access Signature Manipulation
+
+The library includes a BlobURLParts type for deconstructing and reconstructing URLs. And you can use the following types
+for generating and parsing Shared Access Signature (SAS)
+ - Use the AccountSASSignatureValues type to create a SAS for a storage account.
+ - Use the BlobSASSignatureValues type to create a SAS for a container or blob.
+ - Use the SASQueryParameters type to turn signature values in to query parameres or to parse query parameters.
+
+To generate a SAS, you must use the SharedKeyCredential type.
+
+Credentials
+
+When creating a request pipeline, you must specify one of this package's credential types.
+ - Call the NewAnonymousCredential function for requests that contain a Shared Access Signature (SAS).
+ - Call the NewSharedKeyCredential function (with an account name & key) to access any account resources. You must also use this
+   to generate Shared Access Signatures.
+
+HTTP Request Policy Factories
+
+This package defines several request policy factories for use with the pipeline package.
+Most applications will not use these factories directly; instead, the NewPipeline
+function creates these factories, initializes them (via the PipelineOptions type)
+and returns a pipeline object for use by the XxxURL objects.
+
+However, for advanced scenarios, developers can access these policy factories directly
+and even create their own and then construct their own pipeline in order to affect HTTP
+requests and responses performed by the XxxURL objects. For example, developers can
+introduce their own logging, random failures, request recording & playback for fast
+testing, HTTP request pacing, alternate retry mechanisms, metering, metrics, etc. The
+possibilities are endless!
+
+Below are the request pipeline policy factory functions that are provided with this
+package:
+ - NewRetryPolicyFactory           Enables rich retry semantics for failed HTTP requests.
+ - NewRequestLogPolicyFactory      Enables rich logging support for HTTP requests/responses & failures.
+ - NewTelemetryPolicyFactory       Enables simple modification of the HTTP request's User-Agent header so each request reports the SDK version & language/runtime making the requests.
+ - NewUniqueRequestIDPolicyFactory Adds a x-ms-client-request-id header with a unique UUID value to an HTTP request to help with diagnosing failures.
+
+Also, note that all the NewXxxCredential functions return request policy factory objects which get injected into the pipeline.
+*/
+package azblob
+
+// 	TokenCredential     Use this to access resources using Role-Based Access Control (RBAC).

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_append_blob.go

@@ -0,0 +1,234 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"context"
+	"encoding/base64"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// appendBlobClient is the client for the AppendBlob methods of the Azblob service.
+type appendBlobClient struct {
+	managementClient
+}
+
+// newAppendBlobClient creates an instance of the appendBlobClient client.
+func newAppendBlobClient(url url.URL, p pipeline.Pipeline) appendBlobClient {
+	return appendBlobClient{newManagementClient(url, p)}
+}
+
+// AppendBlock the Append Block operation commits a new block of data to the end of an existing append blob. The Append
+// Block operation is permitted only if the blob was created with x-ms-blob-type set to AppendBlob. Append Block is
+// supported only on version 2015-02-21 version or later.
+//
+// body is initial data body will be closed upon successful return. Callers should ensure closure when receiving an
+// error.contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. maxSize is optional conditional header. The max length in bytes permitted for
+// the append blob. If the Append Block operation would cause the blob to exceed that limit or if the blob size is
+// already greater than the value specified in this header, the request will fail with MaxBlobSizeConditionNotMet error
+// (HTTP status code 412 - Precondition Failed). appendPosition is optional conditional header, used only for the
+// Append Block operation. A number indicating the byte offset to compare. Append Block will succeed only if the append
+// position is equal to this number. If it is not, the request will fail with the AppendPositionConditionNotMet error
+// (HTTP status code 412 - Precondition Failed). ifModifiedSince is specify this header value to operate only on a blob
+// if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate
+// only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to
+// operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
+// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
+// in the analytics logs when storage analytics logging is enabled.
+func (client appendBlobClient) AppendBlock(ctx context.Context, body io.ReadSeeker, contentLength int64, timeout *int32, leaseID *string, maxSize *int64, appendPosition *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*AppendBlobAppendBlockResponse, error) {
+	if err := validate([]validation{
+		{targetValue: body,
+			constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.appendBlockPreparer(body, contentLength, timeout, leaseID, maxSize, appendPosition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.appendBlockResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*AppendBlobAppendBlockResponse), err
+}
+
+// appendBlockPreparer prepares the AppendBlock request.
+func (client appendBlobClient) appendBlockPreparer(body io.ReadSeeker, contentLength int64, timeout *int32, leaseID *string, maxSize *int64, appendPosition *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, body)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "appendblock")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if maxSize != nil {
+		req.Header.Set("x-ms-blob-condition-maxsize", strconv.FormatInt(*maxSize, 10))
+	}
+	if appendPosition != nil {
+		req.Header.Set("x-ms-blob-condition-appendpos", strconv.FormatInt(*appendPosition, 10))
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// appendBlockResponder handles the response to the AppendBlock request.
+func (client appendBlobClient) appendBlockResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &AppendBlobAppendBlockResponse{rawResponse: resp.Response()}, err
+}
+
+// Create the Create Append Blob operation creates a new append blob.
+//
+// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
+// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
+// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
+// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
+// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
+// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
+// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
+// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
+// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
+// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
+// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
+// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
+// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
+// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
+// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
+// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
+// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
+// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client appendBlobClient) Create(ctx context.Context, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*AppendBlobCreateResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
+		{targetValue: metadata,
+			constraints: []constraint{{target: "metadata", name: null, rule: false,
+				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.createPreparer(contentLength, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*AppendBlobCreateResponse), err
+}
+
+// createPreparer prepares the Create request.
+func (client appendBlobClient) createPreparer(contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if blobContentType != nil {
+		req.Header.Set("x-ms-blob-content-type", *blobContentType)
+	}
+	if blobContentEncoding != nil {
+		req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
+	}
+	if blobContentLanguage != nil {
+		req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
+	}
+	if blobContentMD5 != nil {
+		req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
+	}
+	if blobCacheControl != nil {
+		req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
+	}
+	if metadata != nil {
+		for k, v := range metadata {
+			req.Header.Set("x-ms-meta-"+k, v)
+		}
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if blobContentDisposition != nil {
+		req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	req.Header.Set("x-ms-blob-type", "AppendBlob")
+	return req, nil
+}
+
+// createResponder handles the response to the Create request.
+func (client appendBlobClient) createResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &AppendBlobCreateResponse{rawResponse: resp.Response()}, err
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_block_blob.go

@@ -0,0 +1,498 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/xml"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// blockBlobClient is the client for the BlockBlob methods of the Azblob service.
+type blockBlobClient struct {
+	managementClient
+}
+
+// newBlockBlobClient creates an instance of the blockBlobClient client.
+func newBlockBlobClient(url url.URL, p pipeline.Pipeline) blockBlobClient {
+	return blockBlobClient{newManagementClient(url, p)}
+}
+
+// CommitBlockList the Commit Block List operation writes a blob by specifying the list of block IDs that make up the
+// blob. In order to be written as part of a blob, a block must have been successfully written to the server in a prior
+// Put Block operation. You can call Put Block List to update a blob by uploading only those blocks that have changed,
+// then committing the new and existing blocks together. You can do this by specifying whether to commit a block from
+// the committed block list or from the uncommitted block list, or to commit the most recently uploaded version of the
+// block, whichever list it may belong to.
+//
+// timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> blobCacheControl is optional. Sets the blob's cache control. If specified,
+// this property is stored with the blob and returned with a read request. blobContentType is optional. Sets the blob's
+// content type. If specified, this property is stored with the blob and returned with a read request.
+// blobContentEncoding is optional. Sets the blob's content encoding. If specified, this property is stored with the
+// blob and returned with a read request. blobContentLanguage is optional. Set the blob's content language. If
+// specified, this property is stored with the blob and returned with a read request. blobContentMD5 is optional. An
+// MD5 hash of the blob content. Note that this hash is not validated, as the hashes for the individual blocks were
+// validated when each was uploaded. metadata is optional. Specifies a user-defined name-value pair associated with the
+// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
+// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
+// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
+// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
+// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
+// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
+// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
+// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
+// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
+// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client blockBlobClient) CommitBlockList(ctx context.Context, blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlockBlobCommitBlockListResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
+		{targetValue: metadata,
+			constraints: []constraint{{target: "metadata", name: null, rule: false,
+				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.commitBlockListPreparer(blocks, timeout, blobCacheControl, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.commitBlockListResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*BlockBlobCommitBlockListResponse), err
+}
+
+// commitBlockListPreparer prepares the CommitBlockList request.
+func (client blockBlobClient) commitBlockListPreparer(blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "blocklist")
+	req.URL.RawQuery = params.Encode()
+	if blobCacheControl != nil {
+		req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
+	}
+	if blobContentType != nil {
+		req.Header.Set("x-ms-blob-content-type", *blobContentType)
+	}
+	if blobContentEncoding != nil {
+		req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
+	}
+	if blobContentLanguage != nil {
+		req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
+	}
+	if blobContentMD5 != nil {
+		req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
+	}
+	if metadata != nil {
+		for k, v := range metadata {
+			req.Header.Set("x-ms-meta-"+k, v)
+		}
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if blobContentDisposition != nil {
+		req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	b, err := xml.Marshal(blocks)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to marshal request body")
+	}
+	req.Header.Set("Content-Type", "application/xml")
+	err = req.SetBody(bytes.NewReader(b))
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to set request body")
+	}
+	return req, nil
+}
+
+// commitBlockListResponder handles the response to the CommitBlockList request.
+func (client blockBlobClient) commitBlockListResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &BlockBlobCommitBlockListResponse{rawResponse: resp.Response()}, err
+}
+
+// GetBlockList the Get Block List operation retrieves the list of blocks that have been uploaded as part of a block
+// blob
+//
+// listType is specifies whether to return the list of committed blocks, the list of uncommitted blocks, or both lists
+// together. snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob
+// snapshot to retrieve. For more information on working with blob snapshots, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
+// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
+// limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client blockBlobClient) GetBlockList(ctx context.Context, listType BlockListType, snapshot *string, timeout *int32, leaseID *string, requestID *string) (*BlockList, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.getBlockListPreparer(listType, snapshot, timeout, leaseID, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getBlockListResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*BlockList), err
+}
+
+// getBlockListPreparer prepares the GetBlockList request.
+func (client blockBlobClient) getBlockListPreparer(listType BlockListType, snapshot *string, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if snapshot != nil && len(*snapshot) > 0 {
+		params.Set("snapshot", *snapshot)
+	}
+	params.Set("blocklisttype", string(listType))
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "blocklist")
+	req.URL.RawQuery = params.Encode()
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// getBlockListResponder handles the response to the GetBlockList request.
+func (client blockBlobClient) getBlockListResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &BlockList{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// StageBlock the Stage Block operation creates a new block to be committed as part of a blob
+//
+// blockID is a valid Base64 string value that identifies the block. Prior to encoding, the string must be less than or
+// equal to 64 bytes in size. For a given blob, the length of the value specified for the blockid parameter must be the
+// same size for each block. contentLength is the length of the request. body is initial data body will be closed upon
+// successful return. Callers should ensure closure when receiving an error.timeout is the timeout parameter is
+// expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
+// limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client blockBlobClient) StageBlock(ctx context.Context, blockID string, contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (*BlockBlobStageBlockResponse, error) {
+	if err := validate([]validation{
+		{targetValue: body,
+			constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.stageBlockPreparer(blockID, contentLength, body, timeout, leaseID, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.stageBlockResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*BlockBlobStageBlockResponse), err
+}
+
+// stageBlockPreparer prepares the StageBlock request.
+func (client blockBlobClient) stageBlockPreparer(blockID string, contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, body)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	params.Set("blockid", blockID)
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "block")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// stageBlockResponder handles the response to the StageBlock request.
+func (client blockBlobClient) stageBlockResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &BlockBlobStageBlockResponse{rawResponse: resp.Response()}, err
+}
+
+// StageBlockFromURL the Stage Block operation creates a new block to be committed as part of a blob where the contents
+// are read from a URL.
+//
+// blockID is a valid Base64 string value that identifies the block. Prior to encoding, the string must be less than or
+// equal to 64 bytes in size. For a given blob, the length of the value specified for the blockid parameter must be the
+// same size for each block. contentLength is the length of the request. sourceURL is specifiy an URL to the copy
+// source. sourceRange is bytes of source data in the specified range. sourceContentMD5 is specify the md5 calculated
+// for the range of bytes that must be read from the copy source. timeout is the timeout parameter is expressed in
+// seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
+// limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client blockBlobClient) StageBlockFromURL(ctx context.Context, blockID string, contentLength int64, sourceURL *string, sourceRange *string, sourceContentMD5 []byte, timeout *int32, leaseID *string, requestID *string) (*BlockBlobStageBlockFromURLResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.stageBlockFromURLPreparer(blockID, contentLength, sourceURL, sourceRange, sourceContentMD5, timeout, leaseID, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.stageBlockFromURLResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*BlockBlobStageBlockFromURLResponse), err
+}
+
+// stageBlockFromURLPreparer prepares the StageBlockFromURL request.
+func (client blockBlobClient) stageBlockFromURLPreparer(blockID string, contentLength int64, sourceURL *string, sourceRange *string, sourceContentMD5 []byte, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	params.Set("blockid", blockID)
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "block")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if sourceURL != nil {
+		req.Header.Set("x-ms-copy-source", *sourceURL)
+	}
+	if sourceRange != nil {
+		req.Header.Set("x-ms-source-range", *sourceRange)
+	}
+	if sourceContentMD5 != nil {
+		req.Header.Set("x-ms-source-content-md5", base64.StdEncoding.EncodeToString(sourceContentMD5))
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// stageBlockFromURLResponder handles the response to the StageBlockFromURL request.
+func (client blockBlobClient) stageBlockFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &BlockBlobStageBlockFromURLResponse{rawResponse: resp.Response()}, err
+}
+
+// Upload the Upload Block Blob operation updates the content of an existing block blob. Updating an existing block
+// blob overwrites any existing metadata on the blob. Partial updates are not supported with Put Blob; the content of
+// the existing blob is overwritten with the content of the new blob. To perform a partial update of the content of a
+// block blob, use the Put Block List operation.
+//
+// body is initial data body will be closed upon successful return. Callers should ensure closure when receiving an
+// error.contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
+// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
+// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
+// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
+// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
+// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
+// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
+// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
+// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
+// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
+// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
+// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
+// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
+// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
+// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
+// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
+// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
+// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client blockBlobClient) Upload(ctx context.Context, body io.ReadSeeker, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlockBlobUploadResponse, error) {
+	if err := validate([]validation{
+		{targetValue: body,
+			constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
+		{targetValue: metadata,
+			constraints: []constraint{{target: "metadata", name: null, rule: false,
+				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.uploadPreparer(body, contentLength, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.uploadResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*BlockBlobUploadResponse), err
+}
+
+// uploadPreparer prepares the Upload request.
+func (client blockBlobClient) uploadPreparer(body io.ReadSeeker, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, body)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if blobContentType != nil {
+		req.Header.Set("x-ms-blob-content-type", *blobContentType)
+	}
+	if blobContentEncoding != nil {
+		req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
+	}
+	if blobContentLanguage != nil {
+		req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
+	}
+	if blobContentMD5 != nil {
+		req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
+	}
+	if blobCacheControl != nil {
+		req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
+	}
+	if metadata != nil {
+		for k, v := range metadata {
+			req.Header.Set("x-ms-meta-"+k, v)
+		}
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if blobContentDisposition != nil {
+		req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	req.Header.Set("x-ms-blob-type", "BlockBlob")
+	return req, nil
+}
+
+// uploadResponder handles the response to the Upload request.
+func (client blockBlobClient) uploadResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &BlockBlobUploadResponse{rawResponse: resp.Response()}, err
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_client.go

@@ -0,0 +1,38 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"net/url"
+)
+
+const (
+	// ServiceVersion specifies the version of the operations used in this package.
+	ServiceVersion = "2018-03-28"
+)
+
+// managementClient is the base client for Azblob.
+type managementClient struct {
+	url url.URL
+	p   pipeline.Pipeline
+}
+
+// newManagementClient creates an instance of the managementClient client.
+func newManagementClient(url url.URL, p pipeline.Pipeline) managementClient {
+	return managementClient{
+		url: url,
+		p:   p,
+	}
+}
+
+// URL returns a copy of the URL for this client.
+func (mc managementClient) URL() url.URL {
+	return mc.url
+}
+
+// Pipeline returns the pipeline for this client.
+func (mc managementClient) Pipeline() pipeline.Pipeline {
+	return mc.p
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_page_blob.go

@@ -0,0 +1,794 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/xml"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+// pageBlobClient is the client for the PageBlob methods of the Azblob service.
+type pageBlobClient struct {
+	managementClient
+}
+
+// newPageBlobClient creates an instance of the pageBlobClient client.
+func newPageBlobClient(url url.URL, p pipeline.Pipeline) pageBlobClient {
+	return pageBlobClient{newManagementClient(url, p)}
+}
+
+// ClearPages the Clear Pages operation clears a set of pages from a page blob
+//
+// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
+// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
+// ifSequenceNumberLessThanOrEqualTo is specify this header value to operate only on a blob if it has a sequence number
+// less than or equal to the specified. ifSequenceNumberLessThan is specify this header value to operate only on a blob
+// if it has a sequence number less than the specified. ifSequenceNumberEqualTo is specify this header value to operate
+// only on a blob if it has the specified sequence number. ifModifiedSince is specify this header value to operate only
+// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
+// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
+// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
+// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
+// recorded in the analytics logs when storage analytics logging is enabled.
+func (client pageBlobClient) ClearPages(ctx context.Context, contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobClearPagesResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.clearPagesPreparer(contentLength, timeout, rangeParameter, leaseID, ifSequenceNumberLessThanOrEqualTo, ifSequenceNumberLessThan, ifSequenceNumberEqualTo, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.clearPagesResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobClearPagesResponse), err
+}
+
+// clearPagesPreparer prepares the ClearPages request.
+func (client pageBlobClient) clearPagesPreparer(contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "page")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if rangeParameter != nil {
+		req.Header.Set("x-ms-range", *rangeParameter)
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifSequenceNumberLessThanOrEqualTo != nil {
+		req.Header.Set("x-ms-if-sequence-number-le", strconv.FormatInt(*ifSequenceNumberLessThanOrEqualTo, 10))
+	}
+	if ifSequenceNumberLessThan != nil {
+		req.Header.Set("x-ms-if-sequence-number-lt", strconv.FormatInt(*ifSequenceNumberLessThan, 10))
+	}
+	if ifSequenceNumberEqualTo != nil {
+		req.Header.Set("x-ms-if-sequence-number-eq", strconv.FormatInt(*ifSequenceNumberEqualTo, 10))
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	req.Header.Set("x-ms-page-write", "clear")
+	return req, nil
+}
+
+// clearPagesResponder handles the response to the ClearPages request.
+func (client pageBlobClient) clearPagesResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobClearPagesResponse{rawResponse: resp.Response()}, err
+}
+
+// CopyIncremental the Copy Incremental operation copies a snapshot of the source page blob to a destination page blob.
+// The snapshot is copied such that only the differential changes between the previously copied snapshot are
+// transferred to the destination. The copied snapshots are complete copies of the original snapshot and can be read or
+// copied from as usual. This API is supported since REST version 2016-05-31.
+//
+// copySource is specifies the name of the source page blob snapshot. This value is a URL of up to 2 KB in length that
+// specifies a page blob snapshot. The value should be URL-encoded as it would appear in a request URI. The source blob
+// must either be public or must be authenticated via a shared access signature. timeout is the timeout parameter is
+// expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
+// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
+// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
+// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
+// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
+// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
+// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
+// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
+// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
+// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
+// recorded in the analytics logs when storage analytics logging is enabled.
+func (client pageBlobClient) CopyIncremental(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobCopyIncrementalResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
+		{targetValue: metadata,
+			constraints: []constraint{{target: "metadata", name: null, rule: false,
+				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.copyIncrementalPreparer(copySource, timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.copyIncrementalResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobCopyIncrementalResponse), err
+}
+
+// copyIncrementalPreparer prepares the CopyIncremental request.
+func (client pageBlobClient) copyIncrementalPreparer(copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "incrementalcopy")
+	req.URL.RawQuery = params.Encode()
+	if metadata != nil {
+		for k, v := range metadata {
+			req.Header.Set("x-ms-meta-"+k, v)
+		}
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-copy-source", copySource)
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// copyIncrementalResponder handles the response to the CopyIncremental request.
+func (client pageBlobClient) copyIncrementalResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobCopyIncrementalResponse{rawResponse: resp.Response()}, err
+}
+
+// Create the Create operation creates a new page blob.
+//
+// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
+// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
+// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
+// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
+// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
+// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
+// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
+// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
+// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
+// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
+// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
+// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
+// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
+// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
+// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
+// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
+// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
+// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. blobContentLength is this
+// header specifies the maximum size for the page blob, up to 1 TB. The page blob size must be aligned to a 512-byte
+// boundary. blobSequenceNumber is set for page blobs only. The sequence number is a user-controlled value that you can
+// use to track requests. The value of the sequence number must be between 0 and 2^63 - 1. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client pageBlobClient) Create(ctx context.Context, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentLength *int64, blobSequenceNumber *int64, requestID *string) (*PageBlobCreateResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
+		{targetValue: metadata,
+			constraints: []constraint{{target: "metadata", name: null, rule: false,
+				chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.createPreparer(contentLength, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobContentLength, blobSequenceNumber, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobCreateResponse), err
+}
+
+// createPreparer prepares the Create request.
+func (client pageBlobClient) createPreparer(contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentLength *int64, blobSequenceNumber *int64, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if blobContentType != nil {
+		req.Header.Set("x-ms-blob-content-type", *blobContentType)
+	}
+	if blobContentEncoding != nil {
+		req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
+	}
+	if blobContentLanguage != nil {
+		req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
+	}
+	if blobContentMD5 != nil {
+		req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
+	}
+	if blobCacheControl != nil {
+		req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
+	}
+	if metadata != nil {
+		for k, v := range metadata {
+			req.Header.Set("x-ms-meta-"+k, v)
+		}
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if blobContentDisposition != nil {
+		req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	if blobContentLength != nil {
+		req.Header.Set("x-ms-blob-content-length", strconv.FormatInt(*blobContentLength, 10))
+	}
+	if blobSequenceNumber != nil {
+		req.Header.Set("x-ms-blob-sequence-number", strconv.FormatInt(*blobSequenceNumber, 10))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	req.Header.Set("x-ms-blob-type", "PageBlob")
+	return req, nil
+}
+
+// createResponder handles the response to the Create request.
+func (client pageBlobClient) createResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobCreateResponse{rawResponse: resp.Response()}, err
+}
+
+// GetPageRanges the Get Page Ranges operation returns the list of valid page ranges for a page blob or snapshot of a
+// page blob
+//
+// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
+// retrieve. For more information on working with blob snapshots, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
+// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
+// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
+// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
+// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
+// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
+// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client pageBlobClient) GetPageRanges(ctx context.Context, snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageList, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.getPageRangesPreparer(snapshot, timeout, rangeParameter, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPageRangesResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageList), err
+}
+
+// getPageRangesPreparer prepares the GetPageRanges request.
+func (client pageBlobClient) getPageRangesPreparer(snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if snapshot != nil && len(*snapshot) > 0 {
+		params.Set("snapshot", *snapshot)
+	}
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "pagelist")
+	req.URL.RawQuery = params.Encode()
+	if rangeParameter != nil {
+		req.Header.Set("x-ms-range", *rangeParameter)
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// getPageRangesResponder handles the response to the GetPageRanges request.
+func (client pageBlobClient) getPageRangesResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &PageList{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// GetPageRangesDiff [Update] The Get Page Ranges Diff operation returns the list of valid page ranges for a page blob
+// that were changed between target blob and previous snapshot.
+//
+// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
+// retrieve. For more information on working with blob snapshots, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
+// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> prevsnapshot is optional in version 2015-07-08 and newer. The prevsnapshot
+// parameter is a DateTime value that specifies that the response will contain only pages that were changed between
+// target blob and previous snapshot. Changed pages include both updated and cleared pages. The target blob may be a
+// snapshot, as long as the snapshot specified by prevsnapshot is the older of the two. Note that incremental snapshots
+// are currently supported only for blobs created on or after January 1, 2016. rangeParameter is return only the bytes
+// of the blob in the specified range. leaseID is if specified, the operation only succeeds if the container's lease is
+// active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it has been
+// modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if
+// it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs
+// with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value.
+// requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics
+// logs when storage analytics logging is enabled.
+func (client pageBlobClient) GetPageRangesDiff(ctx context.Context, snapshot *string, timeout *int32, prevsnapshot *string, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageList, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.getPageRangesDiffPreparer(snapshot, timeout, prevsnapshot, rangeParameter, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPageRangesDiffResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageList), err
+}
+
+// getPageRangesDiffPreparer prepares the GetPageRangesDiff request.
+func (client pageBlobClient) getPageRangesDiffPreparer(snapshot *string, timeout *int32, prevsnapshot *string, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if snapshot != nil && len(*snapshot) > 0 {
+		params.Set("snapshot", *snapshot)
+	}
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	if prevsnapshot != nil && len(*prevsnapshot) > 0 {
+		params.Set("prevsnapshot", *prevsnapshot)
+	}
+	params.Set("comp", "pagelist")
+	req.URL.RawQuery = params.Encode()
+	if rangeParameter != nil {
+		req.Header.Set("x-ms-range", *rangeParameter)
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// getPageRangesDiffResponder handles the response to the GetPageRangesDiff request.
+func (client pageBlobClient) getPageRangesDiffResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &PageList{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// Resize resize the Blob
+//
+// blobContentLength is this header specifies the maximum size for the page blob, up to 1 TB. The page blob size must
+// be aligned to a 512-byte boundary. timeout is the timeout parameter is expressed in seconds. For more information,
+// see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
+// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
+// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
+// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
+// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
+// analytics logs when storage analytics logging is enabled.
+func (client pageBlobClient) Resize(ctx context.Context, blobContentLength int64, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobResizeResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.resizePreparer(blobContentLength, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.resizeResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobResizeResponse), err
+}
+
+// resizePreparer prepares the Resize request.
+func (client pageBlobClient) resizePreparer(blobContentLength int64, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "properties")
+	req.URL.RawQuery = params.Encode()
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-blob-content-length", strconv.FormatInt(blobContentLength, 10))
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// resizeResponder handles the response to the Resize request.
+func (client pageBlobClient) resizeResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobResizeResponse{rawResponse: resp.Response()}, err
+}
+
+// UpdateSequenceNumber update the sequence number of the blob
+//
+// sequenceNumberAction is required if the x-ms-blob-sequence-number header is set for the request. This property
+// applies to page blobs only. This property indicates how the service should modify the blob's sequence number timeout
+// is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
+// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
+// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
+// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
+// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
+// value. blobSequenceNumber is set for page blobs only. The sequence number is a user-controlled value that you can
+// use to track requests. The value of the sequence number must be between 0 and 2^63 - 1. requestID is provides a
+// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
+// analytics logging is enabled.
+func (client pageBlobClient) UpdateSequenceNumber(ctx context.Context, sequenceNumberAction SequenceNumberActionType, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobSequenceNumber *int64, requestID *string) (*PageBlobUpdateSequenceNumberResponse, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.updateSequenceNumberPreparer(sequenceNumberAction, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobSequenceNumber, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.updateSequenceNumberResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobUpdateSequenceNumberResponse), err
+}
+
+// updateSequenceNumberPreparer prepares the UpdateSequenceNumber request.
+func (client pageBlobClient) updateSequenceNumberPreparer(sequenceNumberAction SequenceNumberActionType, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobSequenceNumber *int64, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "properties")
+	req.URL.RawQuery = params.Encode()
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-sequence-number-action", string(sequenceNumberAction))
+	if blobSequenceNumber != nil {
+		req.Header.Set("x-ms-blob-sequence-number", strconv.FormatInt(*blobSequenceNumber, 10))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// updateSequenceNumberResponder handles the response to the UpdateSequenceNumber request.
+func (client pageBlobClient) updateSequenceNumberResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobUpdateSequenceNumberResponse{rawResponse: resp.Response()}, err
+}
+
+// UploadPages the Upload Pages operation writes a range of pages to a page blob
+//
+// body is initial data body will be closed upon successful return. Callers should ensure closure when receiving an
+// error.contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
+// information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
+// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
+// ifSequenceNumberLessThanOrEqualTo is specify this header value to operate only on a blob if it has a sequence number
+// less than or equal to the specified. ifSequenceNumberLessThan is specify this header value to operate only on a blob
+// if it has a sequence number less than the specified. ifSequenceNumberEqualTo is specify this header value to operate
+// only on a blob if it has the specified sequence number. ifModifiedSince is specify this header value to operate only
+// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
+// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
+// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
+// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
+// recorded in the analytics logs when storage analytics logging is enabled.
+func (client pageBlobClient) UploadPages(ctx context.Context, body io.ReadSeeker, contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobUploadPagesResponse, error) {
+	if err := validate([]validation{
+		{targetValue: body,
+			constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.uploadPagesPreparer(body, contentLength, timeout, rangeParameter, leaseID, ifSequenceNumberLessThanOrEqualTo, ifSequenceNumberLessThan, ifSequenceNumberEqualTo, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.uploadPagesResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*PageBlobUploadPagesResponse), err
+}
+
+// uploadPagesPreparer prepares the UploadPages request.
+func (client pageBlobClient) uploadPagesPreparer(body io.ReadSeeker, contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, body)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "page")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("Content-Length", strconv.FormatInt(contentLength, 10))
+	if rangeParameter != nil {
+		req.Header.Set("x-ms-range", *rangeParameter)
+	}
+	if leaseID != nil {
+		req.Header.Set("x-ms-lease-id", *leaseID)
+	}
+	if ifSequenceNumberLessThanOrEqualTo != nil {
+		req.Header.Set("x-ms-if-sequence-number-le", strconv.FormatInt(*ifSequenceNumberLessThanOrEqualTo, 10))
+	}
+	if ifSequenceNumberLessThan != nil {
+		req.Header.Set("x-ms-if-sequence-number-lt", strconv.FormatInt(*ifSequenceNumberLessThan, 10))
+	}
+	if ifSequenceNumberEqualTo != nil {
+		req.Header.Set("x-ms-if-sequence-number-eq", strconv.FormatInt(*ifSequenceNumberEqualTo, 10))
+	}
+	if ifModifiedSince != nil {
+		req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifUnmodifiedSince != nil {
+		req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
+	}
+	if ifMatches != nil {
+		req.Header.Set("If-Match", string(*ifMatches))
+	}
+	if ifNoneMatch != nil {
+		req.Header.Set("If-None-Match", string(*ifNoneMatch))
+	}
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	req.Header.Set("x-ms-page-write", "update")
+	return req, nil
+}
+
+// uploadPagesResponder handles the response to the UploadPages request.
+func (client pageBlobClient) uploadPagesResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusCreated)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &PageBlobUploadPagesResponse{rawResponse: resp.Response()}, err
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_responder_policy.go

@@ -0,0 +1,74 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"bytes"
+	"context"
+	"encoding/xml"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io/ioutil"
+)
+
+type responder func(resp pipeline.Response) (result pipeline.Response, err error)
+
+// ResponderPolicyFactory is a Factory capable of creating a responder pipeline.
+type responderPolicyFactory struct {
+	responder responder
+}
+
+// New creates a responder policy factory.
+func (arpf responderPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
+	return responderPolicy{next: next, responder: arpf.responder}
+}
+
+type responderPolicy struct {
+	next      pipeline.Policy
+	responder responder
+}
+
+// Do sends the request to the service and validates/deserializes the HTTP response.
+func (arp responderPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+	resp, err := arp.next.Do(ctx, request)
+	if err != nil {
+		return resp, err
+	}
+	return arp.responder(resp)
+}
+
+// validateResponse checks an HTTP response's status code against a legal set of codes.
+// If the response code is not legal, then validateResponse reads all of the response's body
+// (containing error information) and returns a response error.
+func validateResponse(resp pipeline.Response, successStatusCodes ...int) error {
+	if resp == nil {
+		return NewResponseError(nil, nil, "nil response")
+	}
+	responseCode := resp.Response().StatusCode
+	for _, i := range successStatusCodes {
+		if i == responseCode {
+			return nil
+		}
+	}
+	// only close the body in the failure case. in the
+	// success case responders will close the body as required.
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	// the service code, description and details will be populated during unmarshalling
+	responseError := NewResponseError(nil, resp.Response(), resp.Response().Status)
+	if len(b) > 0 {
+		if err = xml.Unmarshal(b, &responseError); err != nil {
+			return NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return responseError
+}
+
+// removes any BOM from the byte slice
+func removeBOM(b []byte) []byte {
+	// UTF8
+	return bytes.TrimPrefix(b, []byte("\xef\xbb\xbf"))
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_response_error.go

@@ -0,0 +1,95 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"net"
+	"net/http"
+)
+
+// if you want to provide custom error handling set this variable to your constructor function
+var responseErrorFactory func(cause error, response *http.Response, description string) error
+
+// ResponseError identifies a responder-generated network or response parsing error.
+type ResponseError interface {
+	// Error exposes the Error(), Temporary() and Timeout() methods.
+	net.Error // Includes the Go error interface
+	// Response returns the HTTP response. You may examine this but you should not modify it.
+	Response() *http.Response
+}
+
+// NewResponseError creates an error object that implements the error interface.
+func NewResponseError(cause error, response *http.Response, description string) error {
+	if responseErrorFactory != nil {
+		return responseErrorFactory(cause, response, description)
+	}
+	return &responseError{
+		ErrorNode:   pipeline.ErrorNode{}.Initialize(cause, 3),
+		response:    response,
+		description: description,
+	}
+}
+
+// responseError is the internal struct that implements the public ResponseError interface.
+type responseError struct {
+	pipeline.ErrorNode // This is embedded so that responseError "inherits" Error, Temporary, Timeout, and Cause
+	response           *http.Response
+	description        string
+}
+
+// Error implements the error interface's Error method to return a string representation of the error.
+func (e *responseError) Error() string {
+	b := &bytes.Buffer{}
+	fmt.Fprintf(b, "===== RESPONSE ERROR (Code=%v) =====\n", e.response.StatusCode)
+	fmt.Fprintf(b, "Status=%s, Description: %s\n", e.response.Status, e.description)
+	s := b.String()
+	return e.ErrorNode.Error(s)
+}
+
+// Response implements the ResponseError interface's method to return the HTTP response.
+func (e *responseError) Response() *http.Response {
+	return e.response
+}
+
+// RFC7807 PROBLEM ------------------------------------------------------------------------------------
+// RFC7807Problem ... This type can be publicly embedded in another type that wants to add additional members.
+/*type RFC7807Problem struct {
+	// Mandatory: A (relative) URI reference identifying the problem type (it MAY refer to human-readable documentation).
+	typeURI string // Should default to "about:blank"
+	// Optional: Short, human-readable summary (maybe localized).
+	title string
+	// Optional: HTTP status code generated by the origin server
+	status int
+	// Optional: Human-readable explanation for this problem occurance.
+	// Should help client correct the problem. Clients should NOT parse this string.
+	detail string
+	// Optional: A (relative) URI identifying this specific problem occurence (it may or may not be dereferenced).
+	instance string
+}
+// NewRFC7807Problem ...
+func NewRFC7807Problem(typeURI string, status int, titleFormat string, a ...interface{}) error {
+	return &RFC7807Problem{
+		typeURI: typeURI,
+		status:  status,
+		title:   fmt.Sprintf(titleFormat, a...),
+	}
+}
+// Error returns the error information as a string.
+func (e *RFC7807Problem) Error() string {
+	return e.title
+}
+// TypeURI ...
+func (e *RFC7807Problem) TypeURI() string {
+	if e.typeURI == "" {
+		e.typeURI = "about:blank"
+	}
+	return e.typeURI
+}
+// Members ...
+func (e *RFC7807Problem) Members() (status int, title, detail, instance string) {
+	return e.status, e.title, e.detail, e.instance
+}*/

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_service.go

@@ -0,0 +1,350 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"bytes"
+	"context"
+	"encoding/xml"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+)
+
+// serviceClient is the client for the Service methods of the Azblob service.
+type serviceClient struct {
+	managementClient
+}
+
+// newServiceClient creates an instance of the serviceClient client.
+func newServiceClient(url url.URL, p pipeline.Pipeline) serviceClient {
+	return serviceClient{newManagementClient(url, p)}
+}
+
+// GetProperties gets the properties of a storage account's Blob service, including properties for Storage Analytics
+// and CORS (Cross-Origin Resource Sharing) rules.
+//
+// timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
+// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client serviceClient) GetProperties(ctx context.Context, timeout *int32, requestID *string) (*StorageServiceProperties, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.getPropertiesPreparer(timeout, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPropertiesResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*StorageServiceProperties), err
+}
+
+// getPropertiesPreparer prepares the GetProperties request.
+func (client serviceClient) getPropertiesPreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("restype", "service")
+	params.Set("comp", "properties")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// getPropertiesResponder handles the response to the GetProperties request.
+func (client serviceClient) getPropertiesResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &StorageServiceProperties{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// GetStatistics retrieves statistics related to replication for the Blob service. It is only available on the
+// secondary location endpoint when read-access geo-redundant replication is enabled for the storage account.
+//
+// timeout is the timeout parameter is expressed in seconds. For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
+// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client serviceClient) GetStatistics(ctx context.Context, timeout *int32, requestID *string) (*StorageServiceStats, error) {
+	if err := validate([]validation{
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.getStatisticsPreparer(timeout, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getStatisticsResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*StorageServiceStats), err
+}
+
+// getStatisticsPreparer prepares the GetStatistics request.
+func (client serviceClient) getStatisticsPreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("restype", "service")
+	params.Set("comp", "stats")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// getStatisticsResponder handles the response to the GetStatistics request.
+func (client serviceClient) getStatisticsResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &StorageServiceStats{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// ListContainersSegment the List Containers Segment operation returns a list of the containers under the specified
+// account
+//
+// prefix is filters the results to return only containers whose name begins with the specified prefix. marker is a
+// string value that identifies the portion of the list of containers to be returned with the next listing operation.
+// The operation returns the NextMarker value within the response body if the listing operation did not return all
+// containers remaining to be listed with the current page. The NextMarker value can be used as the value for the
+// marker parameter in a subsequent call to request the next page of list items. The marker value is opaque to the
+// client. maxresults is specifies the maximum number of containers to return. If the request does not specify
+// maxresults, or specifies a value greater than 5000, the server will return up to 5000 items. Note that if the
+// listing operation crosses a partition boundary, then the service will return a continuation token for retrieving the
+// remainder of the results. For this reason, it is possible that the service will return fewer results than specified
+// by maxresults, or than the default of 5000. include is include this parameter to specify that the container's
+// metadata be returned as part of the response body. timeout is the timeout parameter is expressed in seconds. For
+// more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
+// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client serviceClient) ListContainersSegment(ctx context.Context, prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (*ListContainersResponse, error) {
+	if err := validate([]validation{
+		{targetValue: maxresults,
+			constraints: []constraint{{target: "maxresults", name: null, rule: false,
+				chain: []constraint{{target: "maxresults", name: inclusiveMinimum, rule: 1, chain: nil}}}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.listContainersSegmentPreparer(prefix, marker, maxresults, include, timeout, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.listContainersSegmentResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*ListContainersResponse), err
+}
+
+// listContainersSegmentPreparer prepares the ListContainersSegment request.
+func (client serviceClient) listContainersSegmentPreparer(prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("GET", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if prefix != nil && len(*prefix) > 0 {
+		params.Set("prefix", *prefix)
+	}
+	if marker != nil && len(*marker) > 0 {
+		params.Set("marker", *marker)
+	}
+	if maxresults != nil {
+		params.Set("maxresults", strconv.FormatInt(int64(*maxresults), 10))
+	}
+	if include != ListContainersIncludeNone {
+		params.Set("include", string(include))
+	}
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("comp", "list")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	return req, nil
+}
+
+// listContainersSegmentResponder handles the response to the ListContainersSegment request.
+func (client serviceClient) listContainersSegmentResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK)
+	if resp == nil {
+		return nil, err
+	}
+	result := &ListContainersResponse{rawResponse: resp.Response()}
+	if err != nil {
+		return result, err
+	}
+	defer resp.Response().Body.Close()
+	b, err := ioutil.ReadAll(resp.Response().Body)
+	if err != nil {
+		return result, NewResponseError(err, resp.Response(), "failed to read response body")
+	}
+	if len(b) > 0 {
+		b = removeBOM(b)
+		err = xml.Unmarshal(b, result)
+		if err != nil {
+			return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
+		}
+	}
+	return result, nil
+}
+
+// SetProperties sets properties for a storage account's Blob service endpoint, including properties for Storage
+// Analytics and CORS (Cross-Origin Resource Sharing) rules
+//
+// storageServiceProperties is the StorageService properties. timeout is the timeout parameter is expressed in seconds.
+// For more information, see <a
+// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
+// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
+func (client serviceClient) SetProperties(ctx context.Context, storageServiceProperties StorageServiceProperties, timeout *int32, requestID *string) (*ServiceSetPropertiesResponse, error) {
+	if err := validate([]validation{
+		{targetValue: storageServiceProperties,
+			constraints: []constraint{{target: "storageServiceProperties.Logging", name: null, rule: false,
+				chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy", name: null, rule: true,
+					chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: null, rule: false,
+						chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
+					}},
+				}},
+				{target: "storageServiceProperties.HourMetrics", name: null, rule: false,
+					chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy", name: null, rule: false,
+						chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: null, rule: false,
+							chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
+						}},
+					}},
+				{target: "storageServiceProperties.MinuteMetrics", name: null, rule: false,
+					chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy", name: null, rule: false,
+						chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: null, rule: false,
+							chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
+						}},
+					}},
+				{target: "storageServiceProperties.DeleteRetentionPolicy", name: null, rule: false,
+					chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: null, rule: false,
+						chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
+					}}}},
+		{targetValue: timeout,
+			constraints: []constraint{{target: "timeout", name: null, rule: false,
+				chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
+		return nil, err
+	}
+	req, err := client.setPropertiesPreparer(storageServiceProperties, timeout, requestID)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setPropertiesResponder}, req)
+	if err != nil {
+		return nil, err
+	}
+	return resp.(*ServiceSetPropertiesResponse), err
+}
+
+// setPropertiesPreparer prepares the SetProperties request.
+func (client serviceClient) setPropertiesPreparer(storageServiceProperties StorageServiceProperties, timeout *int32, requestID *string) (pipeline.Request, error) {
+	req, err := pipeline.NewRequest("PUT", client.url, nil)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to create request")
+	}
+	params := req.URL.Query()
+	if timeout != nil {
+		params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
+	}
+	params.Set("restype", "service")
+	params.Set("comp", "properties")
+	req.URL.RawQuery = params.Encode()
+	req.Header.Set("x-ms-version", ServiceVersion)
+	if requestID != nil {
+		req.Header.Set("x-ms-client-request-id", *requestID)
+	}
+	b, err := xml.Marshal(storageServiceProperties)
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to marshal request body")
+	}
+	req.Header.Set("Content-Type", "application/xml")
+	err = req.SetBody(bytes.NewReader(b))
+	if err != nil {
+		return req, pipeline.NewError(err, "failed to set request body")
+	}
+	return req, nil
+}
+
+// setPropertiesResponder handles the response to the SetProperties request.
+func (client serviceClient) setPropertiesResponder(resp pipeline.Response) (pipeline.Response, error) {
+	err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
+	if resp == nil {
+		return nil, err
+	}
+	io.Copy(ioutil.Discard, resp.Response().Body)
+	resp.Response().Body.Close()
+	return &ServiceSetPropertiesResponse{rawResponse: resp.Response()}, err
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_validation.go

@@ -0,0 +1,367 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+import (
+	"fmt"
+	"github.com/Azure/azure-pipeline-go/pipeline"
+	"reflect"
+	"regexp"
+	"strings"
+)
+
+// Constraint stores constraint name, target field name
+// Rule and chain validations.
+type constraint struct {
+	// Target field name for validation.
+	target string
+
+	// Constraint name e.g. minLength, MaxLength, Pattern, etc.
+	name string
+
+	// Rule for constraint e.g. greater than 10, less than 5 etc.
+	rule interface{}
+
+	// Chain validations for struct type
+	chain []constraint
+}
+
+// Validation stores parameter-wise validation.
+type validation struct {
+	targetValue interface{}
+	constraints []constraint
+}
+
+// Constraint list
+const (
+	empty            = "Empty"
+	null             = "Null"
+	readOnly         = "ReadOnly"
+	pattern          = "Pattern"
+	maxLength        = "MaxLength"
+	minLength        = "MinLength"
+	maxItems         = "MaxItems"
+	minItems         = "MinItems"
+	multipleOf       = "MultipleOf"
+	uniqueItems      = "UniqueItems"
+	inclusiveMaximum = "InclusiveMaximum"
+	exclusiveMaximum = "ExclusiveMaximum"
+	exclusiveMinimum = "ExclusiveMinimum"
+	inclusiveMinimum = "InclusiveMinimum"
+)
+
+// Validate method validates constraints on parameter
+// passed in validation array.
+func validate(m []validation) error {
+	for _, item := range m {
+		v := reflect.ValueOf(item.targetValue)
+		for _, constraint := range item.constraints {
+			var err error
+			switch v.Kind() {
+			case reflect.Ptr:
+				err = validatePtr(v, constraint)
+			case reflect.String:
+				err = validateString(v, constraint)
+			case reflect.Struct:
+				err = validateStruct(v, constraint)
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				err = validateInt(v, constraint)
+			case reflect.Float32, reflect.Float64:
+				err = validateFloat(v, constraint)
+			case reflect.Array, reflect.Slice, reflect.Map:
+				err = validateArrayMap(v, constraint)
+			default:
+				err = createError(v, constraint, fmt.Sprintf("unknown type %v", v.Kind()))
+			}
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func validateStruct(x reflect.Value, v constraint, name ...string) error {
+	//Get field name from target name which is in format a.b.c
+	s := strings.Split(v.target, ".")
+	f := x.FieldByName(s[len(s)-1])
+	if isZero(f) {
+		return createError(x, v, fmt.Sprintf("field %q doesn't exist", v.target))
+	}
+	err := validate([]validation{
+		{
+			targetValue: getInterfaceValue(f),
+			constraints: []constraint{v},
+		},
+	})
+	return err
+}
+
+func validatePtr(x reflect.Value, v constraint) error {
+	if v.name == readOnly {
+		if !x.IsNil() {
+			return createError(x.Elem(), v, "readonly parameter; must send as nil or empty in request")
+		}
+		return nil
+	}
+	if x.IsNil() {
+		return checkNil(x, v)
+	}
+	if v.chain != nil {
+		return validate([]validation{
+			{
+				targetValue: getInterfaceValue(x.Elem()),
+				constraints: v.chain,
+			},
+		})
+	}
+	return nil
+}
+
+func validateInt(x reflect.Value, v constraint) error {
+	i := x.Int()
+	r, ok := v.rule.(int)
+	if !ok {
+		return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.name, v.rule))
+	}
+	switch v.name {
+	case multipleOf:
+		if i%int64(r) != 0 {
+			return createError(x, v, fmt.Sprintf("value must be a multiple of %v", r))
+		}
+	case exclusiveMinimum:
+		if i <= int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+		}
+	case exclusiveMaximum:
+		if i >= int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+		}
+	case inclusiveMinimum:
+		if i < int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+		}
+	case inclusiveMaximum:
+		if i > int64(r) {
+			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %v is not applicable for type integer", v.name))
+	}
+	return nil
+}
+
+func validateFloat(x reflect.Value, v constraint) error {
+	f := x.Float()
+	r, ok := v.rule.(float64)
+	if !ok {
+		return createError(x, v, fmt.Sprintf("rule must be float value for %v constraint; got: %v", v.name, v.rule))
+	}
+	switch v.name {
+	case exclusiveMinimum:
+		if f <= r {
+			return createError(x, v, fmt.Sprintf("value must be greater than %v", r))
+		}
+	case exclusiveMaximum:
+		if f >= r {
+			return createError(x, v, fmt.Sprintf("value must be less than %v", r))
+		}
+	case inclusiveMinimum:
+		if f < r {
+			return createError(x, v, fmt.Sprintf("value must be greater than or equal to %v", r))
+		}
+	case inclusiveMaximum:
+		if f > r {
+			return createError(x, v, fmt.Sprintf("value must be less than or equal to %v", r))
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %s is not applicable for type float", v.name))
+	}
+	return nil
+}
+
+func validateString(x reflect.Value, v constraint) error {
+	s := x.String()
+	switch v.name {
+	case empty:
+		if len(s) == 0 {
+			return checkEmpty(x, v)
+		}
+	case pattern:
+		reg, err := regexp.Compile(v.rule.(string))
+		if err != nil {
+			return createError(x, v, err.Error())
+		}
+		if !reg.MatchString(s) {
+			return createError(x, v, fmt.Sprintf("value doesn't match pattern %v", v.rule))
+		}
+	case maxLength:
+		if _, ok := v.rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.name, v.rule))
+		}
+		if len(s) > v.rule.(int) {
+			return createError(x, v, fmt.Sprintf("value length must be less than %v", v.rule))
+		}
+	case minLength:
+		if _, ok := v.rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer value for %v constraint; got: %v", v.name, v.rule))
+		}
+		if len(s) < v.rule.(int) {
+			return createError(x, v, fmt.Sprintf("value length must be greater than %v", v.rule))
+		}
+	case readOnly:
+		if len(s) > 0 {
+			return createError(reflect.ValueOf(s), v, "readonly parameter; must send as nil or empty in request")
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %s is not applicable to string type", v.name))
+	}
+	if v.chain != nil {
+		return validate([]validation{
+			{
+				targetValue: getInterfaceValue(x),
+				constraints: v.chain,
+			},
+		})
+	}
+	return nil
+}
+
+func validateArrayMap(x reflect.Value, v constraint) error {
+	switch v.name {
+	case null:
+		if x.IsNil() {
+			return checkNil(x, v)
+		}
+	case empty:
+		if x.IsNil() || x.Len() == 0 {
+			return checkEmpty(x, v)
+		}
+	case maxItems:
+		if _, ok := v.rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.name, v.rule))
+		}
+		if x.Len() > v.rule.(int) {
+			return createError(x, v, fmt.Sprintf("maximum item limit is %v; got: %v", v.rule, x.Len()))
+		}
+	case minItems:
+		if _, ok := v.rule.(int); !ok {
+			return createError(x, v, fmt.Sprintf("rule must be integer for %v constraint; got: %v", v.name, v.rule))
+		}
+		if x.Len() < v.rule.(int) {
+			return createError(x, v, fmt.Sprintf("minimum item limit is %v; got: %v", v.rule, x.Len()))
+		}
+	case uniqueItems:
+		if x.Kind() == reflect.Array || x.Kind() == reflect.Slice {
+			if !checkForUniqueInArray(x) {
+				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.target, x))
+			}
+		} else if x.Kind() == reflect.Map {
+			if !checkForUniqueInMap(x) {
+				return createError(x, v, fmt.Sprintf("all items in parameter %q must be unique; got:%v", v.target, x))
+			}
+		} else {
+			return createError(x, v, fmt.Sprintf("type must be array, slice or map for constraint %v; got: %v", v.name, x.Kind()))
+		}
+	case readOnly:
+		if x.Len() != 0 {
+			return createError(x, v, "readonly parameter; must send as nil or empty in request")
+		}
+	case pattern:
+		reg, err := regexp.Compile(v.rule.(string))
+		if err != nil {
+			return createError(x, v, err.Error())
+		}
+		keys := x.MapKeys()
+		for _, k := range keys {
+			if !reg.MatchString(k.String()) {
+				return createError(k, v, fmt.Sprintf("map key doesn't match pattern %v", v.rule))
+			}
+		}
+	default:
+		return createError(x, v, fmt.Sprintf("constraint %v is not applicable to array, slice and map type", v.name))
+	}
+	if v.chain != nil {
+		return validate([]validation{
+			{
+				targetValue: getInterfaceValue(x),
+				constraints: v.chain,
+			},
+		})
+	}
+	return nil
+}
+
+func checkNil(x reflect.Value, v constraint) error {
+	if _, ok := v.rule.(bool); !ok {
+		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.name, v.rule))
+	}
+	if v.rule.(bool) {
+		return createError(x, v, "value can not be null; required parameter")
+	}
+	return nil
+}
+
+func checkEmpty(x reflect.Value, v constraint) error {
+	if _, ok := v.rule.(bool); !ok {
+		return createError(x, v, fmt.Sprintf("rule must be bool value for %v constraint; got: %v", v.name, v.rule))
+	}
+	if v.rule.(bool) {
+		return createError(x, v, "value can not be null or empty; required parameter")
+	}
+	return nil
+}
+
+func checkForUniqueInArray(x reflect.Value) bool {
+	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+		return false
+	}
+	arrOfInterface := make([]interface{}, x.Len())
+	for i := 0; i < x.Len(); i++ {
+		arrOfInterface[i] = x.Index(i).Interface()
+	}
+	m := make(map[interface{}]bool)
+	for _, val := range arrOfInterface {
+		if m[val] {
+			return false
+		}
+		m[val] = true
+	}
+	return true
+}
+
+func checkForUniqueInMap(x reflect.Value) bool {
+	if x == reflect.Zero(reflect.TypeOf(x)) || x.Len() == 0 {
+		return false
+	}
+	mapOfInterface := make(map[interface{}]interface{}, x.Len())
+	keys := x.MapKeys()
+	for _, k := range keys {
+		mapOfInterface[k.Interface()] = x.MapIndex(k).Interface()
+	}
+	m := make(map[interface{}]bool)
+	for _, val := range mapOfInterface {
+		if m[val] {
+			return false
+		}
+		m[val] = true
+	}
+	return true
+}
+
+func getInterfaceValue(x reflect.Value) interface{} {
+	if x.Kind() == reflect.Invalid {
+		return nil
+	}
+	return x.Interface()
+}
+
+func isZero(x interface{}) bool {
+	return x == reflect.Zero(reflect.TypeOf(x)).Interface()
+}
+
+func createError(x reflect.Value, v constraint, message string) error {
+	return pipeline.NewError(nil, fmt.Sprintf("validation failed: parameter=%s constraint=%s value=%#v details: %s",
+		v.target, v.name, getInterfaceValue(x), message))
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_generated_version.go

@@ -0,0 +1,14 @@
+package azblob
+
+// Code generated by Microsoft (R) AutoRest Code Generator.
+// Changes may cause incorrect behavior and will be lost if the code is regenerated.
+
+// UserAgent returns the UserAgent string to use when sending http.Requests.
+func UserAgent() string {
+	return "Azure-SDK-For-Go/0.0.0 azblob/2018-03-28"
+}
+
+// Version returns the semantic version (see http://semver.org) of the client.
+func Version() string {
+	return "0.0.0"
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/2018-03-28/azblob/zz_response_helpers.go

@@ -0,0 +1,242 @@
+package azblob
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"time"
+)
+
+// BlobHTTPHeaders contains read/writeable blob properties.
+type BlobHTTPHeaders struct {
+	ContentType        string
+	ContentMD5         []byte
+	ContentEncoding    string
+	ContentLanguage    string
+	ContentDisposition string
+	CacheControl       string
+}
+
+// NewHTTPHeaders returns the user-modifiable properties for this blob.
+func (bgpr BlobGetPropertiesResponse) NewHTTPHeaders() BlobHTTPHeaders {
+	return BlobHTTPHeaders{
+		ContentType:        bgpr.ContentType(),
+		ContentEncoding:    bgpr.ContentEncoding(),
+		ContentLanguage:    bgpr.ContentLanguage(),
+		ContentDisposition: bgpr.ContentDisposition(),
+		CacheControl:       bgpr.CacheControl(),
+		ContentMD5:         bgpr.ContentMD5(),
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// NewHTTPHeaders returns the user-modifiable properties for this blob.
+func (dr downloadResponse) NewHTTPHeaders() BlobHTTPHeaders {
+	return BlobHTTPHeaders{
+		ContentType:        dr.ContentType(),
+		ContentEncoding:    dr.ContentEncoding(),
+		ContentLanguage:    dr.ContentLanguage(),
+		ContentDisposition: dr.ContentDisposition(),
+		CacheControl:       dr.CacheControl(),
+		ContentMD5:         dr.ContentMD5(),
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// DownloadResponse wraps AutoRest generated downloadResponse and helps to provide info for retry.
+type DownloadResponse struct {
+	r       *downloadResponse
+	ctx     context.Context
+	b       BlobURL
+	getInfo HTTPGetterInfo
+}
+
+// Body constructs new RetryReader stream for reading data. If a connection failes
+// while reading, it will make additional requests to reestablish a connection and
+// continue reading. Specifying a RetryReaderOption's with MaxRetryRequests set to 0
+// (the default), returns the original response body and no retries will be performed.
+func (r *DownloadResponse) Body(o RetryReaderOptions) io.ReadCloser {
+	if o.MaxRetryRequests == 0 { // No additional retries
+		return r.Response().Body
+	}
+	return NewRetryReader(r.ctx, r.Response(), r.getInfo, o,
+		func(ctx context.Context, getInfo HTTPGetterInfo) (*http.Response, error) {
+			resp, err := r.b.Download(ctx, getInfo.Offset, getInfo.Count,
+				BlobAccessConditions{
+					HTTPAccessConditions: HTTPAccessConditions{IfMatch: getInfo.ETag},
+				},
+				false)
+			if err != nil {
+				return nil, err
+			}
+			return resp.Response(), err
+		},
+	)
+}
+
+// Response returns the raw HTTP response object.
+func (r DownloadResponse) Response() *http.Response {
+	return r.r.Response()
+}
+
+// NewHTTPHeaders returns the user-modifiable properties for this blob.
+func (r DownloadResponse) NewHTTPHeaders() BlobHTTPHeaders {
+	return r.r.NewHTTPHeaders()
+}
+
+// BlobContentMD5 returns the value for header x-ms-blob-content-md5.
+func (r DownloadResponse) BlobContentMD5() []byte {
+	return r.r.BlobContentMD5()
+}
+
+// ContentMD5 returns the value for header Content-MD5.
+func (r DownloadResponse) ContentMD5() []byte {
+	return r.r.ContentMD5()
+}
+
+// StatusCode returns the HTTP status code of the response, e.g. 200.
+func (r DownloadResponse) StatusCode() int {
+	return r.r.StatusCode()
+}
+
+// Status returns the HTTP status message of the response, e.g. "200 OK".
+func (r DownloadResponse) Status() string {
+	return r.r.Status()
+}
+
+// AcceptRanges returns the value for header Accept-Ranges.
+func (r DownloadResponse) AcceptRanges() string {
+	return r.r.AcceptRanges()
+}
+
+// BlobCommittedBlockCount returns the value for header x-ms-blob-committed-block-count.
+func (r DownloadResponse) BlobCommittedBlockCount() int32 {
+	return r.r.BlobCommittedBlockCount()
+}
+
+// BlobSequenceNumber returns the value for header x-ms-blob-sequence-number.
+func (r DownloadResponse) BlobSequenceNumber() int64 {
+	return r.r.BlobSequenceNumber()
+}
+
+// BlobType returns the value for header x-ms-blob-type.
+func (r DownloadResponse) BlobType() BlobType {
+	return r.r.BlobType()
+}
+
+// CacheControl returns the value for header Cache-Control.
+func (r DownloadResponse) CacheControl() string {
+	return r.r.CacheControl()
+}
+
+// ContentDisposition returns the value for header Content-Disposition.
+func (r DownloadResponse) ContentDisposition() string {
+	return r.r.ContentDisposition()
+}
+
+// ContentEncoding returns the value for header Content-Encoding.
+func (r DownloadResponse) ContentEncoding() string {
+	return r.r.ContentEncoding()
+}
+
+// ContentLanguage returns the value for header Content-Language.
+func (r DownloadResponse) ContentLanguage() string {
+	return r.r.ContentLanguage()
+}
+
+// ContentLength returns the value for header Content-Length.
+func (r DownloadResponse) ContentLength() int64 {
+	return r.r.ContentLength()
+}
+
+// ContentRange returns the value for header Content-Range.
+func (r DownloadResponse) ContentRange() string {
+	return r.r.ContentRange()
+}
+
+// ContentType returns the value for header Content-Type.
+func (r DownloadResponse) ContentType() string {
+	return r.r.ContentType()
+}
+
+// CopyCompletionTime returns the value for header x-ms-copy-completion-time.
+func (r DownloadResponse) CopyCompletionTime() time.Time {
+	return r.r.CopyCompletionTime()
+}
+
+// CopyID returns the value for header x-ms-copy-id.
+func (r DownloadResponse) CopyID() string {
+	return r.r.CopyID()
+}
+
+// CopyProgress returns the value for header x-ms-copy-progress.
+func (r DownloadResponse) CopyProgress() string {
+	return r.r.CopyProgress()
+}
+
+// CopySource returns the value for header x-ms-copy-source.
+func (r DownloadResponse) CopySource() string {
+	return r.r.CopySource()
+}
+
+// CopyStatus returns the value for header x-ms-copy-status.
+func (r DownloadResponse) CopyStatus() CopyStatusType {
+	return r.r.CopyStatus()
+}
+
+// CopyStatusDescription returns the value for header x-ms-copy-status-description.
+func (r DownloadResponse) CopyStatusDescription() string {
+	return r.r.CopyStatusDescription()
+}
+
+// Date returns the value for header Date.
+func (r DownloadResponse) Date() time.Time {
+	return r.r.Date()
+}
+
+// ETag returns the value for header ETag.
+func (r DownloadResponse) ETag() ETag {
+	return r.r.ETag()
+}
+
+// IsServerEncrypted returns the value for header x-ms-server-encrypted.
+func (r DownloadResponse) IsServerEncrypted() string {
+	return r.r.IsServerEncrypted()
+}
+
+// LastModified returns the value for header Last-Modified.
+func (r DownloadResponse) LastModified() time.Time {
+	return r.r.LastModified()
+}
+
+// LeaseDuration returns the value for header x-ms-lease-duration.
+func (r DownloadResponse) LeaseDuration() LeaseDurationType {
+	return r.r.LeaseDuration()
+}
+
+// LeaseState returns the value for header x-ms-lease-state.
+func (r DownloadResponse) LeaseState() LeaseStateType {
+	return r.r.LeaseState()
+}
+
+// LeaseStatus returns the value for header x-ms-lease-status.
+func (r DownloadResponse) LeaseStatus() LeaseStatusType {
+	return r.r.LeaseStatus()
+}
+
+// RequestID returns the value for header x-ms-request-id.
+func (r DownloadResponse) RequestID() string {
+	return r.r.RequestID()
+}
+
+// Version returns the value for header x-ms-version.
+func (r DownloadResponse) Version() string {
+	return r.r.Version()
+}
+
+// NewMetadata returns user-defined key/value pairs.
+func (r DownloadResponse) NewMetadata() Metadata {
+	return r.r.NewMetadata()
+}

.rclone_repo/vendor/github.com/Azure/azure-storage-blob-go/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

.rclone_repo/vendor/github.com/Azure/go-ansiterm/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

.rclone_repo/vendor/github.com/Azure/go-ansiterm/README.md

@@ -0,0 +1,12 @@
+# go-ansiterm
+
+This is a cross platform Ansi Terminal Emulation library.  It reads a stream of Ansi characters and produces the appropriate function calls.  The results of the function calls are platform dependent.
+
+For example the parser might receive "ESC, [, A" as a stream of three characters.  This is the code for Cursor Up (http://www.vt100.net/docs/vt510-rm/CUU).  The parser then calls the cursor up function (CUU()) on an event handler.  The event handler determines what platform specific work must be done to cause the cursor to move up one position.
+
+The parser (parser.go) is a partial implementation of this state machine (http://vt100.net/emu/vt500_parser.png).  There are also two event handler implementations, one for tests (test_event_handler.go) to validate that the expected events are being produced and called, the other is a Windows implementation (winterm/win_event_handler.go).
+
+See parser_test.go for examples exercising the state machine and generating appropriate function calls.
+
+-----
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

.rclone_repo/vendor/github.com/Azure/go-ansiterm/constants.go

@@ -0,0 +1,188 @@
+package ansiterm
+
+const LogEnv = "DEBUG_TERMINAL"
+
+// ANSI constants
+// References:
+// -- http://www.ecma-international.org/publications/standards/Ecma-048.htm
+// -- http://man7.org/linux/man-pages/man4/console_codes.4.html
+// -- http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html
+// -- http://en.wikipedia.org/wiki/ANSI_escape_code
+// -- http://vt100.net/emu/dec_ansi_parser
+// -- http://vt100.net/emu/vt500_parser.svg
+// -- http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+// -- http://www.inwap.com/pdp10/ansicode.txt
+const (
+	// ECMA-48 Set Graphics Rendition
+	// Note:
+	// -- Constants leading with an underscore (e.g., _ANSI_xxx) are unsupported or reserved
+	// -- Fonts could possibly be supported via SetCurrentConsoleFontEx
+	// -- Windows does not expose the per-window cursor (i.e., caret) blink times
+	ANSI_SGR_RESET              = 0
+	ANSI_SGR_BOLD               = 1
+	ANSI_SGR_DIM                = 2
+	_ANSI_SGR_ITALIC            = 3
+	ANSI_SGR_UNDERLINE          = 4
+	_ANSI_SGR_BLINKSLOW         = 5
+	_ANSI_SGR_BLINKFAST         = 6
+	ANSI_SGR_REVERSE            = 7
+	_ANSI_SGR_INVISIBLE         = 8
+	_ANSI_SGR_LINETHROUGH       = 9
+	_ANSI_SGR_FONT_00           = 10
+	_ANSI_SGR_FONT_01           = 11
+	_ANSI_SGR_FONT_02           = 12
+	_ANSI_SGR_FONT_03           = 13
+	_ANSI_SGR_FONT_04           = 14
+	_ANSI_SGR_FONT_05           = 15
+	_ANSI_SGR_FONT_06           = 16
+	_ANSI_SGR_FONT_07           = 17
+	_ANSI_SGR_FONT_08           = 18
+	_ANSI_SGR_FONT_09           = 19
+	_ANSI_SGR_FONT_10           = 20
+	_ANSI_SGR_DOUBLEUNDERLINE   = 21
+	ANSI_SGR_BOLD_DIM_OFF       = 22
+	_ANSI_SGR_ITALIC_OFF        = 23
+	ANSI_SGR_UNDERLINE_OFF      = 24
+	_ANSI_SGR_BLINK_OFF         = 25
+	_ANSI_SGR_RESERVED_00       = 26
+	ANSI_SGR_REVERSE_OFF        = 27
+	_ANSI_SGR_INVISIBLE_OFF     = 28
+	_ANSI_SGR_LINETHROUGH_OFF   = 29
+	ANSI_SGR_FOREGROUND_BLACK   = 30
+	ANSI_SGR_FOREGROUND_RED     = 31
+	ANSI_SGR_FOREGROUND_GREEN   = 32
+	ANSI_SGR_FOREGROUND_YELLOW  = 33
+	ANSI_SGR_FOREGROUND_BLUE    = 34
+	ANSI_SGR_FOREGROUND_MAGENTA = 35
+	ANSI_SGR_FOREGROUND_CYAN    = 36
+	ANSI_SGR_FOREGROUND_WHITE   = 37
+	_ANSI_SGR_RESERVED_01       = 38
+	ANSI_SGR_FOREGROUND_DEFAULT = 39
+	ANSI_SGR_BACKGROUND_BLACK   = 40
+	ANSI_SGR_BACKGROUND_RED     = 41
+	ANSI_SGR_BACKGROUND_GREEN   = 42
+	ANSI_SGR_BACKGROUND_YELLOW  = 43
+	ANSI_SGR_BACKGROUND_BLUE    = 44
+	ANSI_SGR_BACKGROUND_MAGENTA = 45
+	ANSI_SGR_BACKGROUND_CYAN    = 46
+	ANSI_SGR_BACKGROUND_WHITE   = 47
+	_ANSI_SGR_RESERVED_02       = 48
+	ANSI_SGR_BACKGROUND_DEFAULT = 49
+	// 50 - 65: Unsupported
+
+	ANSI_MAX_CMD_LENGTH = 4096
+
+	MAX_INPUT_EVENTS = 128
+	DEFAULT_WIDTH    = 80
+	DEFAULT_HEIGHT   = 24
+
+	ANSI_BEL              = 0x07
+	ANSI_BACKSPACE        = 0x08
+	ANSI_TAB              = 0x09
+	ANSI_LINE_FEED        = 0x0A
+	ANSI_VERTICAL_TAB     = 0x0B
+	ANSI_FORM_FEED        = 0x0C
+	ANSI_CARRIAGE_RETURN  = 0x0D
+	ANSI_ESCAPE_PRIMARY   = 0x1B
+	ANSI_ESCAPE_SECONDARY = 0x5B
+	ANSI_OSC_STRING_ENTRY = 0x5D
+	ANSI_COMMAND_FIRST    = 0x40
+	ANSI_COMMAND_LAST     = 0x7E
+	DCS_ENTRY             = 0x90
+	CSI_ENTRY             = 0x9B
+	OSC_STRING            = 0x9D
+	ANSI_PARAMETER_SEP    = ";"
+	ANSI_CMD_G0           = '('
+	ANSI_CMD_G1           = ')'
+	ANSI_CMD_G2           = '*'
+	ANSI_CMD_G3           = '+'
+	ANSI_CMD_DECPNM       = '>'
+	ANSI_CMD_DECPAM       = '='
+	ANSI_CMD_OSC          = ']'
+	ANSI_CMD_STR_TERM     = '\\'
+
+	KEY_CONTROL_PARAM_2 = ";2"
+	KEY_CONTROL_PARAM_3 = ";3"
+	KEY_CONTROL_PARAM_4 = ";4"
+	KEY_CONTROL_PARAM_5 = ";5"
+	KEY_CONTROL_PARAM_6 = ";6"
+	KEY_CONTROL_PARAM_7 = ";7"
+	KEY_CONTROL_PARAM_8 = ";8"
+	KEY_ESC_CSI         = "\x1B["
+	KEY_ESC_N           = "\x1BN"
+	KEY_ESC_O           = "\x1BO"
+
+	FILL_CHARACTER = ' '
+)
+
+func getByteRange(start byte, end byte) []byte {
+	bytes := make([]byte, 0, 32)
+	for i := start; i <= end; i++ {
+		bytes = append(bytes, byte(i))
+	}
+
+	return bytes
+}
+
+var toGroundBytes = getToGroundBytes()
+var executors = getExecuteBytes()
+
+// SPACE		  20+A0 hex  Always and everywhere a blank space
+// Intermediate	  20-2F hex   !"#$%&'()*+,-./
+var intermeds = getByteRange(0x20, 0x2F)
+
+// Parameters	  30-3F hex  0123456789:;<=>?
+// CSI Parameters 30-39, 3B hex 0123456789;
+var csiParams = getByteRange(0x30, 0x3F)
+
+var csiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...)
+
+// Uppercase	  40-5F hex  @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
+var upperCase = getByteRange(0x40, 0x5F)
+
+// Lowercase	  60-7E hex  `abcdefghijlkmnopqrstuvwxyz{|}~
+var lowerCase = getByteRange(0x60, 0x7E)
+
+// Alphabetics	  40-7E hex  (all of upper and lower case)
+var alphabetics = append(upperCase, lowerCase...)
+
+var printables = getByteRange(0x20, 0x7F)
+
+var escapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E)
+var escapeToGroundBytes = getEscapeToGroundBytes()
+
+// See http://www.vt100.net/emu/vt500_parser.png for description of the complex
+// byte ranges below
+
+func getEscapeToGroundBytes() []byte {
+	escapeToGroundBytes := getByteRange(0x30, 0x4F)
+	escapeToGroundBytes = append(escapeToGroundBytes, getByteRange(0x51, 0x57)...)
+	escapeToGroundBytes = append(escapeToGroundBytes, 0x59)
+	escapeToGroundBytes = append(escapeToGroundBytes, 0x5A)
+	escapeToGroundBytes = append(escapeToGroundBytes, 0x5C)
+	escapeToGroundBytes = append(escapeToGroundBytes, getByteRange(0x60, 0x7E)...)
+	return escapeToGroundBytes
+}
+
+func getExecuteBytes() []byte {
+	executeBytes := getByteRange(0x00, 0x17)
+	executeBytes = append(executeBytes, 0x19)
+	executeBytes = append(executeBytes, getByteRange(0x1C, 0x1F)...)
+	return executeBytes
+}
+
+func getToGroundBytes() []byte {
+	groundBytes := []byte{0x18}
+	groundBytes = append(groundBytes, 0x1A)
+	groundBytes = append(groundBytes, getByteRange(0x80, 0x8F)...)
+	groundBytes = append(groundBytes, getByteRange(0x91, 0x97)...)
+	groundBytes = append(groundBytes, 0x99)
+	groundBytes = append(groundBytes, 0x9A)
+	groundBytes = append(groundBytes, 0x9C)
+	return groundBytes
+}
+
+// Delete		     7F hex  Always and everywhere ignored
+// C1 Control	  80-9F hex  32 additional control characters
+// G1 Displayable A1-FE hex  94 additional displayable characters
+// Special		  A0+FF hex  Same as SPACE and DELETE

.rclone_repo/vendor/github.com/Azure/go-ansiterm/context.go

@@ -0,0 +1,7 @@
+package ansiterm
+
+type ansiContext struct {
+	currentChar byte
+	paramBuffer []byte
+	interBuffer []byte
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/csi_entry_state.go

@@ -0,0 +1,49 @@
+package ansiterm
+
+type csiEntryState struct {
+	baseState
+}
+
+func (csiState csiEntryState) Handle(b byte) (s state, e error) {
+	csiState.parser.logf("CsiEntry::Handle %#x", b)
+
+	nextState, err := csiState.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case sliceContains(alphabetics, b):
+		return csiState.parser.ground, nil
+	case sliceContains(csiCollectables, b):
+		return csiState.parser.csiParam, nil
+	case sliceContains(executors, b):
+		return csiState, csiState.parser.execute()
+	}
+
+	return csiState, nil
+}
+
+func (csiState csiEntryState) Transition(s state) error {
+	csiState.parser.logf("CsiEntry::Transition %s --> %s", csiState.Name(), s.Name())
+	csiState.baseState.Transition(s)
+
+	switch s {
+	case csiState.parser.ground:
+		return csiState.parser.csiDispatch()
+	case csiState.parser.csiParam:
+		switch {
+		case sliceContains(csiParams, csiState.parser.context.currentChar):
+			csiState.parser.collectParam()
+		case sliceContains(intermeds, csiState.parser.context.currentChar):
+			csiState.parser.collectInter()
+		}
+	}
+
+	return nil
+}
+
+func (csiState csiEntryState) Enter() error {
+	csiState.parser.clear()
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/csi_param_state.go

@@ -0,0 +1,38 @@
+package ansiterm
+
+type csiParamState struct {
+	baseState
+}
+
+func (csiState csiParamState) Handle(b byte) (s state, e error) {
+	csiState.parser.logf("CsiParam::Handle %#x", b)
+
+	nextState, err := csiState.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case sliceContains(alphabetics, b):
+		return csiState.parser.ground, nil
+	case sliceContains(csiCollectables, b):
+		csiState.parser.collectParam()
+		return csiState, nil
+	case sliceContains(executors, b):
+		return csiState, csiState.parser.execute()
+	}
+
+	return csiState, nil
+}
+
+func (csiState csiParamState) Transition(s state) error {
+	csiState.parser.logf("CsiParam::Transition %s --> %s", csiState.Name(), s.Name())
+	csiState.baseState.Transition(s)
+
+	switch s {
+	case csiState.parser.ground:
+		return csiState.parser.csiDispatch()
+	}
+
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/escape_intermediate_state.go

@@ -0,0 +1,36 @@
+package ansiterm
+
+type escapeIntermediateState struct {
+	baseState
+}
+
+func (escState escapeIntermediateState) Handle(b byte) (s state, e error) {
+	escState.parser.logf("escapeIntermediateState::Handle %#x", b)
+	nextState, err := escState.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case sliceContains(intermeds, b):
+		return escState, escState.parser.collectInter()
+	case sliceContains(executors, b):
+		return escState, escState.parser.execute()
+	case sliceContains(escapeIntermediateToGroundBytes, b):
+		return escState.parser.ground, nil
+	}
+
+	return escState, nil
+}
+
+func (escState escapeIntermediateState) Transition(s state) error {
+	escState.parser.logf("escapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name())
+	escState.baseState.Transition(s)
+
+	switch s {
+	case escState.parser.ground:
+		return escState.parser.escDispatch()
+	}
+
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/escape_state.go

@@ -0,0 +1,47 @@
+package ansiterm
+
+type escapeState struct {
+	baseState
+}
+
+func (escState escapeState) Handle(b byte) (s state, e error) {
+	escState.parser.logf("escapeState::Handle %#x", b)
+	nextState, err := escState.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case b == ANSI_ESCAPE_SECONDARY:
+		return escState.parser.csiEntry, nil
+	case b == ANSI_OSC_STRING_ENTRY:
+		return escState.parser.oscString, nil
+	case sliceContains(executors, b):
+		return escState, escState.parser.execute()
+	case sliceContains(escapeToGroundBytes, b):
+		return escState.parser.ground, nil
+	case sliceContains(intermeds, b):
+		return escState.parser.escapeIntermediate, nil
+	}
+
+	return escState, nil
+}
+
+func (escState escapeState) Transition(s state) error {
+	escState.parser.logf("Escape::Transition %s --> %s", escState.Name(), s.Name())
+	escState.baseState.Transition(s)
+
+	switch s {
+	case escState.parser.ground:
+		return escState.parser.escDispatch()
+	case escState.parser.escapeIntermediate:
+		return escState.parser.collectInter()
+	}
+
+	return nil
+}
+
+func (escState escapeState) Enter() error {
+	escState.parser.clear()
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/event_handler.go

@@ -0,0 +1,90 @@
+package ansiterm
+
+type AnsiEventHandler interface {
+	// Print
+	Print(b byte) error
+
+	// Execute C0 commands
+	Execute(b byte) error
+
+	// CUrsor Up
+	CUU(int) error
+
+	// CUrsor Down
+	CUD(int) error
+
+	// CUrsor Forward
+	CUF(int) error
+
+	// CUrsor Backward
+	CUB(int) error
+
+	// Cursor to Next Line
+	CNL(int) error
+
+	// Cursor to Previous Line
+	CPL(int) error
+
+	// Cursor Horizontal position Absolute
+	CHA(int) error
+
+	// Vertical line Position Absolute
+	VPA(int) error
+
+	// CUrsor Position
+	CUP(int, int) error
+
+	// Horizontal and Vertical Position (depends on PUM)
+	HVP(int, int) error
+
+	// Text Cursor Enable Mode
+	DECTCEM(bool) error
+
+	// Origin Mode
+	DECOM(bool) error
+
+	// 132 Column Mode
+	DECCOLM(bool) error
+
+	// Erase in Display
+	ED(int) error
+
+	// Erase in Line
+	EL(int) error
+
+	// Insert Line
+	IL(int) error
+
+	// Delete Line
+	DL(int) error
+
+	// Insert Character
+	ICH(int) error
+
+	// Delete Character
+	DCH(int) error
+
+	// Set Graphics Rendition
+	SGR([]int) error
+
+	// Pan Down
+	SU(int) error
+
+	// Pan Up
+	SD(int) error
+
+	// Device Attributes
+	DA([]string) error
+
+	// Set Top and Bottom Margins
+	DECSTBM(int, int) error
+
+	// Index
+	IND() error
+
+	// Reverse Index
+	RI() error
+
+	// Flush updates from previous commands
+	Flush() error
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/ground_state.go

@@ -0,0 +1,24 @@
+package ansiterm
+
+type groundState struct {
+	baseState
+}
+
+func (gs groundState) Handle(b byte) (s state, e error) {
+	gs.parser.context.currentChar = b
+
+	nextState, err := gs.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case sliceContains(printables, b):
+		return gs, gs.parser.print()
+
+	case sliceContains(executors, b):
+		return gs, gs.parser.execute()
+	}
+
+	return gs, nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/osc_string_state.go

@@ -0,0 +1,31 @@
+package ansiterm
+
+type oscStringState struct {
+	baseState
+}
+
+func (oscState oscStringState) Handle(b byte) (s state, e error) {
+	oscState.parser.logf("OscString::Handle %#x", b)
+	nextState, err := oscState.baseState.Handle(b)
+	if nextState != nil || err != nil {
+		return nextState, err
+	}
+
+	switch {
+	case isOscStringTerminator(b):
+		return oscState.parser.ground, nil
+	}
+
+	return oscState, nil
+}
+
+// See below for OSC string terminators for linux
+// http://man7.org/linux/man-pages/man4/console_codes.4.html
+func isOscStringTerminator(b byte) bool {
+
+	if b == ANSI_BEL || b == 0x5C {
+		return true
+	}
+
+	return false
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/parser.go

@@ -0,0 +1,151 @@
+package ansiterm
+
+import (
+	"errors"
+	"log"
+	"os"
+)
+
+type AnsiParser struct {
+	currState          state
+	eventHandler       AnsiEventHandler
+	context            *ansiContext
+	csiEntry           state
+	csiParam           state
+	dcsEntry           state
+	escape             state
+	escapeIntermediate state
+	error              state
+	ground             state
+	oscString          state
+	stateMap           []state
+
+	logf func(string, ...interface{})
+}
+
+type Option func(*AnsiParser)
+
+func WithLogf(f func(string, ...interface{})) Option {
+	return func(ap *AnsiParser) {
+		ap.logf = f
+	}
+}
+
+func CreateParser(initialState string, evtHandler AnsiEventHandler, opts ...Option) *AnsiParser {
+	ap := &AnsiParser{
+		eventHandler: evtHandler,
+		context:      &ansiContext{},
+	}
+	for _, o := range opts {
+		o(ap)
+	}
+
+	if isDebugEnv := os.Getenv(LogEnv); isDebugEnv == "1" {
+		logFile, _ := os.Create("ansiParser.log")
+		logger := log.New(logFile, "", log.LstdFlags)
+		if ap.logf != nil {
+			l := ap.logf
+			ap.logf = func(s string, v ...interface{}) {
+				l(s, v...)
+				logger.Printf(s, v...)
+			}
+		} else {
+			ap.logf = logger.Printf
+		}
+	}
+
+	if ap.logf == nil {
+		ap.logf = func(string, ...interface{}) {}
+	}
+
+	ap.csiEntry = csiEntryState{baseState{name: "CsiEntry", parser: ap}}
+	ap.csiParam = csiParamState{baseState{name: "CsiParam", parser: ap}}
+	ap.dcsEntry = dcsEntryState{baseState{name: "DcsEntry", parser: ap}}
+	ap.escape = escapeState{baseState{name: "Escape", parser: ap}}
+	ap.escapeIntermediate = escapeIntermediateState{baseState{name: "EscapeIntermediate", parser: ap}}
+	ap.error = errorState{baseState{name: "Error", parser: ap}}
+	ap.ground = groundState{baseState{name: "Ground", parser: ap}}
+	ap.oscString = oscStringState{baseState{name: "OscString", parser: ap}}
+
+	ap.stateMap = []state{
+		ap.csiEntry,
+		ap.csiParam,
+		ap.dcsEntry,
+		ap.escape,
+		ap.escapeIntermediate,
+		ap.error,
+		ap.ground,
+		ap.oscString,
+	}
+
+	ap.currState = getState(initialState, ap.stateMap)
+
+	ap.logf("CreateParser: parser %p", ap)
+	return ap
+}
+
+func getState(name string, states []state) state {
+	for _, el := range states {
+		if el.Name() == name {
+			return el
+		}
+	}
+
+	return nil
+}
+
+func (ap *AnsiParser) Parse(bytes []byte) (int, error) {
+	for i, b := range bytes {
+		if err := ap.handle(b); err != nil {
+			return i, err
+		}
+	}
+
+	return len(bytes), ap.eventHandler.Flush()
+}
+
+func (ap *AnsiParser) handle(b byte) error {
+	ap.context.currentChar = b
+	newState, err := ap.currState.Handle(b)
+	if err != nil {
+		return err
+	}
+
+	if newState == nil {
+		ap.logf("WARNING: newState is nil")
+		return errors.New("New state of 'nil' is invalid.")
+	}
+
+	if newState != ap.currState {
+		if err := ap.changeState(newState); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (ap *AnsiParser) changeState(newState state) error {
+	ap.logf("ChangeState %s --> %s", ap.currState.Name(), newState.Name())
+
+	// Exit old state
+	if err := ap.currState.Exit(); err != nil {
+		ap.logf("Exit state '%s' failed with : '%v'", ap.currState.Name(), err)
+		return err
+	}
+
+	// Perform transition action
+	if err := ap.currState.Transition(newState); err != nil {
+		ap.logf("Transition from '%s' to '%s' failed with: '%v'", ap.currState.Name(), newState.Name, err)
+		return err
+	}
+
+	// Enter new state
+	if err := newState.Enter(); err != nil {
+		ap.logf("Enter state '%s' failed with: '%v'", newState.Name(), err)
+		return err
+	}
+
+	ap.currState = newState
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/parser_action_helpers.go

@@ -0,0 +1,99 @@
+package ansiterm
+
+import (
+	"strconv"
+)
+
+func parseParams(bytes []byte) ([]string, error) {
+	paramBuff := make([]byte, 0, 0)
+	params := []string{}
+
+	for _, v := range bytes {
+		if v == ';' {
+			if len(paramBuff) > 0 {
+				// Completed parameter, append it to the list
+				s := string(paramBuff)
+				params = append(params, s)
+				paramBuff = make([]byte, 0, 0)
+			}
+		} else {
+			paramBuff = append(paramBuff, v)
+		}
+	}
+
+	// Last parameter may not be terminated with ';'
+	if len(paramBuff) > 0 {
+		s := string(paramBuff)
+		params = append(params, s)
+	}
+
+	return params, nil
+}
+
+func parseCmd(context ansiContext) (string, error) {
+	return string(context.currentChar), nil
+}
+
+func getInt(params []string, dflt int) int {
+	i := getInts(params, 1, dflt)[0]
+	return i
+}
+
+func getInts(params []string, minCount int, dflt int) []int {
+	ints := []int{}
+
+	for _, v := range params {
+		i, _ := strconv.Atoi(v)
+		// Zero is mapped to the default value in VT100.
+		if i == 0 {
+			i = dflt
+		}
+		ints = append(ints, i)
+	}
+
+	if len(ints) < minCount {
+		remaining := minCount - len(ints)
+		for i := 0; i < remaining; i++ {
+			ints = append(ints, dflt)
+		}
+	}
+
+	return ints
+}
+
+func (ap *AnsiParser) modeDispatch(param string, set bool) error {
+	switch param {
+	case "?3":
+		return ap.eventHandler.DECCOLM(set)
+	case "?6":
+		return ap.eventHandler.DECOM(set)
+	case "?25":
+		return ap.eventHandler.DECTCEM(set)
+	}
+	return nil
+}
+
+func (ap *AnsiParser) hDispatch(params []string) error {
+	if len(params) == 1 {
+		return ap.modeDispatch(params[0], true)
+	}
+
+	return nil
+}
+
+func (ap *AnsiParser) lDispatch(params []string) error {
+	if len(params) == 1 {
+		return ap.modeDispatch(params[0], false)
+	}
+
+	return nil
+}
+
+func getEraseParam(params []string) int {
+	param := getInt(params, 0)
+	if param < 0 || 3 < param {
+		param = 0
+	}
+
+	return param
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/parser_actions.go

@@ -0,0 +1,119 @@
+package ansiterm
+
+func (ap *AnsiParser) collectParam() error {
+	currChar := ap.context.currentChar
+	ap.logf("collectParam %#x", currChar)
+	ap.context.paramBuffer = append(ap.context.paramBuffer, currChar)
+	return nil
+}
+
+func (ap *AnsiParser) collectInter() error {
+	currChar := ap.context.currentChar
+	ap.logf("collectInter %#x", currChar)
+	ap.context.paramBuffer = append(ap.context.interBuffer, currChar)
+	return nil
+}
+
+func (ap *AnsiParser) escDispatch() error {
+	cmd, _ := parseCmd(*ap.context)
+	intermeds := ap.context.interBuffer
+	ap.logf("escDispatch currentChar: %#x", ap.context.currentChar)
+	ap.logf("escDispatch: %v(%v)", cmd, intermeds)
+
+	switch cmd {
+	case "D": // IND
+		return ap.eventHandler.IND()
+	case "E": // NEL, equivalent to CRLF
+		err := ap.eventHandler.Execute(ANSI_CARRIAGE_RETURN)
+		if err == nil {
+			err = ap.eventHandler.Execute(ANSI_LINE_FEED)
+		}
+		return err
+	case "M": // RI
+		return ap.eventHandler.RI()
+	}
+
+	return nil
+}
+
+func (ap *AnsiParser) csiDispatch() error {
+	cmd, _ := parseCmd(*ap.context)
+	params, _ := parseParams(ap.context.paramBuffer)
+	ap.logf("Parsed params: %v with length: %d", params, len(params))
+
+	ap.logf("csiDispatch: %v(%v)", cmd, params)
+
+	switch cmd {
+	case "@":
+		return ap.eventHandler.ICH(getInt(params, 1))
+	case "A":
+		return ap.eventHandler.CUU(getInt(params, 1))
+	case "B":
+		return ap.eventHandler.CUD(getInt(params, 1))
+	case "C":
+		return ap.eventHandler.CUF(getInt(params, 1))
+	case "D":
+		return ap.eventHandler.CUB(getInt(params, 1))
+	case "E":
+		return ap.eventHandler.CNL(getInt(params, 1))
+	case "F":
+		return ap.eventHandler.CPL(getInt(params, 1))
+	case "G":
+		return ap.eventHandler.CHA(getInt(params, 1))
+	case "H":
+		ints := getInts(params, 2, 1)
+		x, y := ints[0], ints[1]
+		return ap.eventHandler.CUP(x, y)
+	case "J":
+		param := getEraseParam(params)
+		return ap.eventHandler.ED(param)
+	case "K":
+		param := getEraseParam(params)
+		return ap.eventHandler.EL(param)
+	case "L":
+		return ap.eventHandler.IL(getInt(params, 1))
+	case "M":
+		return ap.eventHandler.DL(getInt(params, 1))
+	case "P":
+		return ap.eventHandler.DCH(getInt(params, 1))
+	case "S":
+		return ap.eventHandler.SU(getInt(params, 1))
+	case "T":
+		return ap.eventHandler.SD(getInt(params, 1))
+	case "c":
+		return ap.eventHandler.DA(params)
+	case "d":
+		return ap.eventHandler.VPA(getInt(params, 1))
+	case "f":
+		ints := getInts(params, 2, 1)
+		x, y := ints[0], ints[1]
+		return ap.eventHandler.HVP(x, y)
+	case "h":
+		return ap.hDispatch(params)
+	case "l":
+		return ap.lDispatch(params)
+	case "m":
+		return ap.eventHandler.SGR(getInts(params, 1, 0))
+	case "r":
+		ints := getInts(params, 2, 1)
+		top, bottom := ints[0], ints[1]
+		return ap.eventHandler.DECSTBM(top, bottom)
+	default:
+		ap.logf("ERROR: Unsupported CSI command: '%s', with full context:  %v", cmd, ap.context)
+		return nil
+	}
+
+}
+
+func (ap *AnsiParser) print() error {
+	return ap.eventHandler.Print(ap.context.currentChar)
+}
+
+func (ap *AnsiParser) clear() error {
+	ap.context = &ansiContext{}
+	return nil
+}
+
+func (ap *AnsiParser) execute() error {
+	return ap.eventHandler.Execute(ap.context.currentChar)
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/states.go

@@ -0,0 +1,71 @@
+package ansiterm
+
+type stateID int
+
+type state interface {
+	Enter() error
+	Exit() error
+	Handle(byte) (state, error)
+	Name() string
+	Transition(state) error
+}
+
+type baseState struct {
+	name   string
+	parser *AnsiParser
+}
+
+func (base baseState) Enter() error {
+	return nil
+}
+
+func (base baseState) Exit() error {
+	return nil
+}
+
+func (base baseState) Handle(b byte) (s state, e error) {
+
+	switch {
+	case b == CSI_ENTRY:
+		return base.parser.csiEntry, nil
+	case b == DCS_ENTRY:
+		return base.parser.dcsEntry, nil
+	case b == ANSI_ESCAPE_PRIMARY:
+		return base.parser.escape, nil
+	case b == OSC_STRING:
+		return base.parser.oscString, nil
+	case sliceContains(toGroundBytes, b):
+		return base.parser.ground, nil
+	}
+
+	return nil, nil
+}
+
+func (base baseState) Name() string {
+	return base.name
+}
+
+func (base baseState) Transition(s state) error {
+	if s == base.parser.ground {
+		execBytes := []byte{0x18}
+		execBytes = append(execBytes, 0x1A)
+		execBytes = append(execBytes, getByteRange(0x80, 0x8F)...)
+		execBytes = append(execBytes, getByteRange(0x91, 0x97)...)
+		execBytes = append(execBytes, 0x99)
+		execBytes = append(execBytes, 0x9A)
+
+		if sliceContains(execBytes, base.parser.context.currentChar) {
+			return base.parser.execute()
+		}
+	}
+
+	return nil
+}
+
+type dcsEntryState struct {
+	baseState
+}
+
+type errorState struct {
+	baseState
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/utilities.go

@@ -0,0 +1,21 @@
+package ansiterm
+
+import (
+	"strconv"
+)
+
+func sliceContains(bytes []byte, b byte) bool {
+	for _, v := range bytes {
+		if v == b {
+			return true
+		}
+	}
+
+	return false
+}
+
+func convertBytesToInteger(bytes []byte) int {
+	s := string(bytes)
+	i, _ := strconv.Atoi(s)
+	return i
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/ansi.go

@@ -0,0 +1,182 @@
+// +build windows
+
+package winterm
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/Azure/go-ansiterm"
+)
+
+// Windows keyboard constants
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx.
+const (
+	VK_PRIOR    = 0x21 // PAGE UP key
+	VK_NEXT     = 0x22 // PAGE DOWN key
+	VK_END      = 0x23 // END key
+	VK_HOME     = 0x24 // HOME key
+	VK_LEFT     = 0x25 // LEFT ARROW key
+	VK_UP       = 0x26 // UP ARROW key
+	VK_RIGHT    = 0x27 // RIGHT ARROW key
+	VK_DOWN     = 0x28 // DOWN ARROW key
+	VK_SELECT   = 0x29 // SELECT key
+	VK_PRINT    = 0x2A // PRINT key
+	VK_EXECUTE  = 0x2B // EXECUTE key
+	VK_SNAPSHOT = 0x2C // PRINT SCREEN key
+	VK_INSERT   = 0x2D // INS key
+	VK_DELETE   = 0x2E // DEL key
+	VK_HELP     = 0x2F // HELP key
+	VK_F1       = 0x70 // F1 key
+	VK_F2       = 0x71 // F2 key
+	VK_F3       = 0x72 // F3 key
+	VK_F4       = 0x73 // F4 key
+	VK_F5       = 0x74 // F5 key
+	VK_F6       = 0x75 // F6 key
+	VK_F7       = 0x76 // F7 key
+	VK_F8       = 0x77 // F8 key
+	VK_F9       = 0x78 // F9 key
+	VK_F10      = 0x79 // F10 key
+	VK_F11      = 0x7A // F11 key
+	VK_F12      = 0x7B // F12 key
+
+	RIGHT_ALT_PRESSED  = 0x0001
+	LEFT_ALT_PRESSED   = 0x0002
+	RIGHT_CTRL_PRESSED = 0x0004
+	LEFT_CTRL_PRESSED  = 0x0008
+	SHIFT_PRESSED      = 0x0010
+	NUMLOCK_ON         = 0x0020
+	SCROLLLOCK_ON      = 0x0040
+	CAPSLOCK_ON        = 0x0080
+	ENHANCED_KEY       = 0x0100
+)
+
+type ansiCommand struct {
+	CommandBytes []byte
+	Command      string
+	Parameters   []string
+	IsSpecial    bool
+}
+
+func newAnsiCommand(command []byte) *ansiCommand {
+
+	if isCharacterSelectionCmdChar(command[1]) {
+		// Is Character Set Selection commands
+		return &ansiCommand{
+			CommandBytes: command,
+			Command:      string(command),
+			IsSpecial:    true,
+		}
+	}
+
+	// last char is command character
+	lastCharIndex := len(command) - 1
+
+	ac := &ansiCommand{
+		CommandBytes: command,
+		Command:      string(command[lastCharIndex]),
+		IsSpecial:    false,
+	}
+
+	// more than a single escape
+	if lastCharIndex != 0 {
+		start := 1
+		// skip if double char escape sequence
+		if command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_ESCAPE_SECONDARY {
+			start++
+		}
+		// convert this to GetNextParam method
+		ac.Parameters = strings.Split(string(command[start:lastCharIndex]), ansiterm.ANSI_PARAMETER_SEP)
+	}
+
+	return ac
+}
+
+func (ac *ansiCommand) paramAsSHORT(index int, defaultValue int16) int16 {
+	if index < 0 || index >= len(ac.Parameters) {
+		return defaultValue
+	}
+
+	param, err := strconv.ParseInt(ac.Parameters[index], 10, 16)
+	if err != nil {
+		return defaultValue
+	}
+
+	return int16(param)
+}
+
+func (ac *ansiCommand) String() string {
+	return fmt.Sprintf("0x%v \"%v\" (\"%v\")",
+		bytesToHex(ac.CommandBytes),
+		ac.Command,
+		strings.Join(ac.Parameters, "\",\""))
+}
+
+// isAnsiCommandChar returns true if the passed byte falls within the range of ANSI commands.
+// See http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html.
+func isAnsiCommandChar(b byte) bool {
+	switch {
+	case ansiterm.ANSI_COMMAND_FIRST <= b && b <= ansiterm.ANSI_COMMAND_LAST && b != ansiterm.ANSI_ESCAPE_SECONDARY:
+		return true
+	case b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_OSC || b == ansiterm.ANSI_CMD_DECPAM || b == ansiterm.ANSI_CMD_DECPNM:
+		// non-CSI escape sequence terminator
+		return true
+	case b == ansiterm.ANSI_CMD_STR_TERM || b == ansiterm.ANSI_BEL:
+		// String escape sequence terminator
+		return true
+	}
+	return false
+}
+
+func isXtermOscSequence(command []byte, current byte) bool {
+	return (len(command) >= 2 && command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_CMD_OSC && current != ansiterm.ANSI_BEL)
+}
+
+func isCharacterSelectionCmdChar(b byte) bool {
+	return (b == ansiterm.ANSI_CMD_G0 || b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_G2 || b == ansiterm.ANSI_CMD_G3)
+}
+
+// bytesToHex converts a slice of bytes to a human-readable string.
+func bytesToHex(b []byte) string {
+	hex := make([]string, len(b))
+	for i, ch := range b {
+		hex[i] = fmt.Sprintf("%X", ch)
+	}
+	return strings.Join(hex, "")
+}
+
+// ensureInRange adjusts the passed value, if necessary, to ensure it is within
+// the passed min / max range.
+func ensureInRange(n int16, min int16, max int16) int16 {
+	if n < min {
+		return min
+	} else if n > max {
+		return max
+	} else {
+		return n
+	}
+}
+
+func GetStdFile(nFile int) (*os.File, uintptr) {
+	var file *os.File
+	switch nFile {
+	case syscall.STD_INPUT_HANDLE:
+		file = os.Stdin
+	case syscall.STD_OUTPUT_HANDLE:
+		file = os.Stdout
+	case syscall.STD_ERROR_HANDLE:
+		file = os.Stderr
+	default:
+		panic(fmt.Errorf("Invalid standard handle identifier: %v", nFile))
+	}
+
+	fd, err := syscall.GetStdHandle(nFile)
+	if err != nil {
+		panic(fmt.Errorf("Invalid standard handle identifier: %v -- %v", nFile, err))
+	}
+
+	return file, uintptr(fd)
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/api.go

@@ -0,0 +1,327 @@
+// +build windows
+
+package winterm
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+//===========================================================================================================
+// IMPORTANT NOTE:
+//
+//	The methods below make extensive use of the "unsafe" package to obtain the required pointers.
+//	Beginning in Go 1.3, the garbage collector may release local variables (e.g., incoming arguments, stack
+//	variables) the pointers reference *before* the API completes.
+//
+//  As a result, in those cases, the code must hint that the variables remain in active by invoking the
+//	dummy method "use" (see below). Newer versions of Go are planned to change the mechanism to no longer
+//	require unsafe pointers.
+//
+//	If you add or modify methods, ENSURE protection of local variables through the "use" builtin to inform
+//	the garbage collector the variables remain in use if:
+//
+//	-- The value is not a pointer (e.g., int32, struct)
+//	-- The value is not referenced by the method after passing the pointer to Windows
+//
+//	See http://golang.org/doc/go1.3.
+//===========================================================================================================
+
+var (
+	kernel32DLL = syscall.NewLazyDLL("kernel32.dll")
+
+	getConsoleCursorInfoProc       = kernel32DLL.NewProc("GetConsoleCursorInfo")
+	setConsoleCursorInfoProc       = kernel32DLL.NewProc("SetConsoleCursorInfo")
+	setConsoleCursorPositionProc   = kernel32DLL.NewProc("SetConsoleCursorPosition")
+	setConsoleModeProc             = kernel32DLL.NewProc("SetConsoleMode")
+	getConsoleScreenBufferInfoProc = kernel32DLL.NewProc("GetConsoleScreenBufferInfo")
+	setConsoleScreenBufferSizeProc = kernel32DLL.NewProc("SetConsoleScreenBufferSize")
+	scrollConsoleScreenBufferProc  = kernel32DLL.NewProc("ScrollConsoleScreenBufferA")
+	setConsoleTextAttributeProc    = kernel32DLL.NewProc("SetConsoleTextAttribute")
+	setConsoleWindowInfoProc       = kernel32DLL.NewProc("SetConsoleWindowInfo")
+	writeConsoleOutputProc         = kernel32DLL.NewProc("WriteConsoleOutputW")
+	readConsoleInputProc           = kernel32DLL.NewProc("ReadConsoleInputW")
+	waitForSingleObjectProc        = kernel32DLL.NewProc("WaitForSingleObject")
+)
+
+// Windows Console constants
+const (
+	// Console modes
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
+	ENABLE_PROCESSED_INPUT        = 0x0001
+	ENABLE_LINE_INPUT             = 0x0002
+	ENABLE_ECHO_INPUT             = 0x0004
+	ENABLE_WINDOW_INPUT           = 0x0008
+	ENABLE_MOUSE_INPUT            = 0x0010
+	ENABLE_INSERT_MODE            = 0x0020
+	ENABLE_QUICK_EDIT_MODE        = 0x0040
+	ENABLE_EXTENDED_FLAGS         = 0x0080
+	ENABLE_AUTO_POSITION          = 0x0100
+	ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+
+	ENABLE_PROCESSED_OUTPUT            = 0x0001
+	ENABLE_WRAP_AT_EOL_OUTPUT          = 0x0002
+	ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+	DISABLE_NEWLINE_AUTO_RETURN        = 0x0008
+	ENABLE_LVB_GRID_WORLDWIDE          = 0x0010
+
+	// Character attributes
+	// Note:
+	// -- The attributes are combined to produce various colors (e.g., Blue + Green will create Cyan).
+	//    Clearing all foreground or background colors results in black; setting all creates white.
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682088(v=vs.85).aspx#_win32_character_attributes.
+	FOREGROUND_BLUE      uint16 = 0x0001
+	FOREGROUND_GREEN     uint16 = 0x0002
+	FOREGROUND_RED       uint16 = 0x0004
+	FOREGROUND_INTENSITY uint16 = 0x0008
+	FOREGROUND_MASK      uint16 = 0x000F
+
+	BACKGROUND_BLUE      uint16 = 0x0010
+	BACKGROUND_GREEN     uint16 = 0x0020
+	BACKGROUND_RED       uint16 = 0x0040
+	BACKGROUND_INTENSITY uint16 = 0x0080
+	BACKGROUND_MASK      uint16 = 0x00F0
+
+	COMMON_LVB_MASK          uint16 = 0xFF00
+	COMMON_LVB_REVERSE_VIDEO uint16 = 0x4000
+	COMMON_LVB_UNDERSCORE    uint16 = 0x8000
+
+	// Input event types
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
+	KEY_EVENT                = 0x0001
+	MOUSE_EVENT              = 0x0002
+	WINDOW_BUFFER_SIZE_EVENT = 0x0004
+	MENU_EVENT               = 0x0008
+	FOCUS_EVENT              = 0x0010
+
+	// WaitForSingleObject return codes
+	WAIT_ABANDONED = 0x00000080
+	WAIT_FAILED    = 0xFFFFFFFF
+	WAIT_SIGNALED  = 0x0000000
+	WAIT_TIMEOUT   = 0x00000102
+
+	// WaitForSingleObject wait duration
+	WAIT_INFINITE       = 0xFFFFFFFF
+	WAIT_ONE_SECOND     = 1000
+	WAIT_HALF_SECOND    = 500
+	WAIT_QUARTER_SECOND = 250
+)
+
+// Windows API Console types
+// -- See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682101(v=vs.85).aspx for Console specific types (e.g., COORD)
+// -- See https://msdn.microsoft.com/en-us/library/aa296569(v=vs.60).aspx for comments on alignment
+type (
+	CHAR_INFO struct {
+		UnicodeChar uint16
+		Attributes  uint16
+	}
+
+	CONSOLE_CURSOR_INFO struct {
+		Size    uint32
+		Visible int32
+	}
+
+	CONSOLE_SCREEN_BUFFER_INFO struct {
+		Size              COORD
+		CursorPosition    COORD
+		Attributes        uint16
+		Window            SMALL_RECT
+		MaximumWindowSize COORD
+	}
+
+	COORD struct {
+		X int16
+		Y int16
+	}
+
+	SMALL_RECT struct {
+		Left   int16
+		Top    int16
+		Right  int16
+		Bottom int16
+	}
+
+	// INPUT_RECORD is a C/C++ union of which KEY_EVENT_RECORD is one case, it is also the largest
+	// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
+	INPUT_RECORD struct {
+		EventType uint16
+		KeyEvent  KEY_EVENT_RECORD
+	}
+
+	KEY_EVENT_RECORD struct {
+		KeyDown         int32
+		RepeatCount     uint16
+		VirtualKeyCode  uint16
+		VirtualScanCode uint16
+		UnicodeChar     uint16
+		ControlKeyState uint32
+	}
+
+	WINDOW_BUFFER_SIZE struct {
+		Size COORD
+	}
+)
+
+// boolToBOOL converts a Go bool into a Windows int32.
+func boolToBOOL(f bool) int32 {
+	if f {
+		return int32(1)
+	} else {
+		return int32(0)
+	}
+}
+
+// GetConsoleCursorInfo retrieves information about the size and visiblity of the console cursor.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683163(v=vs.85).aspx.
+func GetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
+	r1, r2, err := getConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
+	return checkError(r1, r2, err)
+}
+
+// SetConsoleCursorInfo sets the size and visiblity of the console cursor.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686019(v=vs.85).aspx.
+func SetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
+	r1, r2, err := setConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
+	return checkError(r1, r2, err)
+}
+
+// SetConsoleCursorPosition location of the console cursor.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686025(v=vs.85).aspx.
+func SetConsoleCursorPosition(handle uintptr, coord COORD) error {
+	r1, r2, err := setConsoleCursorPositionProc.Call(handle, coordToPointer(coord))
+	use(coord)
+	return checkError(r1, r2, err)
+}
+
+// GetConsoleMode gets the console mode for given file descriptor
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx.
+func GetConsoleMode(handle uintptr) (mode uint32, err error) {
+	err = syscall.GetConsoleMode(syscall.Handle(handle), &mode)
+	return mode, err
+}
+
+// SetConsoleMode sets the console mode for given file descriptor
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
+func SetConsoleMode(handle uintptr, mode uint32) error {
+	r1, r2, err := setConsoleModeProc.Call(handle, uintptr(mode), 0)
+	use(mode)
+	return checkError(r1, r2, err)
+}
+
+// GetConsoleScreenBufferInfo retrieves information about the specified console screen buffer.
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx.
+func GetConsoleScreenBufferInfo(handle uintptr) (*CONSOLE_SCREEN_BUFFER_INFO, error) {
+	info := CONSOLE_SCREEN_BUFFER_INFO{}
+	err := checkError(getConsoleScreenBufferInfoProc.Call(handle, uintptr(unsafe.Pointer(&info)), 0))
+	if err != nil {
+		return nil, err
+	}
+	return &info, nil
+}
+
+func ScrollConsoleScreenBuffer(handle uintptr, scrollRect SMALL_RECT, clipRect SMALL_RECT, destOrigin COORD, char CHAR_INFO) error {
+	r1, r2, err := scrollConsoleScreenBufferProc.Call(handle, uintptr(unsafe.Pointer(&scrollRect)), uintptr(unsafe.Pointer(&clipRect)), coordToPointer(destOrigin), uintptr(unsafe.Pointer(&char)))
+	use(scrollRect)
+	use(clipRect)
+	use(destOrigin)
+	use(char)
+	return checkError(r1, r2, err)
+}
+
+// SetConsoleScreenBufferSize sets the size of the console screen buffer.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686044(v=vs.85).aspx.
+func SetConsoleScreenBufferSize(handle uintptr, coord COORD) error {
+	r1, r2, err := setConsoleScreenBufferSizeProc.Call(handle, coordToPointer(coord))
+	use(coord)
+	return checkError(r1, r2, err)
+}
+
+// SetConsoleTextAttribute sets the attributes of characters written to the
+// console screen buffer by the WriteFile or WriteConsole function.
+// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686047(v=vs.85).aspx.
+func SetConsoleTextAttribute(handle uintptr, attribute uint16) error {
+	r1, r2, err := setConsoleTextAttributeProc.Call(handle, uintptr(attribute), 0)
+	use(attribute)
+	return checkError(r1, r2, err)
+}
+
+// SetConsoleWindowInfo sets the size and position of the console screen buffer's window.
+// Note that the size and location must be within and no larger than the backing console screen buffer.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686125(v=vs.85).aspx.
+func SetConsoleWindowInfo(handle uintptr, isAbsolute bool, rect SMALL_RECT) error {
+	r1, r2, err := setConsoleWindowInfoProc.Call(handle, uintptr(boolToBOOL(isAbsolute)), uintptr(unsafe.Pointer(&rect)))
+	use(isAbsolute)
+	use(rect)
+	return checkError(r1, r2, err)
+}
+
+// WriteConsoleOutput writes the CHAR_INFOs from the provided buffer to the active console buffer.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687404(v=vs.85).aspx.
+func WriteConsoleOutput(handle uintptr, buffer []CHAR_INFO, bufferSize COORD, bufferCoord COORD, writeRegion *SMALL_RECT) error {
+	r1, r2, err := writeConsoleOutputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), coordToPointer(bufferSize), coordToPointer(bufferCoord), uintptr(unsafe.Pointer(writeRegion)))
+	use(buffer)
+	use(bufferSize)
+	use(bufferCoord)
+	return checkError(r1, r2, err)
+}
+
+// ReadConsoleInput reads (and removes) data from the console input buffer.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684961(v=vs.85).aspx.
+func ReadConsoleInput(handle uintptr, buffer []INPUT_RECORD, count *uint32) error {
+	r1, r2, err := readConsoleInputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), uintptr(len(buffer)), uintptr(unsafe.Pointer(count)))
+	use(buffer)
+	return checkError(r1, r2, err)
+}
+
+// WaitForSingleObject waits for the passed handle to be signaled.
+// It returns true if the handle was signaled; false otherwise.
+// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx.
+func WaitForSingleObject(handle uintptr, msWait uint32) (bool, error) {
+	r1, _, err := waitForSingleObjectProc.Call(handle, uintptr(uint32(msWait)))
+	switch r1 {
+	case WAIT_ABANDONED, WAIT_TIMEOUT:
+		return false, nil
+	case WAIT_SIGNALED:
+		return true, nil
+	}
+	use(msWait)
+	return false, err
+}
+
+// String helpers
+func (info CONSOLE_SCREEN_BUFFER_INFO) String() string {
+	return fmt.Sprintf("Size(%v) Cursor(%v) Window(%v) Max(%v)", info.Size, info.CursorPosition, info.Window, info.MaximumWindowSize)
+}
+
+func (coord COORD) String() string {
+	return fmt.Sprintf("%v,%v", coord.X, coord.Y)
+}
+
+func (rect SMALL_RECT) String() string {
+	return fmt.Sprintf("(%v,%v),(%v,%v)", rect.Left, rect.Top, rect.Right, rect.Bottom)
+}
+
+// checkError evaluates the results of a Windows API call and returns the error if it failed.
+func checkError(r1, r2 uintptr, err error) error {
+	// Windows APIs return non-zero to indicate success
+	if r1 != 0 {
+		return nil
+	}
+
+	// Return the error if provided, otherwise default to EINVAL
+	if err != nil {
+		return err
+	}
+	return syscall.EINVAL
+}
+
+// coordToPointer converts a COORD into a uintptr (by fooling the type system).
+func coordToPointer(c COORD) uintptr {
+	// Note: This code assumes the two SHORTs are correctly laid out; the "cast" to uint32 is just to get a pointer to pass.
+	return uintptr(*((*uint32)(unsafe.Pointer(&c))))
+}
+
+// use is a no-op, but the compiler cannot see that it is.
+// Calling use(p) ensures that p is kept live until that point.
+func use(p interface{}) {}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/attr_translation.go

@@ -0,0 +1,100 @@
+// +build windows
+
+package winterm
+
+import "github.com/Azure/go-ansiterm"
+
+const (
+	FOREGROUND_COLOR_MASK = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
+	BACKGROUND_COLOR_MASK = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
+)
+
+// collectAnsiIntoWindowsAttributes modifies the passed Windows text mode flags to reflect the
+// request represented by the passed ANSI mode.
+func collectAnsiIntoWindowsAttributes(windowsMode uint16, inverted bool, baseMode uint16, ansiMode int16) (uint16, bool) {
+	switch ansiMode {
+
+	// Mode styles
+	case ansiterm.ANSI_SGR_BOLD:
+		windowsMode = windowsMode | FOREGROUND_INTENSITY
+
+	case ansiterm.ANSI_SGR_DIM, ansiterm.ANSI_SGR_BOLD_DIM_OFF:
+		windowsMode &^= FOREGROUND_INTENSITY
+
+	case ansiterm.ANSI_SGR_UNDERLINE:
+		windowsMode = windowsMode | COMMON_LVB_UNDERSCORE
+
+	case ansiterm.ANSI_SGR_REVERSE:
+		inverted = true
+
+	case ansiterm.ANSI_SGR_REVERSE_OFF:
+		inverted = false
+
+	case ansiterm.ANSI_SGR_UNDERLINE_OFF:
+		windowsMode &^= COMMON_LVB_UNDERSCORE
+
+		// Foreground colors
+	case ansiterm.ANSI_SGR_FOREGROUND_DEFAULT:
+		windowsMode = (windowsMode &^ FOREGROUND_MASK) | (baseMode & FOREGROUND_MASK)
+
+	case ansiterm.ANSI_SGR_FOREGROUND_BLACK:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK)
+
+	case ansiterm.ANSI_SGR_FOREGROUND_RED:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED
+
+	case ansiterm.ANSI_SGR_FOREGROUND_GREEN:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN
+
+	case ansiterm.ANSI_SGR_FOREGROUND_YELLOW:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN
+
+	case ansiterm.ANSI_SGR_FOREGROUND_BLUE:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_FOREGROUND_MAGENTA:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_FOREGROUND_CYAN:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN | FOREGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_FOREGROUND_WHITE:
+		windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
+
+		// Background colors
+	case ansiterm.ANSI_SGR_BACKGROUND_DEFAULT:
+		// Black with no intensity
+		windowsMode = (windowsMode &^ BACKGROUND_MASK) | (baseMode & BACKGROUND_MASK)
+
+	case ansiterm.ANSI_SGR_BACKGROUND_BLACK:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK)
+
+	case ansiterm.ANSI_SGR_BACKGROUND_RED:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED
+
+	case ansiterm.ANSI_SGR_BACKGROUND_GREEN:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN
+
+	case ansiterm.ANSI_SGR_BACKGROUND_YELLOW:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN
+
+	case ansiterm.ANSI_SGR_BACKGROUND_BLUE:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_BACKGROUND_MAGENTA:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_BACKGROUND_CYAN:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN | BACKGROUND_BLUE
+
+	case ansiterm.ANSI_SGR_BACKGROUND_WHITE:
+		windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
+	}
+
+	return windowsMode, inverted
+}
+
+// invertAttributes inverts the foreground and background colors of a Windows attributes value
+func invertAttributes(windowsMode uint16) uint16 {
+	return (COMMON_LVB_MASK & windowsMode) | ((FOREGROUND_MASK & windowsMode) << 4) | ((BACKGROUND_MASK & windowsMode) >> 4)
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/cursor_helpers.go

@@ -0,0 +1,101 @@
+// +build windows
+
+package winterm
+
+const (
+	horizontal = iota
+	vertical
+)
+
+func (h *windowsAnsiEventHandler) getCursorWindow(info *CONSOLE_SCREEN_BUFFER_INFO) SMALL_RECT {
+	if h.originMode {
+		sr := h.effectiveSr(info.Window)
+		return SMALL_RECT{
+			Top:    sr.top,
+			Bottom: sr.bottom,
+			Left:   0,
+			Right:  info.Size.X - 1,
+		}
+	} else {
+		return SMALL_RECT{
+			Top:    info.Window.Top,
+			Bottom: info.Window.Bottom,
+			Left:   0,
+			Right:  info.Size.X - 1,
+		}
+	}
+}
+
+// setCursorPosition sets the cursor to the specified position, bounded to the screen size
+func (h *windowsAnsiEventHandler) setCursorPosition(position COORD, window SMALL_RECT) error {
+	position.X = ensureInRange(position.X, window.Left, window.Right)
+	position.Y = ensureInRange(position.Y, window.Top, window.Bottom)
+	err := SetConsoleCursorPosition(h.fd, position)
+	if err != nil {
+		return err
+	}
+	h.logf("Cursor position set: (%d, %d)", position.X, position.Y)
+	return err
+}
+
+func (h *windowsAnsiEventHandler) moveCursorVertical(param int) error {
+	return h.moveCursor(vertical, param)
+}
+
+func (h *windowsAnsiEventHandler) moveCursorHorizontal(param int) error {
+	return h.moveCursor(horizontal, param)
+}
+
+func (h *windowsAnsiEventHandler) moveCursor(moveMode int, param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	position := info.CursorPosition
+	switch moveMode {
+	case horizontal:
+		position.X += int16(param)
+	case vertical:
+		position.Y += int16(param)
+	}
+
+	if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) moveCursorLine(param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	position := info.CursorPosition
+	position.X = 0
+	position.Y += int16(param)
+
+	if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) moveCursorColumn(param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	position := info.CursorPosition
+	position.X = int16(param) - 1
+
+	if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
+		return err
+	}
+
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/erase_helpers.go

@@ -0,0 +1,84 @@
+// +build windows
+
+package winterm
+
+import "github.com/Azure/go-ansiterm"
+
+func (h *windowsAnsiEventHandler) clearRange(attributes uint16, fromCoord COORD, toCoord COORD) error {
+	// Ignore an invalid (negative area) request
+	if toCoord.Y < fromCoord.Y {
+		return nil
+	}
+
+	var err error
+
+	var coordStart = COORD{}
+	var coordEnd = COORD{}
+
+	xCurrent, yCurrent := fromCoord.X, fromCoord.Y
+	xEnd, yEnd := toCoord.X, toCoord.Y
+
+	// Clear any partial initial line
+	if xCurrent > 0 {
+		coordStart.X, coordStart.Y = xCurrent, yCurrent
+		coordEnd.X, coordEnd.Y = xEnd, yCurrent
+
+		err = h.clearRect(attributes, coordStart, coordEnd)
+		if err != nil {
+			return err
+		}
+
+		xCurrent = 0
+		yCurrent += 1
+	}
+
+	// Clear intervening rectangular section
+	if yCurrent < yEnd {
+		coordStart.X, coordStart.Y = xCurrent, yCurrent
+		coordEnd.X, coordEnd.Y = xEnd, yEnd-1
+
+		err = h.clearRect(attributes, coordStart, coordEnd)
+		if err != nil {
+			return err
+		}
+
+		xCurrent = 0
+		yCurrent = yEnd
+	}
+
+	// Clear remaining partial ending line
+	coordStart.X, coordStart.Y = xCurrent, yCurrent
+	coordEnd.X, coordEnd.Y = xEnd, yEnd
+
+	err = h.clearRect(attributes, coordStart, coordEnd)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) clearRect(attributes uint16, fromCoord COORD, toCoord COORD) error {
+	region := SMALL_RECT{Top: fromCoord.Y, Left: fromCoord.X, Bottom: toCoord.Y, Right: toCoord.X}
+	width := toCoord.X - fromCoord.X + 1
+	height := toCoord.Y - fromCoord.Y + 1
+	size := uint32(width) * uint32(height)
+
+	if size <= 0 {
+		return nil
+	}
+
+	buffer := make([]CHAR_INFO, size)
+
+	char := CHAR_INFO{ansiterm.FILL_CHARACTER, attributes}
+	for i := 0; i < int(size); i++ {
+		buffer[i] = char
+	}
+
+	err := WriteConsoleOutput(h.fd, buffer, COORD{X: width, Y: height}, COORD{X: 0, Y: 0}, &region)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/scroll_helper.go

@@ -0,0 +1,118 @@
+// +build windows
+
+package winterm
+
+// effectiveSr gets the current effective scroll region in buffer coordinates
+func (h *windowsAnsiEventHandler) effectiveSr(window SMALL_RECT) scrollRegion {
+	top := addInRange(window.Top, h.sr.top, window.Top, window.Bottom)
+	bottom := addInRange(window.Top, h.sr.bottom, window.Top, window.Bottom)
+	if top >= bottom {
+		top = window.Top
+		bottom = window.Bottom
+	}
+	return scrollRegion{top: top, bottom: bottom}
+}
+
+func (h *windowsAnsiEventHandler) scrollUp(param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	sr := h.effectiveSr(info.Window)
+	return h.scroll(param, sr, info)
+}
+
+func (h *windowsAnsiEventHandler) scrollDown(param int) error {
+	return h.scrollUp(-param)
+}
+
+func (h *windowsAnsiEventHandler) deleteLines(param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	start := info.CursorPosition.Y
+	sr := h.effectiveSr(info.Window)
+	// Lines cannot be inserted or deleted outside the scrolling region.
+	if start >= sr.top && start <= sr.bottom {
+		sr.top = start
+		return h.scroll(param, sr, info)
+	} else {
+		return nil
+	}
+}
+
+func (h *windowsAnsiEventHandler) insertLines(param int) error {
+	return h.deleteLines(-param)
+}
+
+// scroll scrolls the provided scroll region by param lines. The scroll region is in buffer coordinates.
+func (h *windowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSOLE_SCREEN_BUFFER_INFO) error {
+	h.logf("scroll: scrollTop: %d, scrollBottom: %d", sr.top, sr.bottom)
+	h.logf("scroll: windowTop: %d, windowBottom: %d", info.Window.Top, info.Window.Bottom)
+
+	// Copy from and clip to the scroll region (full buffer width)
+	scrollRect := SMALL_RECT{
+		Top:    sr.top,
+		Bottom: sr.bottom,
+		Left:   0,
+		Right:  info.Size.X - 1,
+	}
+
+	// Origin to which area should be copied
+	destOrigin := COORD{
+		X: 0,
+		Y: sr.top - int16(param),
+	}
+
+	char := CHAR_INFO{
+		UnicodeChar: ' ',
+		Attributes:  h.attributes,
+	}
+
+	if err := ScrollConsoleScreenBuffer(h.fd, scrollRect, scrollRect, destOrigin, char); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) deleteCharacters(param int) error {
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+	return h.scrollLine(param, info.CursorPosition, info)
+}
+
+func (h *windowsAnsiEventHandler) insertCharacters(param int) error {
+	return h.deleteCharacters(-param)
+}
+
+// scrollLine scrolls a line horizontally starting at the provided position by a number of columns.
+func (h *windowsAnsiEventHandler) scrollLine(columns int, position COORD, info *CONSOLE_SCREEN_BUFFER_INFO) error {
+	// Copy from and clip to the scroll region (full buffer width)
+	scrollRect := SMALL_RECT{
+		Top:    position.Y,
+		Bottom: position.Y,
+		Left:   position.X,
+		Right:  info.Size.X - 1,
+	}
+
+	// Origin to which area should be copied
+	destOrigin := COORD{
+		X: position.X - int16(columns),
+		Y: position.Y,
+	}
+
+	char := CHAR_INFO{
+		UnicodeChar: ' ',
+		Attributes:  h.attributes,
+	}
+
+	if err := ScrollConsoleScreenBuffer(h.fd, scrollRect, scrollRect, destOrigin, char); err != nil {
+		return err
+	}
+	return nil
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/utilities.go

@@ -0,0 +1,9 @@
+// +build windows
+
+package winterm
+
+// AddInRange increments a value by the passed quantity while ensuring the values
+// always remain within the supplied min / max range.
+func addInRange(n int16, increment int16, min int16, max int16) int16 {
+	return ensureInRange(n+increment, min, max)
+}

.rclone_repo/vendor/github.com/Azure/go-ansiterm/winterm/win_event_handler.go

@@ -0,0 +1,743 @@
+// +build windows
+
+package winterm
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"strconv"
+
+	"github.com/Azure/go-ansiterm"
+)
+
+type windowsAnsiEventHandler struct {
+	fd             uintptr
+	file           *os.File
+	infoReset      *CONSOLE_SCREEN_BUFFER_INFO
+	sr             scrollRegion
+	buffer         bytes.Buffer
+	attributes     uint16
+	inverted       bool
+	wrapNext       bool
+	drewMarginByte bool
+	originMode     bool
+	marginByte     byte
+	curInfo        *CONSOLE_SCREEN_BUFFER_INFO
+	curPos         COORD
+	logf           func(string, ...interface{})
+}
+
+type Option func(*windowsAnsiEventHandler)
+
+func WithLogf(f func(string, ...interface{})) Option {
+	return func(w *windowsAnsiEventHandler) {
+		w.logf = f
+	}
+}
+
+func CreateWinEventHandler(fd uintptr, file *os.File, opts ...Option) ansiterm.AnsiEventHandler {
+	infoReset, err := GetConsoleScreenBufferInfo(fd)
+	if err != nil {
+		return nil
+	}
+
+	h := &windowsAnsiEventHandler{
+		fd:         fd,
+		file:       file,
+		infoReset:  infoReset,
+		attributes: infoReset.Attributes,
+	}
+	for _, o := range opts {
+		o(h)
+	}
+
+	if isDebugEnv := os.Getenv(ansiterm.LogEnv); isDebugEnv == "1" {
+		logFile, _ := os.Create("winEventHandler.log")
+		logger := log.New(logFile, "", log.LstdFlags)
+		if h.logf != nil {
+			l := h.logf
+			h.logf = func(s string, v ...interface{}) {
+				l(s, v...)
+				logger.Printf(s, v...)
+			}
+		} else {
+			h.logf = logger.Printf
+		}
+	}
+
+	if h.logf == nil {
+		h.logf = func(string, ...interface{}) {}
+	}
+
+	return h
+}
+
+type scrollRegion struct {
+	top    int16
+	bottom int16
+}
+
+// simulateLF simulates a LF or CR+LF by scrolling if necessary to handle the
+// current cursor position and scroll region settings, in which case it returns
+// true. If no special handling is necessary, then it does nothing and returns
+// false.
+//
+// In the false case, the caller should ensure that a carriage return
+// and line feed are inserted or that the text is otherwise wrapped.
+func (h *windowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) {
+	if h.wrapNext {
+		if err := h.Flush(); err != nil {
+			return false, err
+		}
+		h.clearWrap()
+	}
+	pos, info, err := h.getCurrentInfo()
+	if err != nil {
+		return false, err
+	}
+	sr := h.effectiveSr(info.Window)
+	if pos.Y == sr.bottom {
+		// Scrolling is necessary. Let Windows automatically scroll if the scrolling region
+		// is the full window.
+		if sr.top == info.Window.Top && sr.bottom == info.Window.Bottom {
+			if includeCR {
+				pos.X = 0
+				h.updatePos(pos)
+			}
+			return false, nil
+		}
+
+		// A custom scroll region is active. Scroll the window manually to simulate
+		// the LF.
+		if err := h.Flush(); err != nil {
+			return false, err
+		}
+		h.logf("Simulating LF inside scroll region")
+		if err := h.scrollUp(1); err != nil {
+			return false, err
+		}
+		if includeCR {
+			pos.X = 0
+			if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	} else if pos.Y < info.Window.Bottom {
+		// Let Windows handle the LF.
+		pos.Y++
+		if includeCR {
+			pos.X = 0
+		}
+		h.updatePos(pos)
+		return false, nil
+	} else {
+		// The cursor is at the bottom of the screen but outside the scroll
+		// region. Skip the LF.
+		h.logf("Simulating LF outside scroll region")
+		if includeCR {
+			if err := h.Flush(); err != nil {
+				return false, err
+			}
+			pos.X = 0
+			if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	}
+}
+
+// executeLF executes a LF without a CR.
+func (h *windowsAnsiEventHandler) executeLF() error {
+	handled, err := h.simulateLF(false)
+	if err != nil {
+		return err
+	}
+	if !handled {
+		// Windows LF will reset the cursor column position. Write the LF
+		// and restore the cursor position.
+		pos, _, err := h.getCurrentInfo()
+		if err != nil {
+			return err
+		}
+		h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED)
+		if pos.X != 0 {
+			if err := h.Flush(); err != nil {
+				return err
+			}
+			h.logf("Resetting cursor position for LF without CR")
+			if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) Print(b byte) error {
+	if h.wrapNext {
+		h.buffer.WriteByte(h.marginByte)
+		h.clearWrap()
+		if _, err := h.simulateLF(true); err != nil {
+			return err
+		}
+	}
+	pos, info, err := h.getCurrentInfo()
+	if err != nil {
+		return err
+	}
+	if pos.X == info.Size.X-1 {
+		h.wrapNext = true
+		h.marginByte = b
+	} else {
+		pos.X++
+		h.updatePos(pos)
+		h.buffer.WriteByte(b)
+	}
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) Execute(b byte) error {
+	switch b {
+	case ansiterm.ANSI_TAB:
+		h.logf("Execute(TAB)")
+		// Move to the next tab stop, but preserve auto-wrap if already set.
+		if !h.wrapNext {
+			pos, info, err := h.getCurrentInfo()
+			if err != nil {
+				return err
+			}
+			pos.X = (pos.X + 8) - pos.X%8
+			if pos.X >= info.Size.X {
+				pos.X = info.Size.X - 1
+			}
+			if err := h.Flush(); err != nil {
+				return err
+			}
+			if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
+				return err
+			}
+		}
+		return nil
+
+	case ansiterm.ANSI_BEL:
+		h.buffer.WriteByte(ansiterm.ANSI_BEL)
+		return nil
+
+	case ansiterm.ANSI_BACKSPACE:
+		if h.wrapNext {
+			if err := h.Flush(); err != nil {
+				return err
+			}
+			h.clearWrap()
+		}
+		pos, _, err := h.getCurrentInfo()
+		if err != nil {
+			return err
+		}
+		if pos.X > 0 {
+			pos.X--
+			h.updatePos(pos)
+			h.buffer.WriteByte(ansiterm.ANSI_BACKSPACE)
+		}
+		return nil
+
+	case ansiterm.ANSI_VERTICAL_TAB, ansiterm.ANSI_FORM_FEED:
+		// Treat as true LF.
+		return h.executeLF()
+
+	case ansiterm.ANSI_LINE_FEED:
+		// Simulate a CR and LF for now since there is no way in go-ansiterm
+		// to tell if the LF should include CR (and more things break when it's
+		// missing than when it's incorrectly added).
+		handled, err := h.simulateLF(true)
+		if handled || err != nil {
+			return err
+		}
+		return h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED)
+
+	case ansiterm.ANSI_CARRIAGE_RETURN:
+		if h.wrapNext {
+			if err := h.Flush(); err != nil {
+				return err
+			}
+			h.clearWrap()
+		}
+		pos, _, err := h.getCurrentInfo()
+		if err != nil {
+			return err
+		}
+		if pos.X != 0 {
+			pos.X = 0
+			h.updatePos(pos)
+			h.buffer.WriteByte(ansiterm.ANSI_CARRIAGE_RETURN)
+		}
+		return nil
+
+	default:
+		return nil
+	}
+}
+
+func (h *windowsAnsiEventHandler) CUU(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CUU: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorVertical(-param)
+}
+
+func (h *windowsAnsiEventHandler) CUD(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CUD: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorVertical(param)
+}
+
+func (h *windowsAnsiEventHandler) CUF(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CUF: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorHorizontal(param)
+}
+
+func (h *windowsAnsiEventHandler) CUB(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CUB: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorHorizontal(-param)
+}
+
+func (h *windowsAnsiEventHandler) CNL(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CNL: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorLine(param)
+}
+
+func (h *windowsAnsiEventHandler) CPL(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CPL: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorLine(-param)
+}
+
+func (h *windowsAnsiEventHandler) CHA(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CHA: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.moveCursorColumn(param)
+}
+
+func (h *windowsAnsiEventHandler) VPA(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("VPA: [[%d]]", param)
+	h.clearWrap()
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+	window := h.getCursorWindow(info)
+	position := info.CursorPosition
+	position.Y = window.Top + int16(param) - 1
+	return h.setCursorPosition(position, window)
+}
+
+func (h *windowsAnsiEventHandler) CUP(row int, col int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("CUP: [[%d %d]]", row, col)
+	h.clearWrap()
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	window := h.getCursorWindow(info)
+	position := COORD{window.Left + int16(col) - 1, window.Top + int16(row) - 1}
+	return h.setCursorPosition(position, window)
+}
+
+func (h *windowsAnsiEventHandler) HVP(row int, col int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("HVP: [[%d %d]]", row, col)
+	h.clearWrap()
+	return h.CUP(row, col)
+}
+
+func (h *windowsAnsiEventHandler) DECTCEM(visible bool) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DECTCEM: [%v]", []string{strconv.FormatBool(visible)})
+	h.clearWrap()
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) DECOM(enable bool) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DECOM: [%v]", []string{strconv.FormatBool(enable)})
+	h.clearWrap()
+	h.originMode = enable
+	return h.CUP(1, 1)
+}
+
+func (h *windowsAnsiEventHandler) DECCOLM(use132 bool) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DECCOLM: [%v]", []string{strconv.FormatBool(use132)})
+	h.clearWrap()
+	if err := h.ED(2); err != nil {
+		return err
+	}
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+	targetWidth := int16(80)
+	if use132 {
+		targetWidth = 132
+	}
+	if info.Size.X < targetWidth {
+		if err := SetConsoleScreenBufferSize(h.fd, COORD{targetWidth, info.Size.Y}); err != nil {
+			h.logf("set buffer failed: %v", err)
+			return err
+		}
+	}
+	window := info.Window
+	window.Left = 0
+	window.Right = targetWidth - 1
+	if err := SetConsoleWindowInfo(h.fd, true, window); err != nil {
+		h.logf("set window failed: %v", err)
+		return err
+	}
+	if info.Size.X > targetWidth {
+		if err := SetConsoleScreenBufferSize(h.fd, COORD{targetWidth, info.Size.Y}); err != nil {
+			h.logf("set buffer failed: %v", err)
+			return err
+		}
+	}
+	return SetConsoleCursorPosition(h.fd, COORD{0, 0})
+}
+
+func (h *windowsAnsiEventHandler) ED(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("ED: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+
+	// [J  -- Erases from the cursor to the end of the screen, including the cursor position.
+	// [1J -- Erases from the beginning of the screen to the cursor, including the cursor position.
+	// [2J -- Erases the complete display. The cursor does not move.
+	// Notes:
+	// -- Clearing the entire buffer, versus just the Window, works best for Windows Consoles
+
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	var start COORD
+	var end COORD
+
+	switch param {
+	case 0:
+		start = info.CursorPosition
+		end = COORD{info.Size.X - 1, info.Size.Y - 1}
+
+	case 1:
+		start = COORD{0, 0}
+		end = info.CursorPosition
+
+	case 2:
+		start = COORD{0, 0}
+		end = COORD{info.Size.X - 1, info.Size.Y - 1}
+	}
+
+	err = h.clearRange(h.attributes, start, end)
+	if err != nil {
+		return err
+	}
+
+	// If the whole buffer was cleared, move the window to the top while preserving
+	// the window-relative cursor position.
+	if param == 2 {
+		pos := info.CursorPosition
+		window := info.Window
+		pos.Y -= window.Top
+		window.Bottom -= window.Top
+		window.Top = 0
+		if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
+			return err
+		}
+		if err := SetConsoleWindowInfo(h.fd, true, window); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) EL(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("EL: [%v]", strconv.Itoa(param))
+	h.clearWrap()
+
+	// [K  -- Erases from the cursor to the end of the line, including the cursor position.
+	// [1K -- Erases from the beginning of the line to the cursor, including the cursor position.
+	// [2K -- Erases the complete line.
+
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	var start COORD
+	var end COORD
+
+	switch param {
+	case 0:
+		start = info.CursorPosition
+		end = COORD{info.Size.X, info.CursorPosition.Y}
+
+	case 1:
+		start = COORD{0, info.CursorPosition.Y}
+		end = info.CursorPosition
+
+	case 2:
+		start = COORD{0, info.CursorPosition.Y}
+		end = COORD{info.Size.X, info.CursorPosition.Y}
+	}
+
+	err = h.clearRange(h.attributes, start, end)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) IL(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("IL: [%v]", strconv.Itoa(param))
+	h.clearWrap()
+	return h.insertLines(param)
+}
+
+func (h *windowsAnsiEventHandler) DL(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DL: [%v]", strconv.Itoa(param))
+	h.clearWrap()
+	return h.deleteLines(param)
+}
+
+func (h *windowsAnsiEventHandler) ICH(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("ICH: [%v]", strconv.Itoa(param))
+	h.clearWrap()
+	return h.insertCharacters(param)
+}
+
+func (h *windowsAnsiEventHandler) DCH(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DCH: [%v]", strconv.Itoa(param))
+	h.clearWrap()
+	return h.deleteCharacters(param)
+}
+
+func (h *windowsAnsiEventHandler) SGR(params []int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	strings := []string{}
+	for _, v := range params {
+		strings = append(strings, strconv.Itoa(v))
+	}
+
+	h.logf("SGR: [%v]", strings)
+
+	if len(params) <= 0 {
+		h.attributes = h.infoReset.Attributes
+		h.inverted = false
+	} else {
+		for _, attr := range params {
+
+			if attr == ansiterm.ANSI_SGR_RESET {
+				h.attributes = h.infoReset.Attributes
+				h.inverted = false
+				continue
+			}
+
+			h.attributes, h.inverted = collectAnsiIntoWindowsAttributes(h.attributes, h.inverted, h.infoReset.Attributes, int16(attr))
+		}
+	}
+
+	attributes := h.attributes
+	if h.inverted {
+		attributes = invertAttributes(attributes)
+	}
+	err := SetConsoleTextAttribute(h.fd, attributes)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) SU(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("SU: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.scrollUp(param)
+}
+
+func (h *windowsAnsiEventHandler) SD(param int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("SD: [%v]", []string{strconv.Itoa(param)})
+	h.clearWrap()
+	return h.scrollDown(param)
+}
+
+func (h *windowsAnsiEventHandler) DA(params []string) error {
+	h.logf("DA: [%v]", params)
+	// DA cannot be implemented because it must send data on the VT100 input stream,
+	// which is not available to go-ansiterm.
+	return nil
+}
+
+func (h *windowsAnsiEventHandler) DECSTBM(top int, bottom int) error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("DECSTBM: [%d, %d]", top, bottom)
+
+	// Windows is 0 indexed, Linux is 1 indexed
+	h.sr.top = int16(top - 1)
+	h.sr.bottom = int16(bottom - 1)
+
+	// This command also moves the cursor to the origin.
+	h.clearWrap()
+	return h.CUP(1, 1)
+}
+
+func (h *windowsAnsiEventHandler) RI() error {
+	if err := h.Flush(); err != nil {
+		return err
+	}
+	h.logf("RI: []")
+	h.clearWrap()
+
+	info, err := GetConsoleScreenBufferInfo(h.fd)
+	if err != nil {
+		return err
+	}
+
+	sr := h.effectiveSr(info.Window)
+	if info.CursorPosition.Y == sr.top {
+		return h.scrollDown(1)
+	}
+
+	return h.moveCursorVertical(-1)
+}
+
+func (h *windowsAnsiEventHandler) IND() error {
+	h.logf("IND: []")
+	return h.executeLF()
+}
+
+func (h *windowsAnsiEventHandler) Flush() error {
+	h.curInfo = nil
+	if h.buffer.Len() > 0 {
+		h.logf("Flush: [%s]", h.buffer.Bytes())
+		if _, err := h.buffer.WriteTo(h.file); err != nil {
+			return err
+		}
+	}
+
+	if h.wrapNext && !h.drewMarginByte {
+		h.logf("Flush: drawing margin byte '%c'", h.marginByte)
+
+		info, err := GetConsoleScreenBufferInfo(h.fd)
+		if err != nil {
+			return err
+		}
+
+		charInfo := []CHAR_INFO{{UnicodeChar: uint16(h.marginByte), Attributes: info.Attributes}}
+		size := COORD{1, 1}
+		position := COORD{0, 0}
+		region := SMALL_RECT{Left: info.CursorPosition.X, Top: info.CursorPosition.Y, Right: info.CursorPosition.X, Bottom: info.CursorPosition.Y}
+		if err := WriteConsoleOutput(h.fd, charInfo, size, position, &region); err != nil {
+			return err
+		}
+		h.drewMarginByte = true
+	}
+	return nil
+}
+
+// cacheConsoleInfo ensures that the current console screen information has been queried
+// since the last call to Flush(). It must be called before accessing h.curInfo or h.curPos.
+func (h *windowsAnsiEventHandler) getCurrentInfo() (COORD, *CONSOLE_SCREEN_BUFFER_INFO, error) {
+	if h.curInfo == nil {
+		info, err := GetConsoleScreenBufferInfo(h.fd)
+		if err != nil {
+			return COORD{}, nil, err
+		}
+		h.curInfo = info
+		h.curPos = info.CursorPosition
+	}
+	return h.curPos, h.curInfo, nil
+}
+
+func (h *windowsAnsiEventHandler) updatePos(pos COORD) {
+	if h.curInfo == nil {
+		panic("failed to call getCurrentInfo before calling updatePos")
+	}
+	h.curPos = pos
+}
+
+// clearWrap clears the state where the cursor is in the margin
+// waiting for the next character before wrapping the line. This must
+// be done before most operations that act on the cursor.
+func (h *windowsAnsiEventHandler) clearWrap() {
+	h.wrapNext = false
+	h.drewMarginByte = false
+}