upload/azure: use the new azure/azblob API on Fedora 33+ & RHEL

Fedora 33 and rawhide got an updated version of the azblob library. Sadly, it
introduced a non-compatible API change. This commit does the same thing as
a67baf5a did for kolo/xmlrpc:

We now have two wrappers around the affected part of the API. Fedora 32 uses
the wrapper around the old API, whereas Fedora 33 and 34 (and RHEL with its
vendored deps) use the wrapper around the new API. The switch is implemented
using go build flags and spec file magic.

See a67baf5a for more thoughts.

Also, there's v0.11.1-0.20201209121048-6df5d9af221d in go.mod, why?

The maintainers of azblob probably tagged a wrong commit with v0.12.0 which
breaks go. The long v0.11.1-.* version is basically the proper v0.12.0 commit.
See https://github.com/Azure/azure-storage-blob-go/issues/236 for more
information.

Signed-off-by: Ondřej Budai <ondrej@budai.cz>

vendor/github.com/mattn/go-ieproxy/go.mod

@@ -0,0 +1,9 @@
+module github.com/mattn/go-ieproxy
+
+go 1.14
+
+require (
+	golang.org/x/net v0.0.0-20191112182307-2180aed22343
+	golang.org/x/sys v0.0.0-20191112214154-59a1497f0cea
+	golang.org/x/text v0.3.2 // indirect
+)

vendor/github.com/mattn/go-ieproxy/go.sum

@@ -0,0 +1,11 @@
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20191112182307-2180aed22343 h1:00ohfJ4K98s3m6BGUoBd8nyfp4Yl0GoIKvw5abItTjI=
+golang.org/x/net v0.0.0-20191112182307-2180aed22343/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20191112214154-59a1497f0cea h1:Mz1TMnfJDRJLk8S8OPCoJYgrsp/Se/2TBre2+vwX128=
+golang.org/x/sys v0.0.0-20191112214154-59a1497f0cea/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

vendor/github.com/mattn/go-ieproxy/ieproxy_windows.go

@@ -25,33 +25,55 @@ func getConf() ProxyConf {
 }
 
 func writeConf() {
-	var (
-		cfg *tWINHTTP_CURRENT_USER_IE_PROXY_CONFIG
-		err error
-	)
+	proxy := ""
+	proxyByPass := ""
+	autoConfigUrl := ""
+	autoDetect := false
 
-	if cfg, err = getUserConfigFromWindowsSyscall(); err != nil {
+	// Try from IE first.
+	if ieCfg, err := getUserConfigFromWindowsSyscall(); err == nil {
+		defer globalFreeWrapper(ieCfg.lpszProxy)
+		defer globalFreeWrapper(ieCfg.lpszProxyBypass)
+		defer globalFreeWrapper(ieCfg.lpszAutoConfigUrl)
+
+		proxy = StringFromUTF16Ptr(ieCfg.lpszProxy)
+		proxyByPass = StringFromUTF16Ptr(ieCfg.lpszProxyBypass)
+		autoConfigUrl = StringFromUTF16Ptr(ieCfg.lpszAutoConfigUrl)
+		autoDetect = ieCfg.fAutoDetect
+	}
+
+	if proxy == "" && !autoDetect{
+		// Try WinHTTP default proxy.
+		if defaultCfg, err := getDefaultProxyConfiguration(); err == nil {
+			defer globalFreeWrapper(defaultCfg.lpszProxy)
+			defer globalFreeWrapper(defaultCfg.lpszProxyBypass)
+
+			// Always set both of these (they are a pair, it doesn't make sense to set one here and keep the value of the other from above)
+			proxy = StringFromUTF16Ptr(defaultCfg.lpszProxy)
+			proxyByPass = StringFromUTF16Ptr(defaultCfg.lpszProxyBypass)
+		}
+	}
+
+	if proxy == "" && !autoDetect {
+		// Fall back to IE registry or manual detection if nothing is found there..
 		regedit, _ := readRegedit() // If the syscall fails, backup to manual detection.
 		windowsProxyConf = parseRegedit(regedit)
 		return
 	}
 
-	defer globalFreeWrapper(cfg.lpszProxy)
-	defer globalFreeWrapper(cfg.lpszProxyBypass)
-	defer globalFreeWrapper(cfg.lpszAutoConfigUrl)
-
+	// Setting the proxy settings.
 	windowsProxyConf = ProxyConf{
 		Static: StaticProxyConf{
-			Active: cfg.lpszProxy != nil,
+			Active: len(proxy) > 0,
 		},
 		Automatic: ProxyScriptConf{
-			Active: cfg.lpszAutoConfigUrl != nil || cfg.fAutoDetect,
+			Active: len(autoConfigUrl) > 0 || autoDetect,
 		},
 	}
 
 	if windowsProxyConf.Static.Active {
 		protocol := make(map[string]string)
-		for _, s := range strings.Split(StringFromUTF16Ptr(cfg.lpszProxy), ";") {
+		for _, s := range strings.Split(proxy, ";") {
 			s = strings.TrimSpace(s)
 			if s == "" {
 				continue
@@ -65,31 +87,38 @@ func writeConf() {
 		}
 
 		windowsProxyConf.Static.Protocols = protocol
-		if cfg.lpszProxyBypass != nil {
-			windowsProxyConf.Static.NoProxy = strings.Replace(StringFromUTF16Ptr(cfg.lpszProxyBypass), ";", ",", -1)
+		if len(proxyByPass) > 0 {
+			windowsProxyConf.Static.NoProxy = strings.Replace(proxyByPass, ";", ",", -1)
 		}
 	}
 
 	if windowsProxyConf.Automatic.Active {
-		windowsProxyConf.Automatic.PreConfiguredURL = StringFromUTF16Ptr(cfg.lpszAutoConfigUrl)
+		windowsProxyConf.Automatic.PreConfiguredURL = autoConfigUrl
 	}
 }
 
 func getUserConfigFromWindowsSyscall() (*tWINHTTP_CURRENT_USER_IE_PROXY_CONFIG, error) {
-	handle, _, err := winHttpOpen.Call(0, 0, 0, 0, 0)
-	if handle == 0 {
-		return &tWINHTTP_CURRENT_USER_IE_PROXY_CONFIG{}, err
+	if err := winHttpGetIEProxyConfigForCurrentUser.Find(); err != nil {
+		return nil, err
 	}
-	defer winHttpCloseHandle.Call(handle)
-
-	config := new(tWINHTTP_CURRENT_USER_IE_PROXY_CONFIG)
-
-	ret, _, err := winHttpGetIEProxyConfigForCurrentUser.Call(uintptr(unsafe.Pointer(config)))
-	if ret > 0 {
-		err = nil
+	p := new(tWINHTTP_CURRENT_USER_IE_PROXY_CONFIG)
+	r, _, err := winHttpGetIEProxyConfigForCurrentUser.Call(uintptr(unsafe.Pointer(p)))
+	if rTrue(r) {
+		return p, nil
 	}
+	return nil, err
+}
 
-	return config, err
+func getDefaultProxyConfiguration() (*tWINHTTP_PROXY_INFO, error) {
+	pInfo := new(tWINHTTP_PROXY_INFO)
+	if err := winHttpGetDefaultProxyConfiguration.Find(); err != nil {
+		return nil, err
+	}
+	r, _, err := winHttpGetDefaultProxyConfiguration.Call(uintptr(unsafe.Pointer(pInfo)))
+	if rTrue(r) {
+		return pInfo, nil
+	}
+	return nil, err
 }
 
 // OverrideEnvWithStaticProxy writes new values to the
@@ -135,7 +164,27 @@ func parseRegedit(regedit regeditValues) ProxyConf {
 }
 
 func readRegedit() (values regeditValues, err error) {
-	k, err := registry.OpenKey(registry.CURRENT_USER, `Software\Microsoft\Windows\CurrentVersion\Internet Settings`, registry.QUERY_VALUE)
+	var proxySettingsPerUser uint64 = 1 // 1 is the default value to consider current user
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, `Software\Policies\Microsoft\Windows\CurrentVersion\Internet Settings`, registry.QUERY_VALUE)
+	if err == nil {
+		//We had used the below variable tempPrxUsrSettings, because the Golang method GetIntegerValue
+		//sets the value to zero even it fails.
+		tempPrxUsrSettings, _, err := k.GetIntegerValue("ProxySettingsPerUser")
+		if err == nil {
+			//consider the value of tempPrxUsrSettings if it is a success
+			proxySettingsPerUser = tempPrxUsrSettings
+		}
+		k.Close()
+	}
+
+	var hkey registry.Key
+	if proxySettingsPerUser == 0 {
+		hkey = registry.LOCAL_MACHINE
+	} else {
+		hkey = registry.CURRENT_USER
+	}
+
+	k, err = registry.OpenKey(hkey, `Software\Microsoft\Windows\CurrentVersion\Internet Settings`, registry.QUERY_VALUE)
 	if err != nil {
 		return
 	}

vendor/github.com/mattn/go-ieproxy/kernel32_data_windows.go

@@ -13,3 +13,7 @@ func globalFreeWrapper(ptr *uint16) {
 		_, _, _ = globalFree.Call(uintptr(unsafe.Pointer(ptr)))
 	}
 }
+
+func rTrue(r uintptr) bool {
+	return r == 1
+}

vendor/github.com/mattn/go-ieproxy/proxy_middleman_unix.go

@@ -1,4 +1,4 @@
-//+build darwin unix linux
+// +build !windows
 
 package ieproxy
 

vendor/github.com/mattn/go-ieproxy/proxy_middleman_windows.go

@@ -15,30 +15,31 @@ func proxyMiddleman() func(req *http.Request) (i *url.URL, e error) {
 	if envcfg.HTTPProxy != "" || envcfg.HTTPSProxy != "" {
 		// If the user manually specifies environment variables, prefer those over the Windows config.
 		return http.ProxyFromEnvironment
-	} else if conf.Automatic.Active {
-		// If automatic proxy obtaining is specified
-		return func(req *http.Request) (i *url.URL, e error) {
-			host := conf.Automatic.FindProxyForURL(req.URL.String())
-			if host == "" {
-				return nil, nil
-			}
-			return &url.URL{Host: host}, nil
-		}
-	} else if conf.Static.Active {
-		// If static proxy obtaining is specified
-		prox := httpproxy.Config{
-			HTTPSProxy: mapFallback("https", "", conf.Static.Protocols),
-			HTTPProxy:  mapFallback("http", "", conf.Static.Protocols),
-			NoProxy:    conf.Static.NoProxy,
-		}
-
-		return func(req *http.Request) (i *url.URL, e error) {
-			return prox.ProxyFunc()(req.URL)
-		}
-	} else {
-		// Final fallthrough case; use the environment variables.
-		return http.ProxyFromEnvironment
 	}
+
+	return func(req *http.Request) (i *url.URL, e error) {
+		if conf.Automatic.Active {
+			host := conf.Automatic.FindProxyForURL(req.URL.String())
+			if host != "" {
+				return &url.URL{Host: host}, nil
+			}
+		}
+		if conf.Static.Active {
+			return staticProxy(conf, req)
+		}
+		// Should return no proxy; fallthrough.
+		return http.ProxyFromEnvironment(req)
+	}
+}
+
+func staticProxy(conf ProxyConf, req *http.Request) (i *url.URL, e error) {
+	// If static proxy obtaining is specified
+	prox := httpproxy.Config{
+		HTTPSProxy: mapFallback("https", "", conf.Static.Protocols),
+		HTTPProxy:  mapFallback("http", "", conf.Static.Protocols),
+		NoProxy:    conf.Static.NoProxy,
+	}
+	return prox.ProxyFunc()(req.URL)
 }
 
 // Return oKey or fbKey if oKey doesn't exist in the map.

vendor/github.com/mattn/go-ieproxy/winhttp_data_windows.go

@@ -7,6 +7,7 @@ var winHttpGetProxyForURL = winHttp.NewProc("WinHttpGetProxyForUrl")
 var winHttpOpen = winHttp.NewProc("WinHttpOpen")
 var winHttpCloseHandle = winHttp.NewProc("WinHttpCloseHandle")
 var winHttpGetIEProxyConfigForCurrentUser = winHttp.NewProc("WinHttpGetIEProxyConfigForCurrentUser")
+var winHttpGetDefaultProxyConfiguration = winHttp.NewProc("WinHttpGetDefaultProxyConfiguration")
 
 type tWINHTTP_AUTOPROXY_OPTIONS struct {
 	dwFlags                autoProxyFlag