c2047754c3
Compiler changes:
* Change map assignment to use mapassign and assign value directly.
* Change string iteration to use decoderune, faster for ASCII strings.
* Change makeslice to take int, and use makeslice64 for larger values.
* Add new noverflow field to hmap struct used for maps.
Unresolved problems, to be fixed later:
* Commented out test in go/types/sizes_test.go that doesn't compile.
* Commented out reflect.TestStructOf test for padding after zero-sized field.
Reviewed-on: https://go-review.googlesource.com/35231
gotools/:
Updates for Go 1.8rc1.
* Makefile.am (go_cmd_go_files): Add bug.go.
(s-zdefaultcc): Write defaultPkgConfig.
* Makefile.in: Rebuild.
From-SVN: r244456
120 lines
3 KiB
Go
120 lines
3 KiB
Go
// Copyright 2012 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build !cmd_go_bootstrap
|
|
|
|
// This code is compiled into the real 'go' binary, but it is not
|
|
// compiled into the binary that is built during all.bash, so as
|
|
// to avoid needing to build net (and thus use cgo) during the
|
|
// bootstrap process.
|
|
|
|
package main
|
|
|
|
import (
|
|
"cmd/internal/browser"
|
|
"crypto/tls"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// httpClient is the default HTTP client, but a variable so it can be
|
|
// changed by tests, without modifying http.DefaultClient.
|
|
var httpClient = http.DefaultClient
|
|
|
|
// impatientInsecureHTTPClient is used in -insecure mode,
|
|
// when we're connecting to https servers that might not be there
|
|
// or might be using self-signed certificates.
|
|
var impatientInsecureHTTPClient = &http.Client{
|
|
Timeout: 5 * time.Second,
|
|
Transport: &http.Transport{
|
|
Proxy: http.ProxyFromEnvironment,
|
|
TLSClientConfig: &tls.Config{
|
|
InsecureSkipVerify: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
type httpError struct {
|
|
status string
|
|
statusCode int
|
|
url string
|
|
}
|
|
|
|
func (e *httpError) Error() string {
|
|
return fmt.Sprintf("%s: %s", e.url, e.status)
|
|
}
|
|
|
|
// httpGET returns the data from an HTTP GET request for the given URL.
|
|
func httpGET(url string) ([]byte, error) {
|
|
resp, err := httpClient.Get(url)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != 200 {
|
|
err := &httpError{status: resp.Status, statusCode: resp.StatusCode, url: url}
|
|
|
|
return nil, err
|
|
}
|
|
b, err := ioutil.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s: %v", url, err)
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
// httpsOrHTTP returns the body of either the importPath's
|
|
// https resource or, if unavailable, the http resource.
|
|
func httpsOrHTTP(importPath string, security securityMode) (urlStr string, body io.ReadCloser, err error) {
|
|
fetch := func(scheme string) (urlStr string, res *http.Response, err error) {
|
|
u, err := url.Parse(scheme + "://" + importPath)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
u.RawQuery = "go-get=1"
|
|
urlStr = u.String()
|
|
if buildV {
|
|
log.Printf("Fetching %s", urlStr)
|
|
}
|
|
if security == insecure && scheme == "https" { // fail earlier
|
|
res, err = impatientInsecureHTTPClient.Get(urlStr)
|
|
} else {
|
|
res, err = httpClient.Get(urlStr)
|
|
}
|
|
return
|
|
}
|
|
closeBody := func(res *http.Response) {
|
|
if res != nil {
|
|
res.Body.Close()
|
|
}
|
|
}
|
|
urlStr, res, err := fetch("https")
|
|
if err != nil {
|
|
if buildV {
|
|
log.Printf("https fetch failed: %v", err)
|
|
}
|
|
if security == insecure {
|
|
closeBody(res)
|
|
urlStr, res, err = fetch("http")
|
|
}
|
|
}
|
|
if err != nil {
|
|
closeBody(res)
|
|
return "", nil, err
|
|
}
|
|
// Note: accepting a non-200 OK here, so people can serve a
|
|
// meta import in their http 404 page.
|
|
if buildV {
|
|
log.Printf("Parsing meta tags from %s (status code %d)", urlStr, res.StatusCode)
|
|
}
|
|
return urlStr, res.Body, nil
|
|
}
|
|
|
|
func queryEscape(s string) string { return url.QueryEscape(s) }
|
|
func openBrowser(url string) bool { return browser.Open(url) }
|