Open platform to collect and prioritize feedback
tooling: update Go dependencies (#708)
Guilherme Oenning0d1478bd66fd
diff --git a/Gopkg.lock b/Gopkg.lockindex 5fe19d358..52bda64ef 100644--- a/Gopkg.lock+++ b/Gopkg.lock@@ -2,15 +2,7 @@[[projects]]- digest = "1:28181cff95634e84b01ac5d9d5bffd201cd02404b78a0e69ba29e9bc41703ff0"- name = "cloud.google.com/go"- packages = ["compute/metadata"]- pruneopts = "UT"- revision = "5a9e19d4e1e41a734154e44a2132b358afb49a03"- version = "v0.13.0"--[[projects]]- digest = "1:4488d53934d19e169589db4c90a11bf452fa1e5e97176fe60892ebf8121fe05a"+ digest = "1:35564f1cd08e1163bf327e6f595b9e596c4470a77f7f13fe6421236ea99e5966"name = "github.com/aws/aws-sdk-go"packages = ["aws",@@ -49,8 +41,8 @@"service/sts",]pruneopts = "UT"- revision = "818fa5c274d4dee665096411e2bad037f47c31f7"- version = "v1.16.3"+ revision = "3991042237b45cf58c9d5f34295942d5533c28c6"+ version = "v1.16.11"[[projects]]digest = "1:76dc72490af7174349349838f2fe118996381b31ea83243812a97e5a0fd5ed55"@@ -89,20 +81,20 @@revision = "e2365dfdc4a05e4b8299a783240d4a7d5a65d4e4"[[projects]]- branch = "master"- digest = "1:9b0e71863f18fc5de645a263184c8a6409ae731e847b35b25da4be818f1975fa"+ digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d"name = "github.com/golang/protobuf"packages = ["proto"]pruneopts = "UT"- revision = "ae59567b9aab61b50b2590679a62c3c044030b61"+ revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"+ version = "v1.2.0"[[projects]]- digest = "1:0ae2e1b2d4cdff4834aa28ce2e33a7b6de91e10150e3647fe1b9fd63a51b39ce"+ digest = "1:e1aa8e520787bfd8623c7df394352be3183ef207039cfb513ba40dc00c82fa6d"name = "github.com/gosimple/slug"packages = ["."]pruneopts = "UT"- revision = "e9f42fa127660e552d0ad2b589868d403a9be7c6"- version = "v1.1.1"+ revision = "42ac18c34c2c6f4843fa48167317dcaa9416d1e2"+ version = "v1.4.2"[[projects]]digest = "1:bb81097a5b62634f3e9fec1014657855610c82d19b9a40c17612e32651e35dca"@@ -129,14 +121,14 @@[[projects]]branch = "master"- digest = "1:37ce7d7d80531b227023331002c0d42b4b4b291a96798c82a049d03a54ba79e4"+ digest = "1:7cefc4f7f6a411c2598d3344563e4d23fd4e4d88fd1591831fe39cccff41ad28"name = "github.com/lib/pq"packages = [".","oid",]pruneopts = "UT"- revision = "90697d60dd844d5ef6ff15135d0203f65d2f53b8"+ revision = "9eb73efc1fcc404148b56765b0d3f61d9a5ef8ee"[[projects]]digest = "1:808cdddf087fb64baeae67b8dfaee2069034d9704923a3cb8bd96a995421a625"@@ -155,27 +147,27 @@revision = "cb7f23ec59bec0d61b19c56cd88cee3d0cc1870c"[[projects]]- digest = "1:8bc629776d035c003c7814d4369521afe67fdb8efc4b5f66540d29343b98cf23"+ digest = "1:b36a0ede02c4c2aef7df7f91cbbb7bb88a98b5d253509d4f997dda526e50c88c"name = "github.com/russross/blackfriday"packages = ["."]pruneopts = "UT"- revision = "55d61fa8aa702f59229e6cff85793c22e580eaf5"- version = "v1.5.1"+ revision = "05f3235734ad95d0016f6a23902f06461fcf567a"+ version = "v1.5.2"[[projects]]branch = "master"- digest = "1:507fa82feeba6c3651d3cfb7593a498144ae6455e1b00dde2e0c344cdfdc9c4d"+ digest = "1:e3d2db9bc633f4635e6418caf0b0734c43821ecd59105d1798458c6ae4d227fd"name = "golang.org/x/crypto"packages = ["acme","acme/autocert",]pruneopts = "UT"- revision = "2c241ca3045ddc354463c376a9515d9f1f1390a4"+ revision = "8d7daa0c54b357f3071e11eaef7efc4e19a417e2"[[projects]]branch = "master"- digest = "1:3f27b2eb37fc7c73de41226ec8b21066019934150c96d87f6e76354945a6f005"+ digest = "1:98cb8180faeb2421bfb3d6f6c8d2f3525758102e1629ffbaea954c339400e891"name = "golang.org/x/image"packages = ["bmp",@@ -187,46 +179,40 @@"tiff/lzw",]pruneopts = "UT"- revision = "e20db36d77bd0cb36cea8fe49d5c37d82d21591f"+ revision = "cd38e8056d9b27bb2f265effa37fb0ea6b8a7f0f"[[projects]]branch = "master"- digest = "1:cb2c7a3956a0b04d0ddca74cc7a008b467db63d3b6cbdc678111e9ea1416fc95"+ digest = "1:f8b491a7c25030a895a0e579742d07136e6958e77ef2d46e769db8eec4e58fcd"name = "golang.org/x/net"packages = ["context","context/ctxhttp",]pruneopts = "UT"- revision = "8351a756f30f1297fe94bbf4b767ec589c6ea6d0"+ revision = "927f97764cc334a6575f4b7a1584a147864d5723"[[projects]]branch = "master"- digest = "1:10f69df7d03f1799319a065a80633204821d98afcbb1f2d62a1f2be01abdacab"+ digest = "1:cea04128c498bdd994ddcf81f001f6328c5ce8df707f99ce5ba3ef4ccc6a9671"name = "golang.org/x/oauth2"packages = [".","facebook","github",- "google","internal",- "jws",- "jwt",]pruneopts = "UT"- revision = "ef147856a6ddbb60760db74283d2424e98c87bff"+ revision = "d668ce993890a79bda886613ee587a69dd5da7a6"[[projects]]- digest = "1:a48f97fb737d5d61cf13e81cfef040942d217d086766b823757d39d4f6a4c547"+ digest = "1:9cf45e754ab2dff5f53a553e6948b994ff738e4d1092ca608dcada945d8be0ef"name = "google.golang.org/appengine"packages = [- ".","internal",- "internal/app_identity","internal/base","internal/datastore","internal/log",- "internal/modules","internal/remote_api","internal/urlfetch","urlfetch",@@ -253,12 +239,12 @@"github.com/lib/pq","github.com/patrickmn/go-cache","github.com/russross/blackfriday",+ "golang.org/x/crypto/acme","golang.org/x/crypto/acme/autocert","golang.org/x/image/draw","golang.org/x/oauth2","golang.org/x/oauth2/facebook","golang.org/x/oauth2/github",- "golang.org/x/oauth2/google",]solver-name = "gps-cdcl"solver-version = 1diff --git a/Gopkg.toml b/Gopkg.tomlindex b7e154958..b9f52ba21 100644--- a/Gopkg.toml+++ b/Gopkg.toml@@ -19,7 +19,7 @@ ignored = ["github.com/magefile/mage/mg","github.com/magefile/mage/sh"][[constraint]]name = "github.com/russross/blackfriday"- version = "^1.5.1"+ version = "^1.5.2"[[constraint]]branch = "master"@@ -42,7 +42,7 @@ ignored = ["github.com/magefile/mage/mg","github.com/magefile/mage/sh"]version = "2.1.0"[[constraint]]- version = "v1.16.3"+ version = "v1.16.11"name = "github.com/aws/aws-sdk-go"[[constraint]]diff --git a/app/pkg/web/oauth_test.go b/app/pkg/web/oauth_test.goindex 0905661d7..95ed7f98a 100644--- a/app/pkg/web/oauth_test.go+++ b/app/pkg/web/oauth_test.go@@ -19,7 +19,7 @@ func TestGetAuthURL_Facebook(t *testing.T) {authURL, err := svc.GetAuthURL(oauth.FacebookProvider, "http://example.org", "456")Expect(err).IsNil()- Expect(authURL).Equals("https://www.facebook.com/dialog/oauth?client_id=FB_CL_ID&redirect_uri=http%3A%2F%2Flogin.test.fider.io%3A3000%2Foauth%2Ffacebook%2Fcallback&response_type=code&scope=public_profile+email&state=http%3A%2F%2Fexample.org%7C456")+ Expect(authURL).Equals("https://www.facebook.com/v3.1/dialog/oauth?client_id=FB_CL_ID&redirect_uri=http%3A%2F%2Flogin.test.fider.io%3A3000%2Foauth%2Ffacebook%2Fcallback&response_type=code&scope=public_profile+email&state=http%3A%2F%2Fexample.org%7C456")}func TestGetAuthURL_Google(t *testing.T) {diff --git a/app/pkg/web/ssl.go b/app/pkg/web/ssl.goindex 2ed8680a3..6b628bea5 100644--- a/app/pkg/web/ssl.go+++ b/app/pkg/web/ssl.go@@ -6,6 +6,8 @@ import ("net/http""strings"+ "golang.org/x/crypto/acme"+"github.com/getfider/fider/app/pkg/blob""github.com/getfider/fider/app/pkg/dbx""github.com/getfider/fider/app/pkg/di"@@ -51,6 +53,7 @@ func NewCertificateManager(certFile, keyFile string, db *dbx.Database) (*Certifiautossl: autocert.Manager{Prompt: autocert.AcceptTOS,Cache: blob.NewAutoCert(di.NewBlobStorage(db)),+ Client: acmeClient(),},}@@ -99,3 +102,12 @@ func (m *CertificateManager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Cefunc (m *CertificateManager) StartHTTPServer() {http.ListenAndServe(":80", m.autossl.HTTPHandler(nil))}++func acmeClient() *acme.Client {+ if env.IsTest() {+ return &acme.Client{+ DirectoryURL: "https://acme-staging.api.letsencrypt.org/directory",+ }+ }+ return nil+}diff --git a/app/pkg/web/ssl_test.go b/app/pkg/web/ssl_test.goindex 2b64d34b1..fc374b743 100644--- a/app/pkg/web/ssl_test.go+++ b/app/pkg/web/ssl_test.go@@ -67,7 +67,7 @@ func Test_UseAutoCert(t *testing.T) {cert, err := manager.GetCertificate(&tls.ClientHelloInfo{ServerName: serverName,})- Expect(err.Error()).Equals(`acme/autocert: unable to authorize "` + serverName + `"; tried ["tls-sni-02" "tls-sni-01"]`)+ Expect(err.Error()).ContainsSubstring(`acme/autocert: unable to authorize "` + serverName + `"; challenge "tls-alpn-01" failed with error: acme: authorization error`)Expect(cert).IsNil()}}diff --git a/vendor/cloud.google.com/go/AUTHORS b/vendor/cloud.google.com/go/AUTHORSdeleted file mode 100644index c364af1da..000000000--- a/vendor/cloud.google.com/go/AUTHORS+++ /dev/null@@ -1,15 +0,0 @@-# This is the official list of cloud authors for copyright purposes.-# This file is distinct from the CONTRIBUTORS files.-# See the latter for an explanation.--# Names should be added to this file as:-# Name or Organization <email address>-# The email address is not required for organizations.--Filippo Valsorda <[email protected]>-Google Inc.-Ingo Oeser <[email protected]>-Palm Stone Games, Inc.-Paweł Knap <[email protected]>-Péter Szilágyi <[email protected]>-Tyler Treat <[email protected]>diff --git a/vendor/cloud.google.com/go/CONTRIBUTORS b/vendor/cloud.google.com/go/CONTRIBUTORSdeleted file mode 100644index d4b376c7c..000000000--- a/vendor/cloud.google.com/go/CONTRIBUTORS+++ /dev/null@@ -1,37 +0,0 @@-# People who have agreed to one of the CLAs and can contribute patches.-# The AUTHORS file lists the copyright holders; this file-# lists people. For example, Google employees are listed here-# but not in AUTHORS, because Google holds the copyright.-#-# https://developers.google.com/open-source/cla/individual-# https://developers.google.com/open-source/cla/corporate-#-# Names should be added to this file as:-# Name <email address>--# Keep the list alphabetically sorted.--Alexis Hunt <[email protected]>-Andreas Litt <[email protected]>-Andrew Gerrand <[email protected]>-Brad Fitzpatrick <[email protected]>-Burcu Dogan <[email protected]>-Dave Day <[email protected]>-David Sansome <[email protected]>-David Symonds <[email protected]>-Filippo Valsorda <[email protected]>-Glenn Lewis <[email protected]>-Ingo Oeser <[email protected]>-Johan Euphrosine <[email protected]>-Jonathan Amsterdam <[email protected]>-Luna Duclos <[email protected]>-Magnus Hiie <[email protected]>-Michael McGreevy <[email protected]>-Omar Jarjur <[email protected]>-Paweł Knap <[email protected]>-Péter Szilágyi <[email protected]>-Sarah Adams <[email protected]>-Thanatat Tamtan <[email protected]>-Toby Burress <[email protected]>-Tuo Shan <[email protected]>-Tyler Treat <[email protected]>diff --git a/vendor/cloud.google.com/go/LICENSE b/vendor/cloud.google.com/go/LICENSEdeleted file mode 100644index a4c5efd82..000000000--- a/vendor/cloud.google.com/go/LICENSE+++ /dev/null@@ -1,202 +0,0 @@-- Apache License- Version 2.0, January 2004- http://www.apache.org/licenses/-- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION-- 1. Definitions.-- "License" shall mean the terms and conditions for use, reproduction,- and distribution as defined by Sections 1 through 9 of this document.-- "Licensor" shall mean the copyright owner or entity authorized by- the copyright owner that is granting the License.-- "Legal Entity" shall mean the union of the acting entity and all- other entities that control, are controlled by, or are under common- control with that entity. For the purposes of this definition,- "control" means (i) the power, direct or indirect, to cause the- direction or management of such entity, whether by contract or- otherwise, or (ii) ownership of fifty percent (50%) or more of the- outstanding shares, or (iii) beneficial ownership of such entity.-- "You" (or "Your") shall mean an individual or Legal Entity- exercising permissions granted by this License.-- "Source" form shall mean the preferred form for making modifications,- including but not limited to software source code, documentation- source, and configuration files.-- "Object" form shall mean any form resulting from mechanical- transformation or translation of a Source form, including but- not limited to compiled object code, generated documentation,- and conversions to other media types.-- "Work" shall mean the work of authorship, whether in Source or- Object form, made available under the License, as indicated by a- copyright notice that is included in or attached to the work- (an example is provided in the Appendix below).-- "Derivative Works" shall mean any work, whether in Source or Object- form, that is based on (or derived from) the Work and for which the- editorial revisions, annotations, elaborations, or other modifications- represent, as a whole, an original work of authorship. For the purposes- of this License, Derivative Works shall not include works that remain- separable from, or merely link (or bind by name) to the interfaces of,- the Work and Derivative Works thereof.-- "Contribution" shall mean any work of authorship, including- the original version of the Work and any modifications or additions- to that Work or Derivative Works thereof, that is intentionally- submitted to Licensor for inclusion in the Work by the copyright owner- or by an individual or Legal Entity authorized to submit on behalf of- the copyright owner. For the purposes of this definition, "submitted"- means any form of electronic, verbal, or written communication sent- to the Licensor or its representatives, including but not limited to- communication on electronic mailing lists, source code control systems,- and issue tracking systems that are managed by, or on behalf of, the- Licensor for the purpose of discussing and improving the Work, but- excluding communication that is conspicuously marked or otherwise- designated in writing by the copyright owner as "Not a Contribution."-- "Contributor" shall mean Licensor and any individual or Legal Entity- on behalf of whom a Contribution has been received by Licensor and- subsequently incorporated within the Work.-- 2. Grant of Copyright License. Subject to the terms and conditions of- this License, each Contributor hereby grants to You a perpetual,- worldwide, non-exclusive, no-charge, royalty-free, irrevocable- copyright license to reproduce, prepare Derivative Works of,- publicly display, publicly perform, sublicense, and distribute the- Work and such Derivative Works in Source or Object form.-- 3. Grant of Patent License. Subject to the terms and conditions of- this License, each Contributor hereby grants to You a perpetual,- worldwide, non-exclusive, no-charge, royalty-free, irrevocable- (except as stated in this section) patent license to make, have made,- use, offer to sell, sell, import, and otherwise transfer the Work,- where such license applies only to those patent claims licensable- by such Contributor that are necessarily infringed by their- Contribution(s) alone or by combination of their Contribution(s)- with the Work to which such Contribution(s) was submitted. If You- institute patent litigation against any entity (including a- cross-claim or counterclaim in a lawsuit) alleging that the Work- or a Contribution incorporated within the Work constitutes direct- or contributory patent infringement, then any patent licenses- granted to You under this License for that Work shall terminate- as of the date such litigation is filed.-- 4. Redistribution. You may reproduce and distribute copies of the- Work or Derivative Works thereof in any medium, with or without- modifications, and in Source or Object form, provided that You- meet the following conditions:-- (a) You must give any other recipients of the Work or- Derivative Works a copy of this License; and-- (b) You must cause any modified files to carry prominent notices- stating that You changed the files; and-- (c) You must retain, in the Source form of any Derivative Works- that You distribute, all copyright, patent, trademark, and- attribution notices from the Source form of the Work,- excluding those notices that do not pertain to any part of- the Derivative Works; and-- (d) If the Work includes a "NOTICE" text file as part of its- distribution, then any Derivative Works that You distribute must- include a readable copy of the attribution notices contained- within such NOTICE file, excluding those notices that do not- pertain to any part of the Derivative Works, in at least one- of the following places: within a NOTICE text file distributed- as part of the Derivative Works; within the Source form or- documentation, if provided along with the Derivative Works; or,- within a display generated by the Derivative Works, if and- wherever such third-party notices normally appear. The contents- of the NOTICE file are for informational purposes only and- do not modify the License. You may add Your own attribution- notices within Derivative Works that You distribute, alongside- or as an addendum to the NOTICE text from the Work, provided- that such additional attribution notices cannot be construed- as modifying the License.-- You may add Your own copyright statement to Your modifications and- may provide additional or different license terms and conditions- for use, reproduction, or distribution of Your modifications, or- for any such Derivative Works as a whole, provided Your use,- reproduction, and distribution of the Work otherwise complies with- the conditions stated in this License.-- 5. Submission of Contributions. Unless You explicitly state otherwise,- any Contribution intentionally submitted for inclusion in the Work- by You to the Licensor shall be under the terms and conditions of- this License, without any additional terms or conditions.- Notwithstanding the above, nothing herein shall supersede or modify- the terms of any separate license agreement you may have executed- with Licensor regarding such Contributions.-- 6. Trademarks. This License does not grant permission to use the trade- names, trademarks, service marks, or product names of the Licensor,- except as required for reasonable and customary use in describing the- origin of the Work and reproducing the content of the NOTICE file.-- 7. Disclaimer of Warranty. Unless required by applicable law or- agreed to in writing, Licensor provides the Work (and each- Contributor provides its Contributions) on an "AS IS" BASIS,- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or- implied, including, without limitation, any warranties or conditions- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A- PARTICULAR PURPOSE. You are solely responsible for determining the- appropriateness of using or redistributing the Work and assume any- risks associated with Your exercise of permissions under this License.-- 8. Limitation of Liability. In no event and under no legal theory,- whether in tort (including negligence), contract, or otherwise,- unless required by applicable law (such as deliberate and grossly- negligent acts) or agreed to in writing, shall any Contributor be- liable to You for damages, including any direct, indirect, special,- incidental, or consequential damages of any character arising as a- result of this License or out of the use or inability to use the- Work (including but not limited to damages for loss of goodwill,- work stoppage, computer failure or malfunction, or any and all- other commercial damages or losses), even if such Contributor- has been advised of the possibility of such damages.-- 9. Accepting Warranty or Additional Liability. While redistributing- the Work or Derivative Works thereof, You may choose to offer,- and charge a fee for, acceptance of support, warranty, indemnity,- or other liability obligations and/or rights consistent with this- License. However, in accepting such obligations, You may act only- on Your own behalf and on Your sole responsibility, not on behalf- of any other Contributor, and only if You agree to indemnify,- defend, and hold each Contributor harmless for any liability- incurred by, or claims asserted against, such Contributor by reason- of your accepting any such warranty or additional liability.-- END OF TERMS AND CONDITIONS-- APPENDIX: How to apply the Apache License to your work.-- To apply the Apache License to your work, attach the following- boilerplate notice, with the fields enclosed by brackets "[]"- replaced with your own identifying information. (Don't include- the brackets!) The text should be enclosed in the appropriate- comment syntax for the file format. We also recommend that a- file or class name and description of purpose be included on the- same "printed page" as the copyright notice for easier- identification within third-party archives.-- Copyright 2014 Google Inc.-- Licensed under the Apache License, Version 2.0 (the "License");- you may not use this file except in compliance with the License.- You may obtain a copy of the License at-- http://www.apache.org/licenses/LICENSE-2.0-- Unless required by applicable law or agreed to in writing, software- distributed under the License is distributed on an "AS IS" BASIS,- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.- See the License for the specific language governing permissions and- limitations under the License.diff --git a/vendor/cloud.google.com/go/compute/metadata/metadata.go b/vendor/cloud.google.com/go/compute/metadata/metadata.godeleted file mode 100644index e708c031b..000000000--- a/vendor/cloud.google.com/go/compute/metadata/metadata.go+++ /dev/null@@ -1,437 +0,0 @@-// Copyright 2014 Google Inc. All Rights Reserved.-//-// Licensed under the Apache License, Version 2.0 (the "License");-// you may not use this file except in compliance with the License.-// You may obtain a copy of the License at-//-// http://www.apache.org/licenses/LICENSE-2.0-//-// Unless required by applicable law or agreed to in writing, software-// distributed under the License is distributed on an "AS IS" BASIS,-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.-// See the License for the specific language governing permissions and-// limitations under the License.--// Package metadata provides access to Google Compute Engine (GCE)-// metadata and API service accounts.-//-// This package is a wrapper around the GCE metadata service,-// as documented at https://developers.google.com/compute/docs/metadata.-package metadata // import "cloud.google.com/go/compute/metadata"--import (- "encoding/json"- "fmt"- "io/ioutil"- "net"- "net/http"- "net/url"- "os"- "runtime"- "strings"- "sync"- "time"-- "golang.org/x/net/context"- "golang.org/x/net/context/ctxhttp"-)--const (- // metadataIP is the documented metadata server IP address.- metadataIP = "169.254.169.254"-- // metadataHostEnv is the environment variable specifying the- // GCE metadata hostname. If empty, the default value of- // metadataIP ("169.254.169.254") is used instead.- // This is variable name is not defined by any spec, as far as- // I know; it was made up for the Go package.- metadataHostEnv = "GCE_METADATA_HOST"-- userAgent = "gcloud-golang/0.1"-)--type cachedValue struct {- k string- trim bool- mu sync.Mutex- v string-}--var (- projID = &cachedValue{k: "project/project-id", trim: true}- projNum = &cachedValue{k: "project/numeric-project-id", trim: true}- instID = &cachedValue{k: "instance/id", trim: true}-)--var (- metaClient = &http.Client{- Transport: &http.Transport{- Dial: (&net.Dialer{- Timeout: 2 * time.Second,- KeepAlive: 30 * time.Second,- }).Dial,- ResponseHeaderTimeout: 2 * time.Second,- },- }- subscribeClient = &http.Client{- Transport: &http.Transport{- Dial: (&net.Dialer{- Timeout: 2 * time.Second,- KeepAlive: 30 * time.Second,- }).Dial,- },- }-)--// NotDefinedError is returned when requested metadata is not defined.-//-// The underlying string is the suffix after "/computeMetadata/v1/".-//-// This error is not returned if the value is defined to be the empty-// string.-type NotDefinedError string--func (suffix NotDefinedError) Error() string {- return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))-}--// Get returns a value from the metadata service.-// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".-//-// If the GCE_METADATA_HOST environment variable is not defined, a default of-// 169.254.169.254 will be used instead.-//-// If the requested metadata is not defined, the returned error will-// be of type NotDefinedError.-func Get(suffix string) (string, error) {- val, _, err := getETag(metaClient, suffix)- return val, err-}--// getETag returns a value from the metadata service as well as the associated-// ETag using the provided client. This func is otherwise equivalent to Get.-func getETag(client *http.Client, suffix string) (value, etag string, err error) {- // Using a fixed IP makes it very difficult to spoof the metadata service in- // a container, which is an important use-case for local testing of cloud- // deployments. To enable spoofing of the metadata service, the environment- // variable GCE_METADATA_HOST is first inspected to decide where metadata- // requests shall go.- host := os.Getenv(metadataHostEnv)- if host == "" {- // Using 169.254.169.254 instead of "metadata" here because Go- // binaries built with the "netgo" tag and without cgo won't- // know the search suffix for "metadata" is- // ".google.internal", and this IP address is documented as- // being stable anyway.- host = metadataIP- }- url := "http://" + host + "/computeMetadata/v1/" + suffix- req, _ := http.NewRequest("GET", url, nil)- req.Header.Set("Metadata-Flavor", "Google")- req.Header.Set("User-Agent", userAgent)- res, err := client.Do(req)- if err != nil {- return "", "", err- }- defer res.Body.Close()- if res.StatusCode == http.StatusNotFound {- return "", "", NotDefinedError(suffix)- }- if res.StatusCode != 200 {- return "", "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)- }- all, err := ioutil.ReadAll(res.Body)- if err != nil {- return "", "", err- }- return string(all), res.Header.Get("Etag"), nil-}--func getTrimmed(suffix string) (s string, err error) {- s, err = Get(suffix)- s = strings.TrimSpace(s)- return-}--func (c *cachedValue) get() (v string, err error) {- defer c.mu.Unlock()- c.mu.Lock()- if c.v != "" {- return c.v, nil- }- if c.trim {- v, err = getTrimmed(c.k)- } else {- v, err = Get(c.k)- }- if err == nil {- c.v = v- }- return-}--var (- onGCEOnce sync.Once- onGCE bool-)--// OnGCE reports whether this process is running on Google Compute Engine.-func OnGCE() bool {- onGCEOnce.Do(initOnGCE)- return onGCE-}--func initOnGCE() {- onGCE = testOnGCE()-}--func testOnGCE() bool {- // The user explicitly said they're on GCE, so trust them.- if os.Getenv(metadataHostEnv) != "" {- return true- }-- ctx, cancel := context.WithCancel(context.Background())- defer cancel()-- resc := make(chan bool, 2)-- // Try two strategies in parallel.- // See https://github.com/GoogleCloudPlatform/google-cloud-go/issues/194- go func() {- req, _ := http.NewRequest("GET", "http://"+metadataIP, nil)- req.Header.Set("User-Agent", userAgent)- res, err := ctxhttp.Do(ctx, metaClient, req)- if err != nil {- resc <- false- return- }- defer res.Body.Close()- resc <- res.Header.Get("Metadata-Flavor") == "Google"- }()-- go func() {- addrs, err := net.LookupHost("metadata.google.internal")- if err != nil || len(addrs) == 0 {- resc <- false- return- }- resc <- strsContains(addrs, metadataIP)- }()-- tryHarder := systemInfoSuggestsGCE()- if tryHarder {- res := <-resc- if res {- // The first strategy succeeded, so let's use it.- return true- }- // Wait for either the DNS or metadata server probe to- // contradict the other one and say we are running on- // GCE. Give it a lot of time to do so, since the system- // info already suggests we're running on a GCE BIOS.- timer := time.NewTimer(5 * time.Second)- defer timer.Stop()- select {- case res = <-resc:- return res- case <-timer.C:- // Too slow. Who knows what this system is.- return false- }- }-- // There's no hint from the system info that we're running on- // GCE, so use the first probe's result as truth, whether it's- // true or false. The goal here is to optimize for speed for- // users who are NOT running on GCE. We can't assume that- // either a DNS lookup or an HTTP request to a blackholed IP- // address is fast. Worst case this should return when the- // metaClient's Transport.ResponseHeaderTimeout or- // Transport.Dial.Timeout fires (in two seconds).- return <-resc-}--// systemInfoSuggestsGCE reports whether the local system (without-// doing network requests) suggests that we're running on GCE. If this-// returns true, testOnGCE tries a bit harder to reach its metadata-// server.-func systemInfoSuggestsGCE() bool {- if runtime.GOOS != "linux" {- // We don't have any non-Linux clues available, at least yet.- return false- }- slurp, _ := ioutil.ReadFile("/sys/class/dmi/id/product_name")- name := strings.TrimSpace(string(slurp))- return name == "Google" || name == "Google Compute Engine"-}--// Subscribe subscribes to a value from the metadata service.-// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".-// The suffix may contain query parameters.-//-// Subscribe calls fn with the latest metadata value indicated by the provided-// suffix. If the metadata value is deleted, fn is called with the empty string-// and ok false. Subscribe blocks until fn returns a non-nil error or the value-// is deleted. Subscribe returns the error value returned from the last call to-// fn, which may be nil when ok == false.-func Subscribe(suffix string, fn func(v string, ok bool) error) error {- const failedSubscribeSleep = time.Second * 5-- // First check to see if the metadata value exists at all.- val, lastETag, err := getETag(subscribeClient, suffix)- if err != nil {- return err- }-- if err := fn(val, true); err != nil {- return err- }-- ok := true- if strings.ContainsRune(suffix, '?') {- suffix += "&wait_for_change=true&last_etag="- } else {- suffix += "?wait_for_change=true&last_etag="- }- for {- val, etag, err := getETag(subscribeClient, suffix+url.QueryEscape(lastETag))- if err != nil {- if _, deleted := err.(NotDefinedError); !deleted {- time.Sleep(failedSubscribeSleep)- continue // Retry on other errors.- }- ok = false- }- lastETag = etag-- if err := fn(val, ok); err != nil || !ok {- return err- }- }-}--// ProjectID returns the current instance's project ID string.-func ProjectID() (string, error) { return projID.get() }--// NumericProjectID returns the current instance's numeric project ID.-func NumericProjectID() (string, error) { return projNum.get() }--// InternalIP returns the instance's primary internal IP address.-func InternalIP() (string, error) {- return getTrimmed("instance/network-interfaces/0/ip")-}--// ExternalIP returns the instance's primary external (public) IP address.-func ExternalIP() (string, error) {- return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")-}--// Hostname returns the instance's hostname. This will be of the form-// "<instanceID>.c.<projID>.internal".-func Hostname() (string, error) {- return getTrimmed("instance/hostname")-}--// InstanceTags returns the list of user-defined instance tags,-// assigned when initially creating a GCE instance.-func InstanceTags() ([]string, error) {- var s []string- j, err := Get("instance/tags")- if err != nil {- return nil, err- }- if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {- return nil, err- }- return s, nil-}--// InstanceID returns the current VM's numeric instance ID.-func InstanceID() (string, error) {- return instID.get()-}--// InstanceName returns the current VM's instance ID string.-func InstanceName() (string, error) {- host, err := Hostname()- if err != nil {- return "", err- }- return strings.Split(host, ".")[0], nil-}--// Zone returns the current VM's zone, such as "us-central1-b".-func Zone() (string, error) {- zone, err := getTrimmed("instance/zone")- // zone is of the form "projects/<projNum>/zones/<zoneName>".- if err != nil {- return "", err- }- return zone[strings.LastIndex(zone, "/")+1:], nil-}--// InstanceAttributes returns the list of user-defined attributes,-// assigned when initially creating a GCE VM instance. The value of an-// attribute can be obtained with InstanceAttributeValue.-func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") }--// ProjectAttributes returns the list of user-defined attributes-// applying to the project as a whole, not just this VM. The value of-// an attribute can be obtained with ProjectAttributeValue.-func ProjectAttributes() ([]string, error) { return lines("project/attributes/") }--func lines(suffix string) ([]string, error) {- j, err := Get(suffix)- if err != nil {- return nil, err- }- s := strings.Split(strings.TrimSpace(j), "\n")- for i := range s {- s[i] = strings.TrimSpace(s[i])- }- return s, nil-}--// InstanceAttributeValue returns the value of the provided VM-// instance attribute.-//-// If the requested attribute is not defined, the returned error will-// be of type NotDefinedError.-//-// InstanceAttributeValue may return ("", nil) if the attribute was-// defined to be the empty string.-func InstanceAttributeValue(attr string) (string, error) {- return Get("instance/attributes/" + attr)-}--// ProjectAttributeValue returns the value of the provided-// project attribute.-//-// If the requested attribute is not defined, the returned error will-// be of type NotDefinedError.-//-// ProjectAttributeValue may return ("", nil) if the attribute was-// defined to be the empty string.-func ProjectAttributeValue(attr string) (string, error) {- return Get("project/attributes/" + attr)-}--// Scopes returns the service account scopes for the given account.-// The account may be empty or the string "default" to use the instance's-// main account.-func Scopes(serviceAccount string) ([]string, error) {- if serviceAccount == "" {- serviceAccount = "default"- }- return lines("instance/service-accounts/" + serviceAccount + "/scopes")-}--func strsContains(ss []string, s string) bool {- for _, v := range ss {- if v == s {- return true- }- }- return false-}diff --git a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.go b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.goindex a15f496bc..ab69c7a6f 100644--- a/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.go+++ b/vendor/github.com/aws/aws-sdk-go/aws/corehandlers/user_agent.go@@ -17,7 +17,7 @@ var SDKVersionUserAgentHandler = request.NamedHandler{}const execEnvVar = `AWS_EXECUTION_ENV`-const execEnvUAKey = `exec_env`+const execEnvUAKey = `exec-env`// AddHostExecEnvUserAgentHander is a request handler appending the SDK's// execution environment to the user agent.diff --git a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.goindex c3bbaa0cd..6368c78ad 100644--- a/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go+++ b/vendor/github.com/aws/aws-sdk-go/aws/endpoints/defaults.go@@ -349,10 +349,18 @@ var awsPartition = partition{},},Endpoints: endpoints{+ "ap-northeast-1": endpoint{},+ "ap-northeast-2": endpoint{},+ "ap-south-1": endpoint{},"ap-southeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "ca-central-1": endpoint{},+ "eu-central-1": endpoint{},"eu-west-1": endpoint{},+ "eu-west-2": endpoint{},"us-east-1": endpoint{},"us-east-2": endpoint{},+ "us-west-1": endpoint{},"us-west-2": endpoint{},},},@@ -368,6 +376,7 @@ var awsPartition = partition{"eu-central-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},+ "eu-west-3": endpoint{},"sa-east-1": endpoint{},"us-east-1": endpoint{},"us-east-2": endpoint{},@@ -506,6 +515,7 @@ var awsPartition = partition{"ap-southeast-2": endpoint{},"ca-central-1": endpoint{},"eu-central-1": endpoint{},+ "eu-north-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},"eu-west-3": endpoint{},@@ -1032,6 +1042,7 @@ var awsPartition = partition{"ap-southeast-2": endpoint{},"ca-central-1": endpoint{},"eu-central-1": endpoint{},+ "eu-north-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},"eu-west-3": endpoint{},@@ -1206,9 +1217,13 @@ var awsPartition = partition{Protocols: []string{"https"},},Endpoints: endpoints{- "eu-west-1": endpoint{},- "us-east-1": endpoint{},- "us-west-2": endpoint{},+ "ap-northeast-1": endpoint{},+ "ap-southeast-2": endpoint{},+ "eu-central-1": endpoint{},+ "eu-west-1": endpoint{},+ "us-east-1": endpoint{},+ "us-east-2": endpoint{},+ "us-west-2": endpoint{},},},"gamelift": service{@@ -1267,6 +1282,7 @@ var awsPartition = partition{"eu-west-2": endpoint{},"us-east-1": endpoint{},"us-east-2": endpoint{},+ "us-west-1": endpoint{},"us-west-2": endpoint{},},},@@ -1414,6 +1430,7 @@ var awsPartition = partition{"eu-central-1": endpoint{},"eu-west-1": endpoint{},"us-east-1": endpoint{},+ "us-east-2": endpoint{},"us-west-2": endpoint{},},},@@ -1598,6 +1615,7 @@ var awsPartition = partition{"ap-southeast-2": endpoint{},"ca-central-1": endpoint{},"eu-central-1": endpoint{},+ "eu-north-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},"eu-west-3": endpoint{},@@ -1668,6 +1686,12 @@ var awsPartition = partition{"neptune": service{Endpoints: endpoints{+ "ap-southeast-1": endpoint{+ Hostname: "rds.ap-southeast-1.amazonaws.com",+ CredentialScope: credentialScope{+ Region: "ap-southeast-1",+ },+ },"eu-central-1": endpoint{Hostname: "rds.eu-central-1.amazonaws.com",CredentialScope: credentialScope{@@ -1850,6 +1874,7 @@ var awsPartition = partition{"ap-southeast-2": endpoint{},"ca-central-1": endpoint{},"eu-central-1": endpoint{},+ "eu-north-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},"eu-west-3": endpoint{},@@ -2306,7 +2331,7 @@ var awsPartition = partition{"shield": service{IsRegionalized: boxedFalse,Defaults: endpoint{- SSLCommonName: "Shield.us-east-1.amazonaws.com",+ SSLCommonName: "shield.us-east-1.amazonaws.com",Protocols: []string{"https"},},Endpoints: endpoints{@@ -2459,6 +2484,8 @@ var awsPartition = partition{"eu-north-1": endpoint{},"eu-west-1": endpoint{},"eu-west-2": endpoint{},+ "eu-west-3": endpoint{},+ "sa-east-1": endpoint{},"us-east-1": endpoint{},"us-east-2": endpoint{},"us-west-1": endpoint{},@@ -3253,6 +3280,7 @@ var awsusgovPartition = partition{},},Endpoints: endpoints{+ "us-gov-east-1": endpoint{},"us-gov-west-1": endpoint{},},},@@ -3303,6 +3331,12 @@ var awsusgovPartition = partition{"us-gov-west-1": endpoint{},},},+ "ds": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },"dynamodb": service{Endpoints: endpoints{@@ -3368,6 +3402,12 @@ var awsusgovPartition = partition{"us-gov-west-1": endpoint{},},},+ "elasticfilesystem": service{++ Endpoints: endpoints{+ "us-gov-west-1": endpoint{},+ },+ },"elasticloadbalancing": service{Endpoints: endpoints{@@ -3592,6 +3632,7 @@ var awsusgovPartition = partition{"snowball": service{Endpoints: endpoints{+ "us-gov-east-1": endpoint{},"us-gov-west-1": endpoint{},},},diff --git a/vendor/github.com/aws/aws-sdk-go/aws/version.go b/vendor/github.com/aws/aws-sdk-go/aws/version.goindex 8ab57837b..e1380cb16 100644--- a/vendor/github.com/aws/aws-sdk-go/aws/version.go+++ b/vendor/github.com/aws/aws-sdk-go/aws/version.go@@ -5,4 +5,4 @@ package awsconst SDKName = "aws-sdk-go"// SDKVersion is the version of this SDK-const SDKVersion = "1.16.3"+const SDKVersion = "1.16.11"diff --git a/vendor/github.com/golang/protobuf/LICENSE b/vendor/github.com/golang/protobuf/LICENSEindex 1b1b1921e..0f646931a 100644--- a/vendor/github.com/golang/protobuf/LICENSE+++ b/vendor/github.com/golang/protobuf/LICENSE@@ -1,7 +1,4 @@-Go support for Protocol Buffers - Google's data interchange format-Copyright 2010 The Go Authors. All rights reserved.-https://github.com/golang/protobufRedistribution and use in source and binary forms, with or withoutmodification, are permitted provided that the following conditions arediff --git a/vendor/github.com/golang/protobuf/proto/Makefile b/vendor/github.com/golang/protobuf/proto/Makefiledeleted file mode 100644index e2e0651a9..000000000--- a/vendor/github.com/golang/protobuf/proto/Makefile+++ /dev/null@@ -1,43 +0,0 @@-# Go support for Protocol Buffers - Google's data interchange format-#-# Copyright 2010 The Go Authors. All rights reserved.-# https://github.com/golang/protobuf-#-# Redistribution and use in source and binary forms, with or without-# modification, are permitted provided that the following conditions are-# met:-#-# * Redistributions of source code must retain the above copyright-# notice, this list of conditions and the following disclaimer.-# * Redistributions in binary form must reproduce the above-# copyright notice, this list of conditions and the following disclaimer-# in the documentation and/or other materials provided with the-# distribution.-# * Neither the name of Google Inc. nor the names of its-# contributors may be used to endorse or promote products derived from-# this software without specific prior written permission.-#-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.--install:- go install--test: install generate-test-pbs- go test---generate-test-pbs:- make install- make -C testdata- protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto- makediff --git a/vendor/github.com/golang/protobuf/proto/clone.go b/vendor/github.com/golang/protobuf/proto/clone.goindex e392575b3..3cd3249f7 100644--- a/vendor/github.com/golang/protobuf/proto/clone.go+++ b/vendor/github.com/golang/protobuf/proto/clone.go@@ -35,22 +35,39 @@package protoimport (+ "fmt""log""reflect""strings")// Clone returns a deep copy of a protocol buffer.-func Clone(pb Message) Message {- in := reflect.ValueOf(pb)+func Clone(src Message) Message {+ in := reflect.ValueOf(src)if in.IsNil() {- return pb+ return src}-out := reflect.New(in.Type().Elem())- // out is empty so a merge is a deep copy.- mergeStruct(out.Elem(), in.Elem())- return out.Interface().(Message)+ dst := out.Interface().(Message)+ Merge(dst, src)+ return dst+}++// Merger is the interface representing objects that can merge messages of the same type.+type Merger interface {+ // Merge merges src into this message.+ // Required and optional fields that are set in src will be set to that value in dst.+ // Elements of repeated fields will be appended.+ //+ // Merge may panic if called with a different argument type than the receiver.+ Merge(src Message)+}++// generatedMerger is the custom merge method that generated protos will have.+// We must add this method since a generate Merge method will conflict with+// many existing protos that have a Merge data field already defined.+type generatedMerger interface {+ XXX_Merge(src Message)}// Merge merges src into dst.@@ -58,17 +75,24 @@ func Clone(pb Message) Message {// Elements of repeated fields will be appended.// Merge panics if src and dst are not the same type, or if dst is nil.func Merge(dst, src Message) {+ if m, ok := dst.(Merger); ok {+ m.Merge(src)+ return+ }+in := reflect.ValueOf(src)out := reflect.ValueOf(dst)if out.IsNil() {panic("proto: nil destination")}if in.Type() != out.Type() {- // Explicit test prior to mergeStruct so that mistyped nils will fail- panic("proto: type mismatch")+ panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src))}if in.IsNil() {- // Merging nil into non-nil is a quiet no-op+ return // Merge from nil src is a noop+ }+ if m, ok := dst.(generatedMerger); ok {+ m.XXX_Merge(src)return}mergeStruct(out.Elem(), in.Elem())@@ -84,7 +108,7 @@ func mergeStruct(out, in reflect.Value) {mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i])}- if emIn, ok := extendable(in.Addr().Interface()); ok {+ if emIn, err := extendable(in.Addr().Interface()); err == nil {emOut, _ := extendable(out.Addr().Interface())mIn, muIn := emIn.extensionsRead()if mIn != nil {diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.goindex aa207298f..d9aa3c42d 100644--- a/vendor/github.com/golang/protobuf/proto/decode.go+++ b/vendor/github.com/golang/protobuf/proto/decode.go@@ -39,8 +39,6 @@ import ("errors""fmt""io"- "os"- "reflect")// errOverflow is returned when an integer is too large to be represented.@@ -50,10 +48,6 @@ var errOverflow = errors.New("proto: integer overflow")// wire type is encountered. It does not get returned to user code.var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")-// The fundamental decoders that interpret bytes on the wire.-// Those that take integer types all return uint64 and are-// therefore of type valueDecoder.-// DecodeVarint reads a varint-encoded integer from the slice.// It returns the integer and the number of bytes consumed, or// zero if there is not enough.@@ -267,9 +261,6 @@ func (p *Buffer) DecodeZigzag32() (x uint64, err error) {return}-// These are not ValueDecoders: they produce an array of bytes or a string.-// bytes, embedded messages-// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.// This is the format used for the bytes protocol buffer// type and for embedded messages.@@ -311,81 +302,29 @@ func (p *Buffer) DecodeStringBytes() (s string, err error) {return string(buf), nil}-// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.-// If the protocol buffer has extensions, and the field matches, add it as an extension.-// Otherwise, if the XXX_unrecognized field exists, append the skipped data there.-func (o *Buffer) skipAndSave(t reflect.Type, tag, wire int, base structPointer, unrecField field) error {- oi := o.index-- err := o.skip(t, tag, wire)- if err != nil {- return err- }-- if !unrecField.IsValid() {- return nil- }-- ptr := structPointer_Bytes(base, unrecField)-- // Add the skipped field to struct field- obuf := o.buf-- o.buf = *ptr- o.EncodeVarint(uint64(tag<<3 | wire))- *ptr = append(o.buf, obuf[oi:o.index]...)-- o.buf = obuf-- return nil-}--// Skip the next item in the buffer. Its wire type is decoded and presented as an argument.-func (o *Buffer) skip(t reflect.Type, tag, wire int) error {-- var u uint64- var err error-- switch wire {- case WireVarint:- _, err = o.DecodeVarint()- case WireFixed64:- _, err = o.DecodeFixed64()- case WireBytes:- _, err = o.DecodeRawBytes(false)- case WireFixed32:- _, err = o.DecodeFixed32()- case WireStartGroup:- for {- u, err = o.DecodeVarint()- if err != nil {- break- }- fwire := int(u & 0x7)- if fwire == WireEndGroup {- break- }- ftag := int(u >> 3)- err = o.skip(t, ftag, fwire)- if err != nil {- break- }- }- default:- err = fmt.Errorf("proto: can't skip unknown wire type %d for %s", wire, t)- }- return err-}-// Unmarshaler is the interface representing objects that can-// unmarshal themselves. The method should reset the receiver before-// decoding starts. The argument points to data that may be+// unmarshal themselves. The argument points to data that may be// overwritten, so implementations should not keep references to the// buffer.+// Unmarshal implementations should not clear the receiver.+// Any unmarshaled data should be merged into the receiver.+// Callers of Unmarshal that do not want to retain existing data+// should Reset the receiver before calling Unmarshal.type Unmarshaler interface {Unmarshal([]byte) error}+// newUnmarshaler is the interface representing objects that can+// unmarshal themselves. The semantics are identical to Unmarshaler.+//+// This exists to support protoc-gen-go generated messages.+// The proto package will stop type-asserting to this interface in the future.+//+// DO NOT DEPEND ON THIS.+type newUnmarshaler interface {+ XXX_Unmarshal([]byte) error+}+// Unmarshal parses the protocol buffer representation in buf and places the// decoded result in pb. If the struct underlying pb does not match// the data in buf, the results can be unpredictable.@@ -395,7 +334,13 @@ type Unmarshaler interface {// to preserve and append to existing data.func Unmarshal(buf []byte, pb Message) error {pb.Reset()- return UnmarshalMerge(buf, pb)+ if u, ok := pb.(newUnmarshaler); ok {+ return u.XXX_Unmarshal(buf)+ }+ if u, ok := pb.(Unmarshaler); ok {+ return u.Unmarshal(buf)+ }+ return NewBuffer(buf).Unmarshal(pb)}// UnmarshalMerge parses the protocol buffer representation in buf and@@ -405,8 +350,16 @@ func Unmarshal(buf []byte, pb Message) error {// UnmarshalMerge merges into existing data in pb.// Most code should use Unmarshal instead.func UnmarshalMerge(buf []byte, pb Message) error {- // If the object can unmarshal itself, let it.+ if u, ok := pb.(newUnmarshaler); ok {+ return u.XXX_Unmarshal(buf)+ }if u, ok := pb.(Unmarshaler); ok {+ // NOTE: The history of proto have unfortunately been inconsistent+ // whether Unmarshaler should or should not implicitly clear itself.+ // Some implementations do, most do not.+ // Thus, calling this here may or may not do what people want.+ //+ // See https://github.com/golang/protobuf/issues/424return u.Unmarshal(buf)}return NewBuffer(buf).Unmarshal(pb)@@ -422,12 +375,17 @@ func (p *Buffer) DecodeMessage(pb Message) error {}// DecodeGroup reads a tag-delimited group from the Buffer.+// StartGroup tag is already consumed. This function consumes+// EndGroup tag.func (p *Buffer) DecodeGroup(pb Message) error {- typ, base, err := getbase(pb)- if err != nil {- return err+ b := p.buf[p.index:]+ x, y := findEndGroup(b)+ if x < 0 {+ return io.ErrUnexpectedEOF}- return p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), true, base)+ err := Unmarshal(b[:x], pb)+ p.index += y+ return err}// Unmarshal parses the protocol buffer representation in the@@ -438,533 +396,33 @@ func (p *Buffer) DecodeGroup(pb Message) error {// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.func (p *Buffer) Unmarshal(pb Message) error {// If the object can unmarshal itself, let it.- if u, ok := pb.(Unmarshaler); ok {- err := u.Unmarshal(p.buf[p.index:])+ if u, ok := pb.(newUnmarshaler); ok {+ err := u.XXX_Unmarshal(p.buf[p.index:])p.index = len(p.buf)return err}-- typ, base, err := getbase(pb)- if err != nil {- return err- }-- err = p.unmarshalType(typ.Elem(), GetProperties(typ.Elem()), false, base)-- if collectStats {- stats.Decode++- }-- return err-}--// unmarshalType does the work of unmarshaling a structure.-func (o *Buffer) unmarshalType(st reflect.Type, prop *StructProperties, is_group bool, base structPointer) error {- var state errorState- required, reqFields := prop.reqCount, uint64(0)-- var err error- for err == nil && o.index < len(o.buf) {- oi := o.index- var u uint64- u, err = o.DecodeVarint()- if err != nil {- break- }- wire := int(u & 0x7)- if wire == WireEndGroup {- if is_group {- if required > 0 {- // Not enough information to determine the exact field.- // (See below.)- return &RequiredNotSetError{"{Unknown}"}- }- return nil // input is satisfied- }- return fmt.Errorf("proto: %s: wiretype end group for non-group", st)- }- tag := int(u >> 3)- if tag <= 0 {- return fmt.Errorf("proto: %s: illegal tag %d (wire type %d)", st, tag, wire)- }- fieldnum, ok := prop.decoderTags.get(tag)- if !ok {- // Maybe it's an extension?- if prop.extendable {- if e, _ := extendable(structPointer_Interface(base, st)); isExtensionField(e, int32(tag)) {- if err = o.skip(st, tag, wire); err == nil {- extmap := e.extensionsWrite()- ext := extmap[int32(tag)] // may be missing- ext.enc = append(ext.enc, o.buf[oi:o.index]...)- extmap[int32(tag)] = ext- }- continue- }- }- // Maybe it's a oneof?- if prop.oneofUnmarshaler != nil {- m := structPointer_Interface(base, st).(Message)- // First return value indicates whether tag is a oneof field.- ok, err = prop.oneofUnmarshaler(m, tag, wire, o)- if err == ErrInternalBadWireType {- // Map the error to something more descriptive.- // Do the formatting here to save generated code space.- err = fmt.Errorf("bad wiretype for oneof field in %T", m)- }- if ok {- continue- }- }- err = o.skipAndSave(st, tag, wire, base, prop.unrecField)- continue- }- p := prop.Prop[fieldnum]-- if p.dec == nil {- fmt.Fprintf(os.Stderr, "proto: no protobuf decoder for %s.%s\n", st, st.Field(fieldnum).Name)- continue- }- dec := p.dec- if wire != WireStartGroup && wire != p.WireType {- if wire == WireBytes && p.packedDec != nil {- // a packable field- dec = p.packedDec- } else {- err = fmt.Errorf("proto: bad wiretype for field %s.%s: got wiretype %d, want %d", st, st.Field(fieldnum).Name, wire, p.WireType)- continue- }- }- decErr := dec(o, p, base)- if decErr != nil && !state.shouldContinue(decErr, p) {- err = decErr- }- if err == nil && p.Required {- // Successfully decoded a required field.- if tag <= 64 {- // use bitmap for fields 1-64 to catch field reuse.- var mask uint64 = 1 << uint64(tag-1)- if reqFields&mask == 0 {- // new required field- reqFields |= mask- required--- }- } else {- // This is imprecise. It can be fooled by a required field- // with a tag > 64 that is encoded twice; that's very rare.- // A fully correct implementation would require allocating- // a data structure, which we would like to avoid.- required--- }- }- }- if err == nil {- if is_group {- return io.ErrUnexpectedEOF- }- if state.err != nil {- return state.err- }- if required > 0 {- // Not enough information to determine the exact field. If we use extra- // CPU, we could determine the field only if the missing required field- // has a tag <= 64 and we check reqFields.- return &RequiredNotSetError{"{Unknown}"}- }- }- return err-}--// Individual type decoders-// For each,-// u is the decoded value,-// v is a pointer to the field (pointer) in the struct--// Sizes of the pools to allocate inside the Buffer.-// The goal is modest amortization and allocation-// on at least 16-byte boundaries.-const (- boolPoolSize = 16- uint32PoolSize = 8- uint64PoolSize = 4-)--// Decode a bool.-func (o *Buffer) dec_bool(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- if len(o.bools) == 0 {- o.bools = make([]bool, boolPoolSize)- }- o.bools[0] = u != 0- *structPointer_Bool(base, p.field) = &o.bools[0]- o.bools = o.bools[1:]- return nil-}--func (o *Buffer) dec_proto3_bool(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- *structPointer_BoolVal(base, p.field) = u != 0- return nil-}--// Decode an int32.-func (o *Buffer) dec_int32(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- word32_Set(structPointer_Word32(base, p.field), o, uint32(u))- return nil-}--func (o *Buffer) dec_proto3_int32(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- word32Val_Set(structPointer_Word32Val(base, p.field), uint32(u))- return nil-}--// Decode an int64.-func (o *Buffer) dec_int64(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- word64_Set(structPointer_Word64(base, p.field), o, u)- return nil-}--func (o *Buffer) dec_proto3_int64(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- word64Val_Set(structPointer_Word64Val(base, p.field), o, u)- return nil-}--// Decode a string.-func (o *Buffer) dec_string(p *Properties, base structPointer) error {- s, err := o.DecodeStringBytes()- if err != nil {- return err- }- *structPointer_String(base, p.field) = &s- return nil-}--func (o *Buffer) dec_proto3_string(p *Properties, base structPointer) error {- s, err := o.DecodeStringBytes()- if err != nil {- return err- }- *structPointer_StringVal(base, p.field) = s- return nil-}--// Decode a slice of bytes ([]byte).-func (o *Buffer) dec_slice_byte(p *Properties, base structPointer) error {- b, err := o.DecodeRawBytes(true)- if err != nil {- return err- }- *structPointer_Bytes(base, p.field) = b- return nil-}--// Decode a slice of bools ([]bool).-func (o *Buffer) dec_slice_bool(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- v := structPointer_BoolSlice(base, p.field)- *v = append(*v, u != 0)- return nil-}--// Decode a slice of bools ([]bool) in packed format.-func (o *Buffer) dec_slice_packed_bool(p *Properties, base structPointer) error {- v := structPointer_BoolSlice(base, p.field)-- nn, err := o.DecodeVarint()- if err != nil {- return err- }- nb := int(nn) // number of bytes of encoded bools- fin := o.index + nb- if fin < o.index {- return errOverflow- }-- y := *v- for o.index < fin {- u, err := p.valDec(o)- if err != nil {- return err- }- y = append(y, u != 0)- }-- *v = y- return nil-}--// Decode a slice of int32s ([]int32).-func (o *Buffer) dec_slice_int32(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }- structPointer_Word32Slice(base, p.field).Append(uint32(u))- return nil-}--// Decode a slice of int32s ([]int32) in packed format.-func (o *Buffer) dec_slice_packed_int32(p *Properties, base structPointer) error {- v := structPointer_Word32Slice(base, p.field)-- nn, err := o.DecodeVarint()- if err != nil {- return err- }- nb := int(nn) // number of bytes of encoded int32s-- fin := o.index + nb- if fin < o.index {- return errOverflow- }- for o.index < fin {- u, err := p.valDec(o)- if err != nil {- return err- }- v.Append(uint32(u))- }- return nil-}--// Decode a slice of int64s ([]int64).-func (o *Buffer) dec_slice_int64(p *Properties, base structPointer) error {- u, err := p.valDec(o)- if err != nil {- return err- }-- structPointer_Word64Slice(base, p.field).Append(u)- return nil-}--// Decode a slice of int64s ([]int64) in packed format.-func (o *Buffer) dec_slice_packed_int64(p *Properties, base structPointer) error {- v := structPointer_Word64Slice(base, p.field)-- nn, err := o.DecodeVarint()- if err != nil {- return err- }- nb := int(nn) // number of bytes of encoded int64s-- fin := o.index + nb- if fin < o.index {- return errOverflow- }- for o.index < fin {- u, err := p.valDec(o)- if err != nil {- return err- }- v.Append(u)- }- return nil-}--// Decode a slice of strings ([]string).-func (o *Buffer) dec_slice_string(p *Properties, base structPointer) error {- s, err := o.DecodeStringBytes()- if err != nil {- return err- }- v := structPointer_StringSlice(base, p.field)- *v = append(*v, s)- return nil-}--// Decode a slice of slice of bytes ([][]byte).-func (o *Buffer) dec_slice_slice_byte(p *Properties, base structPointer) error {- b, err := o.DecodeRawBytes(true)- if err != nil {- return err- }- v := structPointer_BytesSlice(base, p.field)- *v = append(*v, b)- return nil-}--// Decode a map field.-func (o *Buffer) dec_new_map(p *Properties, base structPointer) error {- raw, err := o.DecodeRawBytes(false)- if err != nil {- return err- }- oi := o.index // index at the end of this map entry- o.index -= len(raw) // move buffer back to start of map entry-- mptr := structPointer_NewAt(base, p.field, p.mtype) // *map[K]V- if mptr.Elem().IsNil() {- mptr.Elem().Set(reflect.MakeMap(mptr.Type().Elem()))- }- v := mptr.Elem() // map[K]V-- // Prepare addressable doubly-indirect placeholders for the key and value types.- // See enc_new_map for why.- keyptr := reflect.New(reflect.PtrTo(p.mtype.Key())).Elem() // addressable *K- keybase := toStructPointer(keyptr.Addr()) // **K-- var valbase structPointer- var valptr reflect.Value- switch p.mtype.Elem().Kind() {- case reflect.Slice:- // []byte- var dummy []byte- valptr = reflect.ValueOf(&dummy) // *[]byte- valbase = toStructPointer(valptr) // *[]byte- case reflect.Ptr:- // message; valptr is **Msg; need to allocate the intermediate pointer- valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V- valptr.Set(reflect.New(valptr.Type().Elem()))- valbase = toStructPointer(valptr)- default:- // everything else- valptr = reflect.New(reflect.PtrTo(p.mtype.Elem())).Elem() // addressable *V- valbase = toStructPointer(valptr.Addr()) // **V- }-- // Decode.- // This parses a restricted wire format, namely the encoding of a message- // with two fields. See enc_new_map for the format.- for o.index < oi {- // tagcode for key and value properties are always a single byte- // because they have tags 1 and 2.- tagcode := o.buf[o.index]- o.index++- switch tagcode {- case p.mkeyprop.tagcode[0]:- if err := p.mkeyprop.dec(o, p.mkeyprop, keybase); err != nil {- return err- }- case p.mvalprop.tagcode[0]:- if err := p.mvalprop.dec(o, p.mvalprop, valbase); err != nil {- return err- }- default:- // TODO: Should we silently skip this instead?- return fmt.Errorf("proto: bad map data tag %d", raw[0])- }- }- keyelem, valelem := keyptr.Elem(), valptr.Elem()- if !keyelem.IsValid() {- keyelem = reflect.Zero(p.mtype.Key())- }- if !valelem.IsValid() {- valelem = reflect.Zero(p.mtype.Elem())- }-- v.SetMapIndex(keyelem, valelem)- return nil-}--// Decode a group.-func (o *Buffer) dec_struct_group(p *Properties, base structPointer) error {- bas := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(bas) {- // allocate new nested message- bas = toStructPointer(reflect.New(p.stype))- structPointer_SetStructPointer(base, p.field, bas)- }- return o.unmarshalType(p.stype, p.sprop, true, bas)-}--// Decode an embedded message.-func (o *Buffer) dec_struct_message(p *Properties, base structPointer) (err error) {- raw, e := o.DecodeRawBytes(false)- if e != nil {- return e- }-- bas := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(bas) {- // allocate new nested message- bas = toStructPointer(reflect.New(p.stype))- structPointer_SetStructPointer(base, p.field, bas)- }-- // If the object can unmarshal itself, let it.- if p.isUnmarshaler {- iv := structPointer_Interface(bas, p.stype)- return iv.(Unmarshaler).Unmarshal(raw)- }-- obuf := o.buf- oi := o.index- o.buf = raw- o.index = 0-- err = o.unmarshalType(p.stype, p.sprop, false, bas)- o.buf = obuf- o.index = oi-- return err-}--// Decode a slice of embedded messages.-func (o *Buffer) dec_slice_struct_message(p *Properties, base structPointer) error {- return o.dec_slice_struct(p, false, base)-}--// Decode a slice of embedded groups.-func (o *Buffer) dec_slice_struct_group(p *Properties, base structPointer) error {- return o.dec_slice_struct(p, true, base)-}--// Decode a slice of structs ([]*struct).-func (o *Buffer) dec_slice_struct(p *Properties, is_group bool, base structPointer) error {- v := reflect.New(p.stype)- bas := toStructPointer(v)- structPointer_StructPointerSlice(base, p.field).Append(bas)-- if is_group {- err := o.unmarshalType(p.stype, p.sprop, is_group, bas)- return err- }-- raw, err := o.DecodeRawBytes(false)- if err != nil {+ if u, ok := pb.(Unmarshaler); ok {+ // NOTE: The history of proto have unfortunately been inconsistent+ // whether Unmarshaler should or should not implicitly clear itself.+ // Some implementations do, most do not.+ // Thus, calling this here may or may not do what people want.+ //+ // See https://github.com/golang/protobuf/issues/424+ err := u.Unmarshal(p.buf[p.index:])+ p.index = len(p.buf)return err}- // If the object can unmarshal itself, let it.- if p.isUnmarshaler {- iv := v.Interface()- return iv.(Unmarshaler).Unmarshal(raw)- }-- obuf := o.buf- oi := o.index- o.buf = raw- o.index = 0-- err = o.unmarshalType(p.stype, p.sprop, is_group, bas)-- o.buf = obuf- o.index = oi-+ // Slow workaround for messages that aren't Unmarshalers.+ // This includes some hand-coded .pb.go files and+ // bootstrap protos.+ // TODO: fix all of those and then add Unmarshal to+ // the Message interface. Then:+ // The cast above and code below can be deleted.+ // The old unmarshaler can be deleted.+ // Clients can call Unmarshal directly (can already do that, actually).+ var info InternalMessageInfo+ err := info.Unmarshal(pb, p.buf[p.index:])+ p.index = len(p.buf)return err}diff --git a/vendor/github.com/golang/protobuf/proto/discard.go b/vendor/github.com/golang/protobuf/proto/discard.gonew file mode 100644index 000000000..dea2617ce--- /dev/null+++ b/vendor/github.com/golang/protobuf/proto/discard.go@@ -0,0 +1,350 @@+// Go support for Protocol Buffers - Google's data interchange format+//+// Copyright 2017 The Go Authors. All rights reserved.+// https://github.com/golang/protobuf+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++package proto++import (+ "fmt"+ "reflect"+ "strings"+ "sync"+ "sync/atomic"+)++type generatedDiscarder interface {+ XXX_DiscardUnknown()+}++// DiscardUnknown recursively discards all unknown fields from this message+// and all embedded messages.+//+// When unmarshaling a message with unrecognized fields, the tags and values+// of such fields are preserved in the Message. This allows a later call to+// marshal to be able to produce a message that continues to have those+// unrecognized fields. To avoid this, DiscardUnknown is used to+// explicitly clear the unknown fields after unmarshaling.+//+// For proto2 messages, the unknown fields of message extensions are only+// discarded from messages that have been accessed via GetExtension.+func DiscardUnknown(m Message) {+ if m, ok := m.(generatedDiscarder); ok {+ m.XXX_DiscardUnknown()+ return+ }+ // TODO: Dynamically populate a InternalMessageInfo for legacy messages,+ // but the master branch has no implementation for InternalMessageInfo,+ // so it would be more work to replicate that approach.+ discardLegacy(m)+}++// DiscardUnknown recursively discards all unknown fields.+func (a *InternalMessageInfo) DiscardUnknown(m Message) {+ di := atomicLoadDiscardInfo(&a.discard)+ if di == nil {+ di = getDiscardInfo(reflect.TypeOf(m).Elem())+ atomicStoreDiscardInfo(&a.discard, di)+ }+ di.discard(toPointer(&m))+}++type discardInfo struct {+ typ reflect.Type++ initialized int32 // 0: only typ is valid, 1: everything is valid+ lock sync.Mutex++ fields []discardFieldInfo+ unrecognized field+}++type discardFieldInfo struct {+ field field // Offset of field, guaranteed to be valid+ discard func(src pointer)+}++var (+ discardInfoMap = map[reflect.Type]*discardInfo{}+ discardInfoLock sync.Mutex+)++func getDiscardInfo(t reflect.Type) *discardInfo {+ discardInfoLock.Lock()+ defer discardInfoLock.Unlock()+ di := discardInfoMap[t]+ if di == nil {+ di = &discardInfo{typ: t}+ discardInfoMap[t] = di+ }+ return di+}++func (di *discardInfo) discard(src pointer) {+ if src.isNil() {+ return // Nothing to do.+ }++ if atomic.LoadInt32(&di.initialized) == 0 {+ di.computeDiscardInfo()+ }++ for _, fi := range di.fields {+ sfp := src.offset(fi.field)+ fi.discard(sfp)+ }++ // For proto2 messages, only discard unknown fields in message extensions+ // that have been accessed via GetExtension.+ if em, err := extendable(src.asPointerTo(di.typ).Interface()); err == nil {+ // Ignore lock since DiscardUnknown is not concurrency safe.+ emm, _ := em.extensionsRead()+ for _, mx := range emm {+ if m, ok := mx.value.(Message); ok {+ DiscardUnknown(m)+ }+ }+ }++ if di.unrecognized.IsValid() {+ *src.offset(di.unrecognized).toBytes() = nil+ }+}++func (di *discardInfo) computeDiscardInfo() {+ di.lock.Lock()+ defer di.lock.Unlock()+ if di.initialized != 0 {+ return+ }+ t := di.typ+ n := t.NumField()++ for i := 0; i < n; i++ {+ f := t.Field(i)+ if strings.HasPrefix(f.Name, "XXX_") {+ continue+ }++ dfi := discardFieldInfo{field: toField(&f)}+ tf := f.Type++ // Unwrap tf to get its most basic type.+ var isPointer, isSlice bool+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {+ isSlice = true+ tf = tf.Elem()+ }+ if tf.Kind() == reflect.Ptr {+ isPointer = true+ tf = tf.Elem()+ }+ if isPointer && isSlice && tf.Kind() != reflect.Struct {+ panic(fmt.Sprintf("%v.%s cannot be a slice of pointers to primitive types", t, f.Name))+ }++ switch tf.Kind() {+ case reflect.Struct:+ switch {+ case !isPointer:+ panic(fmt.Sprintf("%v.%s cannot be a direct struct value", t, f.Name))+ case isSlice: // E.g., []*pb.T+ di := getDiscardInfo(tf)+ dfi.discard = func(src pointer) {+ sps := src.getPointerSlice()+ for _, sp := range sps {+ if !sp.isNil() {+ di.discard(sp)+ }+ }+ }+ default: // E.g., *pb.T+ di := getDiscardInfo(tf)+ dfi.discard = func(src pointer) {+ sp := src.getPointer()+ if !sp.isNil() {+ di.discard(sp)+ }+ }+ }+ case reflect.Map:+ switch {+ case isPointer || isSlice:+ panic(fmt.Sprintf("%v.%s cannot be a pointer to a map or a slice of map values", t, f.Name))+ default: // E.g., map[K]V+ if tf.Elem().Kind() == reflect.Ptr { // Proto struct (e.g., *T)+ dfi.discard = func(src pointer) {+ sm := src.asPointerTo(tf).Elem()+ if sm.Len() == 0 {+ return+ }+ for _, key := range sm.MapKeys() {+ val := sm.MapIndex(key)+ DiscardUnknown(val.Interface().(Message))+ }+ }+ } else {+ dfi.discard = func(pointer) {} // Noop+ }+ }+ case reflect.Interface:+ // Must be oneof field.+ switch {+ case isPointer || isSlice:+ panic(fmt.Sprintf("%v.%s cannot be a pointer to a interface or a slice of interface values", t, f.Name))+ default: // E.g., interface{}+ // TODO: Make this faster?+ dfi.discard = func(src pointer) {+ su := src.asPointerTo(tf).Elem()+ if !su.IsNil() {+ sv := su.Elem().Elem().Field(0)+ if sv.Kind() == reflect.Ptr && sv.IsNil() {+ return+ }+ switch sv.Type().Kind() {+ case reflect.Ptr: // Proto struct (e.g., *T)+ DiscardUnknown(sv.Interface().(Message))+ }+ }+ }+ }+ default:+ continue+ }+ di.fields = append(di.fields, dfi)+ }++ di.unrecognized = invalidField+ if f, ok := t.FieldByName("XXX_unrecognized"); ok {+ if f.Type != reflect.TypeOf([]byte{}) {+ panic("expected XXX_unrecognized to be of type []byte")+ }+ di.unrecognized = toField(&f)+ }++ atomic.StoreInt32(&di.initialized, 1)+}++func discardLegacy(m Message) {+ v := reflect.ValueOf(m)+ if v.Kind() != reflect.Ptr || v.IsNil() {+ return+ }+ v = v.Elem()+ if v.Kind() != reflect.Struct {+ return+ }+ t := v.Type()++ for i := 0; i < v.NumField(); i++ {+ f := t.Field(i)+ if strings.HasPrefix(f.Name, "XXX_") {+ continue+ }+ vf := v.Field(i)+ tf := f.Type++ // Unwrap tf to get its most basic type.+ var isPointer, isSlice bool+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {+ isSlice = true+ tf = tf.Elem()+ }+ if tf.Kind() == reflect.Ptr {+ isPointer = true+ tf = tf.Elem()+ }+ if isPointer && isSlice && tf.Kind() != reflect.Struct {+ panic(fmt.Sprintf("%T.%s cannot be a slice of pointers to primitive types", m, f.Name))+ }++ switch tf.Kind() {+ case reflect.Struct:+ switch {+ case !isPointer:+ panic(fmt.Sprintf("%T.%s cannot be a direct struct value", m, f.Name))+ case isSlice: // E.g., []*pb.T+ for j := 0; j < vf.Len(); j++ {+ discardLegacy(vf.Index(j).Interface().(Message))+ }+ default: // E.g., *pb.T+ discardLegacy(vf.Interface().(Message))+ }+ case reflect.Map:+ switch {+ case isPointer || isSlice:+ panic(fmt.Sprintf("%T.%s cannot be a pointer to a map or a slice of map values", m, f.Name))+ default: // E.g., map[K]V+ tv := vf.Type().Elem()+ if tv.Kind() == reflect.Ptr && tv.Implements(protoMessageType) { // Proto struct (e.g., *T)+ for _, key := range vf.MapKeys() {+ val := vf.MapIndex(key)+ discardLegacy(val.Interface().(Message))+ }+ }+ }+ case reflect.Interface:+ // Must be oneof field.+ switch {+ case isPointer || isSlice:+ panic(fmt.Sprintf("%T.%s cannot be a pointer to a interface or a slice of interface values", m, f.Name))+ default: // E.g., test_proto.isCommunique_Union interface+ if !vf.IsNil() && f.Tag.Get("protobuf_oneof") != "" {+ vf = vf.Elem() // E.g., *test_proto.Communique_Msg+ if !vf.IsNil() {+ vf = vf.Elem() // E.g., test_proto.Communique_Msg+ vf = vf.Field(0) // E.g., Proto struct (e.g., *T) or primitive value+ if vf.Kind() == reflect.Ptr {+ discardLegacy(vf.Interface().(Message))+ }+ }+ }+ }+ }+ }++ if vf := v.FieldByName("XXX_unrecognized"); vf.IsValid() {+ if vf.Type() != reflect.TypeOf([]byte{}) {+ panic("expected XXX_unrecognized to be of type []byte")+ }+ vf.Set(reflect.ValueOf([]byte(nil)))+ }++ // For proto2 messages, only discard unknown fields in message extensions+ // that have been accessed via GetExtension.+ if em, err := extendable(m); err == nil {+ // Ignore lock since discardLegacy is not concurrency safe.+ emm, _ := em.extensionsRead()+ for _, mx := range emm {+ if m, ok := mx.value.(Message); ok {+ discardLegacy(m)+ }+ }+ }+}diff --git a/vendor/github.com/golang/protobuf/proto/encode.go b/vendor/github.com/golang/protobuf/proto/encode.goindex 8b84d1b22..3abfed2cf 100644--- a/vendor/github.com/golang/protobuf/proto/encode.go+++ b/vendor/github.com/golang/protobuf/proto/encode.go@@ -37,28 +37,9 @@ package protoimport ("errors"- "fmt""reflect"- "sort")-// RequiredNotSetError is the error returned if Marshal is called with-// a protocol buffer struct whose required fields have not-// all been initialized. It is also the error returned if Unmarshal is-// called with an encoded protocol buffer that does not include all the-// required fields.-//-// When printed, RequiredNotSetError reports the first unset required field in a-// message. If the field cannot be precisely determined, it is reported as-// "{Unknown}".-type RequiredNotSetError struct {- field string-}--func (e *RequiredNotSetError) Error() string {- return fmt.Sprintf("proto: required field %q not set", e.field)-}-var (// errRepeatedHasNil is the error returned if Marshal is called with// a struct with a repeated field containing a nil element.@@ -82,10 +63,6 @@ var (const maxVarintBytes = 10 // maximum length of a varint-// maxMarshalSize is the largest allowed size of an encoded protobuf,-// since C++ and Java use signed int32s for the size.-const maxMarshalSize = 1<<31 - 1-// EncodeVarint returns the varint encoding of x.// This is the format for the// int32, int64, uint32, uint64, bool, and enum@@ -119,18 +96,27 @@ func (p *Buffer) EncodeVarint(x uint64) error {// SizeVarint returns the varint encoding size of an integer.func SizeVarint(x uint64) int {- return sizeVarint(x)-}--func sizeVarint(x uint64) (n int) {- for {- n++- x >>= 7- if x == 0 {- break- }- }- return n+ switch {+ case x < 1<<7:+ return 1+ case x < 1<<14:+ return 2+ case x < 1<<21:+ return 3+ case x < 1<<28:+ return 4+ case x < 1<<35:+ return 5+ case x < 1<<42:+ return 6+ case x < 1<<49:+ return 7+ case x < 1<<56:+ return 8+ case x < 1<<63:+ return 9+ }+ return 10}// EncodeFixed64 writes a 64-bit integer to the Buffer.@@ -149,10 +135,6 @@ func (p *Buffer) EncodeFixed64(x uint64) error {return nil}-func sizeFixed64(x uint64) int {- return 8-}-// EncodeFixed32 writes a 32-bit integer to the Buffer.// This is the format for the// fixed32, sfixed32, and float protocol buffer types.@@ -165,20 +147,12 @@ func (p *Buffer) EncodeFixed32(x uint64) error {return nil}-func sizeFixed32(x uint64) int {- return 4-}-// EncodeZigzag64 writes a zigzag-encoded 64-bit integer// to the Buffer.// This is the format used for the sint64 protocol buffer type.func (p *Buffer) EncodeZigzag64(x uint64) error {// use signed number to get arithmetic right shift.- return p.EncodeVarint((x << 1) ^ uint64((int64(x) >> 63)))-}--func sizeZigzag64(x uint64) int {- return sizeVarint((x << 1) ^ uint64((int64(x) >> 63)))+ return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63))))}// EncodeZigzag32 writes a zigzag-encoded 32-bit integer@@ -189,10 +163,6 @@ func (p *Buffer) EncodeZigzag32(x uint64) error {return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))}-func sizeZigzag32(x uint64) int {- return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))-}-// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.// This is the format used for the bytes protocol buffer// type and for embedded messages.@@ -202,11 +172,6 @@ func (p *Buffer) EncodeRawBytes(b []byte) error {return nil}-func sizeRawBytes(b []byte) int {- return sizeVarint(uint64(len(b))) +- len(b)-}-// EncodeStringBytes writes an encoded string to the Buffer.// This is the format used for the proto2 string type.func (p *Buffer) EncodeStringBytes(s string) error {@@ -215,319 +180,17 @@ func (p *Buffer) EncodeStringBytes(s string) error {return nil}-func sizeStringBytes(s string) int {- return sizeVarint(uint64(len(s))) +- len(s)-}-// Marshaler is the interface representing objects that can marshal themselves.type Marshaler interface {Marshal() ([]byte, error)}-// Marshal takes the protocol buffer-// and encodes it into the wire format, returning the data.-func Marshal(pb Message) ([]byte, error) {- // Can the object marshal itself?- if m, ok := pb.(Marshaler); ok {- return m.Marshal()- }- p := NewBuffer(nil)- err := p.Marshal(pb)- if p.buf == nil && err == nil {- // Return a non-nil slice on success.- return []byte{}, nil- }- return p.buf, err-}-// EncodeMessage writes the protocol buffer to the Buffer,// prefixed by a varint-encoded length.func (p *Buffer) EncodeMessage(pb Message) error {- t, base, err := getbase(pb)- if structPointer_IsNil(base) {- return ErrNil- }- if err == nil {- var state errorState- err = p.enc_len_struct(GetProperties(t.Elem()), base, &state)- }- return err-}--// Marshal takes the protocol buffer-// and encodes it into the wire format, writing the result to the-// Buffer.-func (p *Buffer) Marshal(pb Message) error {- // Can the object marshal itself?- if m, ok := pb.(Marshaler); ok {- data, err := m.Marshal()- p.buf = append(p.buf, data...)- return err- }-- t, base, err := getbase(pb)- if structPointer_IsNil(base) {- return ErrNil- }- if err == nil {- err = p.enc_struct(GetProperties(t.Elem()), base)- }-- if collectStats {- (stats).Encode++ // Parens are to work around a goimports bug.- }-- if len(p.buf) > maxMarshalSize {- return ErrTooLarge- }- return err-}--// Size returns the encoded size of a protocol buffer.-func Size(pb Message) (n int) {- // Can the object marshal itself? If so, Size is slow.- // TODO: add Size to Marshaler, or add a Sizer interface.- if m, ok := pb.(Marshaler); ok {- b, _ := m.Marshal()- return len(b)- }-- t, base, err := getbase(pb)- if structPointer_IsNil(base) {- return 0- }- if err == nil {- n = size_struct(GetProperties(t.Elem()), base)- }-- if collectStats {- (stats).Size++ // Parens are to work around a goimports bug.- }-- return-}--// Individual type encoders.--// Encode a bool.-func (o *Buffer) enc_bool(p *Properties, base structPointer) error {- v := *structPointer_Bool(base, p.field)- if v == nil {- return ErrNil- }- x := 0- if *v {- x = 1- }- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, uint64(x))- return nil-}--func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {- v := *structPointer_BoolVal(base, p.field)- if !v {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, 1)- return nil-}--func size_bool(p *Properties, base structPointer) int {- v := *structPointer_Bool(base, p.field)- if v == nil {- return 0- }- return len(p.tagcode) + 1 // each bool takes exactly one byte-}--func size_proto3_bool(p *Properties, base structPointer) int {- v := *structPointer_BoolVal(base, p.field)- if !v && !p.oneof {- return 0- }- return len(p.tagcode) + 1 // each bool takes exactly one byte-}--// Encode an int32.-func (o *Buffer) enc_int32(p *Properties, base structPointer) error {- v := structPointer_Word32(base, p.field)- if word32_IsNil(v) {- return ErrNil- }- x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, uint64(x))- return nil-}--func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {- v := structPointer_Word32Val(base, p.field)- x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range- if x == 0 {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, uint64(x))- return nil-}--func size_int32(p *Properties, base structPointer) (n int) {- v := structPointer_Word32(base, p.field)- if word32_IsNil(v) {- return 0- }- x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range- n += len(p.tagcode)- n += p.valSize(uint64(x))- return-}--func size_proto3_int32(p *Properties, base structPointer) (n int) {- v := structPointer_Word32Val(base, p.field)- x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range- if x == 0 && !p.oneof {- return 0- }- n += len(p.tagcode)- n += p.valSize(uint64(x))- return-}--// Encode a uint32.-// Exactly the same as int32, except for no sign extension.-func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {- v := structPointer_Word32(base, p.field)- if word32_IsNil(v) {- return ErrNil- }- x := word32_Get(v)- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, uint64(x))- return nil-}--func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {- v := structPointer_Word32Val(base, p.field)- x := word32Val_Get(v)- if x == 0 {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, uint64(x))- return nil-}--func size_uint32(p *Properties, base structPointer) (n int) {- v := structPointer_Word32(base, p.field)- if word32_IsNil(v) {- return 0- }- x := word32_Get(v)- n += len(p.tagcode)- n += p.valSize(uint64(x))- return-}--func size_proto3_uint32(p *Properties, base structPointer) (n int) {- v := structPointer_Word32Val(base, p.field)- x := word32Val_Get(v)- if x == 0 && !p.oneof {- return 0- }- n += len(p.tagcode)- n += p.valSize(uint64(x))- return-}--// Encode an int64.-func (o *Buffer) enc_int64(p *Properties, base structPointer) error {- v := structPointer_Word64(base, p.field)- if word64_IsNil(v) {- return ErrNil- }- x := word64_Get(v)- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, x)- return nil-}--func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {- v := structPointer_Word64Val(base, p.field)- x := word64Val_Get(v)- if x == 0 {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, x)- return nil-}--func size_int64(p *Properties, base structPointer) (n int) {- v := structPointer_Word64(base, p.field)- if word64_IsNil(v) {- return 0- }- x := word64_Get(v)- n += len(p.tagcode)- n += p.valSize(x)- return-}--func size_proto3_int64(p *Properties, base structPointer) (n int) {- v := structPointer_Word64Val(base, p.field)- x := word64Val_Get(v)- if x == 0 && !p.oneof {- return 0- }- n += len(p.tagcode)- n += p.valSize(x)- return-}--// Encode a string.-func (o *Buffer) enc_string(p *Properties, base structPointer) error {- v := *structPointer_String(base, p.field)- if v == nil {- return ErrNil- }- x := *v- o.buf = append(o.buf, p.tagcode...)- o.EncodeStringBytes(x)- return nil-}--func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {- v := *structPointer_StringVal(base, p.field)- if v == "" {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeStringBytes(v)- return nil-}--func size_string(p *Properties, base structPointer) (n int) {- v := *structPointer_String(base, p.field)- if v == nil {- return 0- }- x := *v- n += len(p.tagcode)- n += sizeStringBytes(x)- return-}--func size_proto3_string(p *Properties, base structPointer) (n int) {- v := *structPointer_StringVal(base, p.field)- if v == "" && !p.oneof {- return 0- }- n += len(p.tagcode)- n += sizeStringBytes(v)- return+ siz := Size(pb)+ p.EncodeVarint(uint64(siz))+ return p.Marshal(pb)}// All protocol buffer fields are nillable, but be careful.@@ -538,825 +201,3 @@ func isNil(v reflect.Value) bool {}return false}--// Encode a message struct.-func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {- var state errorState- structp := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(structp) {- return ErrNil- }-- // Can the object marshal itself?- if p.isMarshaler {- m := structPointer_Interface(structp, p.stype).(Marshaler)- data, err := m.Marshal()- if err != nil && !state.shouldContinue(err, nil) {- return err- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeRawBytes(data)- return state.err- }-- o.buf = append(o.buf, p.tagcode...)- return o.enc_len_struct(p.sprop, structp, &state)-}--func size_struct_message(p *Properties, base structPointer) int {- structp := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(structp) {- return 0- }-- // Can the object marshal itself?- if p.isMarshaler {- m := structPointer_Interface(structp, p.stype).(Marshaler)- data, _ := m.Marshal()- n0 := len(p.tagcode)- n1 := sizeRawBytes(data)- return n0 + n1- }-- n0 := len(p.tagcode)- n1 := size_struct(p.sprop, structp)- n2 := sizeVarint(uint64(n1)) // size of encoded length- return n0 + n1 + n2-}--// Encode a group struct.-func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {- var state errorState- b := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(b) {- return ErrNil- }-- o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))- err := o.enc_struct(p.sprop, b)- if err != nil && !state.shouldContinue(err, nil) {- return err- }- o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))- return state.err-}--func size_struct_group(p *Properties, base structPointer) (n int) {- b := structPointer_GetStructPointer(base, p.field)- if structPointer_IsNil(b) {- return 0- }-- n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))- n += size_struct(p.sprop, b)- n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))- return-}--// Encode a slice of bools ([]bool).-func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {- s := *structPointer_BoolSlice(base, p.field)- l := len(s)- if l == 0 {- return ErrNil- }- for _, x := range s {- o.buf = append(o.buf, p.tagcode...)- v := uint64(0)- if x {- v = 1- }- p.valEnc(o, v)- }- return nil-}--func size_slice_bool(p *Properties, base structPointer) int {- s := *structPointer_BoolSlice(base, p.field)- l := len(s)- if l == 0 {- return 0- }- return l * (len(p.tagcode) + 1) // each bool takes exactly one byte-}--// Encode a slice of bools ([]bool) in packed format.-func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {- s := *structPointer_BoolSlice(base, p.field)- l := len(s)- if l == 0 {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeVarint(uint64(l)) // each bool takes exactly one byte- for _, x := range s {- v := uint64(0)- if x {- v = 1- }- p.valEnc(o, v)- }- return nil-}--func size_slice_packed_bool(p *Properties, base structPointer) (n int) {- s := *structPointer_BoolSlice(base, p.field)- l := len(s)- if l == 0 {- return 0- }- n += len(p.tagcode)- n += sizeVarint(uint64(l))- n += l // each bool takes exactly one byte- return-}--// Encode a slice of bytes ([]byte).-func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {- s := *structPointer_Bytes(base, p.field)- if s == nil {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeRawBytes(s)- return nil-}--func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {- s := *structPointer_Bytes(base, p.field)- if len(s) == 0 {- return ErrNil- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeRawBytes(s)- return nil-}--func size_slice_byte(p *Properties, base structPointer) (n int) {- s := *structPointer_Bytes(base, p.field)- if s == nil && !p.oneof {- return 0- }- n += len(p.tagcode)- n += sizeRawBytes(s)- return-}--func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {- s := *structPointer_Bytes(base, p.field)- if len(s) == 0 && !p.oneof {- return 0- }- n += len(p.tagcode)- n += sizeRawBytes(s)- return-}--// Encode a slice of int32s ([]int32).-func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- for i := 0; i < l; i++ {- o.buf = append(o.buf, p.tagcode...)- x := int32(s.Index(i)) // permit sign extension to use full 64-bit range- p.valEnc(o, uint64(x))- }- return nil-}--func size_slice_int32(p *Properties, base structPointer) (n int) {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- for i := 0; i < l; i++ {- n += len(p.tagcode)- x := int32(s.Index(i)) // permit sign extension to use full 64-bit range- n += p.valSize(uint64(x))- }- return-}--// Encode a slice of int32s ([]int32) in packed format.-func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- // TODO: Reuse a Buffer.- buf := NewBuffer(nil)- for i := 0; i < l; i++ {- x := int32(s.Index(i)) // permit sign extension to use full 64-bit range- p.valEnc(buf, uint64(x))- }-- o.buf = append(o.buf, p.tagcode...)- o.EncodeVarint(uint64(len(buf.buf)))- o.buf = append(o.buf, buf.buf...)- return nil-}--func size_slice_packed_int32(p *Properties, base structPointer) (n int) {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- var bufSize int- for i := 0; i < l; i++ {- x := int32(s.Index(i)) // permit sign extension to use full 64-bit range- bufSize += p.valSize(uint64(x))- }-- n += len(p.tagcode)- n += sizeVarint(uint64(bufSize))- n += bufSize- return-}--// Encode a slice of uint32s ([]uint32).-// Exactly the same as int32, except for no sign extension.-func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- for i := 0; i < l; i++ {- o.buf = append(o.buf, p.tagcode...)- x := s.Index(i)- p.valEnc(o, uint64(x))- }- return nil-}--func size_slice_uint32(p *Properties, base structPointer) (n int) {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- for i := 0; i < l; i++ {- n += len(p.tagcode)- x := s.Index(i)- n += p.valSize(uint64(x))- }- return-}--// Encode a slice of uint32s ([]uint32) in packed format.-// Exactly the same as int32, except for no sign extension.-func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- // TODO: Reuse a Buffer.- buf := NewBuffer(nil)- for i := 0; i < l; i++ {- p.valEnc(buf, uint64(s.Index(i)))- }-- o.buf = append(o.buf, p.tagcode...)- o.EncodeVarint(uint64(len(buf.buf)))- o.buf = append(o.buf, buf.buf...)- return nil-}--func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {- s := structPointer_Word32Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- var bufSize int- for i := 0; i < l; i++ {- bufSize += p.valSize(uint64(s.Index(i)))- }-- n += len(p.tagcode)- n += sizeVarint(uint64(bufSize))- n += bufSize- return-}--// Encode a slice of int64s ([]int64).-func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {- s := structPointer_Word64Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- for i := 0; i < l; i++ {- o.buf = append(o.buf, p.tagcode...)- p.valEnc(o, s.Index(i))- }- return nil-}--func size_slice_int64(p *Properties, base structPointer) (n int) {- s := structPointer_Word64Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- for i := 0; i < l; i++ {- n += len(p.tagcode)- n += p.valSize(s.Index(i))- }- return-}--// Encode a slice of int64s ([]int64) in packed format.-func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {- s := structPointer_Word64Slice(base, p.field)- l := s.Len()- if l == 0 {- return ErrNil- }- // TODO: Reuse a Buffer.- buf := NewBuffer(nil)- for i := 0; i < l; i++ {- p.valEnc(buf, s.Index(i))- }-- o.buf = append(o.buf, p.tagcode...)- o.EncodeVarint(uint64(len(buf.buf)))- o.buf = append(o.buf, buf.buf...)- return nil-}--func size_slice_packed_int64(p *Properties, base structPointer) (n int) {- s := structPointer_Word64Slice(base, p.field)- l := s.Len()- if l == 0 {- return 0- }- var bufSize int- for i := 0; i < l; i++ {- bufSize += p.valSize(s.Index(i))- }-- n += len(p.tagcode)- n += sizeVarint(uint64(bufSize))- n += bufSize- return-}--// Encode a slice of slice of bytes ([][]byte).-func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {- ss := *structPointer_BytesSlice(base, p.field)- l := len(ss)- if l == 0 {- return ErrNil- }- for i := 0; i < l; i++ {- o.buf = append(o.buf, p.tagcode...)- o.EncodeRawBytes(ss[i])- }- return nil-}--func size_slice_slice_byte(p *Properties, base structPointer) (n int) {- ss := *structPointer_BytesSlice(base, p.field)- l := len(ss)- if l == 0 {- return 0- }- n += l * len(p.tagcode)- for i := 0; i < l; i++ {- n += sizeRawBytes(ss[i])- }- return-}--// Encode a slice of strings ([]string).-func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {- ss := *structPointer_StringSlice(base, p.field)- l := len(ss)- for i := 0; i < l; i++ {- o.buf = append(o.buf, p.tagcode...)- o.EncodeStringBytes(ss[i])- }- return nil-}--func size_slice_string(p *Properties, base structPointer) (n int) {- ss := *structPointer_StringSlice(base, p.field)- l := len(ss)- n += l * len(p.tagcode)- for i := 0; i < l; i++ {- n += sizeStringBytes(ss[i])- }- return-}--// Encode a slice of message structs ([]*struct).-func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {- var state errorState- s := structPointer_StructPointerSlice(base, p.field)- l := s.Len()-- for i := 0; i < l; i++ {- structp := s.Index(i)- if structPointer_IsNil(structp) {- return errRepeatedHasNil- }-- // Can the object marshal itself?- if p.isMarshaler {- m := structPointer_Interface(structp, p.stype).(Marshaler)- data, err := m.Marshal()- if err != nil && !state.shouldContinue(err, nil) {- return err- }- o.buf = append(o.buf, p.tagcode...)- o.EncodeRawBytes(data)- continue- }-- o.buf = append(o.buf, p.tagcode...)- err := o.enc_len_struct(p.sprop, structp, &state)- if err != nil && !state.shouldContinue(err, nil) {- if err == ErrNil {- return errRepeatedHasNil- }- return err- }- }- return state.err-}--func size_slice_struct_message(p *Properties, base structPointer) (n int) {- s := structPointer_StructPointerSlice(base, p.field)- l := s.Len()- n += l * len(p.tagcode)- for i := 0; i < l; i++ {- structp := s.Index(i)- if structPointer_IsNil(structp) {- return // return the size up to this point- }-- // Can the object marshal itself?- if p.isMarshaler {- m := structPointer_Interface(structp, p.stype).(Marshaler)- data, _ := m.Marshal()- n += sizeRawBytes(data)- continue- }-- n0 := size_struct(p.sprop, structp)- n1 := sizeVarint(uint64(n0)) // size of encoded length- n += n0 + n1- }- return-}--// Encode a slice of group structs ([]*struct).-func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {- var state errorState- s := structPointer_StructPointerSlice(base, p.field)- l := s.Len()-- for i := 0; i < l; i++ {- b := s.Index(i)- if structPointer_IsNil(b) {- return errRepeatedHasNil- }-- o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))-- err := o.enc_struct(p.sprop, b)-- if err != nil && !state.shouldContinue(err, nil) {- if err == ErrNil {- return errRepeatedHasNil- }- return err- }-- o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))- }- return state.err-}--func size_slice_struct_group(p *Properties, base structPointer) (n int) {- s := structPointer_StructPointerSlice(base, p.field)- l := s.Len()-- n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))- n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))- for i := 0; i < l; i++ {- b := s.Index(i)- if structPointer_IsNil(b) {- return // return size up to this point- }-- n += size_struct(p.sprop, b)- }- return-}--// Encode an extension map.-func (o *Buffer) enc_map(p *Properties, base structPointer) error {- exts := structPointer_ExtMap(base, p.field)- if err := encodeExtensionsMap(*exts); err != nil {- return err- }-- return o.enc_map_body(*exts)-}--func (o *Buffer) enc_exts(p *Properties, base structPointer) error {- exts := structPointer_Extensions(base, p.field)-- v, mu := exts.extensionsRead()- if v == nil {- return nil- }-- mu.Lock()- defer mu.Unlock()- if err := encodeExtensionsMap(v); err != nil {- return err- }-- return o.enc_map_body(v)-}--func (o *Buffer) enc_map_body(v map[int32]Extension) error {- // Fast-path for common cases: zero or one extensions.- if len(v) <= 1 {- for _, e := range v {- o.buf = append(o.buf, e.enc...)- }- return nil- }-- // Sort keys to provide a deterministic encoding.- keys := make([]int, 0, len(v))- for k := range v {- keys = append(keys, int(k))- }- sort.Ints(keys)-- for _, k := range keys {- o.buf = append(o.buf, v[int32(k)].enc...)- }- return nil-}--func size_map(p *Properties, base structPointer) int {- v := structPointer_ExtMap(base, p.field)- return extensionsMapSize(*v)-}--func size_exts(p *Properties, base structPointer) int {- v := structPointer_Extensions(base, p.field)- return extensionsSize(v)-}--// Encode a map field.-func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {- var state errorState // XXX: or do we need to plumb this through?-- /*- A map defined as- map<key_type, value_type> map_field = N;- is encoded in the same way as- message MapFieldEntry {- key_type key = 1;- value_type value = 2;- }- repeated MapFieldEntry map_field = N;- */-- v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V- if v.Len() == 0 {- return nil- }-- keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)-- enc := func() error {- if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {- return err- }- if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {- return err- }- return nil- }-- // Don't sort map keys. It is not required by the spec, and C++ doesn't do it.- for _, key := range v.MapKeys() {- val := v.MapIndex(key)-- keycopy.Set(key)- valcopy.Set(val)-- o.buf = append(o.buf, p.tagcode...)- if err := o.enc_len_thing(enc, &state); err != nil {- return err- }- }- return nil-}--func size_new_map(p *Properties, base structPointer) int {- v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V-- keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)-- n := 0- for _, key := range v.MapKeys() {- val := v.MapIndex(key)- keycopy.Set(key)- valcopy.Set(val)-- // Tag codes for key and val are the responsibility of the sub-sizer.- keysize := p.mkeyprop.size(p.mkeyprop, keybase)- valsize := p.mvalprop.size(p.mvalprop, valbase)- entry := keysize + valsize- // Add on tag code and length of map entry itself.- n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry- }- return n-}--// mapEncodeScratch returns a new reflect.Value matching the map's value type,-// and a structPointer suitable for passing to an encoder or sizer.-func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {- // Prepare addressable doubly-indirect placeholders for the key and value types.- // This is needed because the element-type encoders expect **T, but the map iteration produces T.-- keycopy = reflect.New(mapType.Key()).Elem() // addressable K- keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K- keyptr.Set(keycopy.Addr()) //- keybase = toStructPointer(keyptr.Addr()) // **K-- // Value types are more varied and require special handling.- switch mapType.Elem().Kind() {- case reflect.Slice:- // []byte- var dummy []byte- valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte- valbase = toStructPointer(valcopy.Addr())- case reflect.Ptr:- // message; the generated field type is map[K]*Msg (so V is *Msg),- // so we only need one level of indirection.- valcopy = reflect.New(mapType.Elem()).Elem() // addressable V- valbase = toStructPointer(valcopy.Addr())- default:- // everything else- valcopy = reflect.New(mapType.Elem()).Elem() // addressable V- valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V- valptr.Set(valcopy.Addr()) //- valbase = toStructPointer(valptr.Addr()) // **V- }- return-}--// Encode a struct.-func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {- var state errorState- // Encode fields in tag order so that decoders may use optimizations- // that depend on the ordering.- // https://developers.google.com/protocol-buffers/docs/encoding#order- for _, i := range prop.order {- p := prop.Prop[i]- if p.enc != nil {- err := p.enc(o, p, base)- if err != nil {- if err == ErrNil {- if p.Required && state.err == nil {- state.err = &RequiredNotSetError{p.Name}- }- } else if err == errRepeatedHasNil {- // Give more context to nil values in repeated fields.- return errors.New("repeated field " + p.OrigName + " has nil element")- } else if !state.shouldContinue(err, p) {- return err- }- }- if len(o.buf) > maxMarshalSize {- return ErrTooLarge- }- }- }-- // Do oneof fields.- if prop.oneofMarshaler != nil {- m := structPointer_Interface(base, prop.stype).(Message)- if err := prop.oneofMarshaler(m, o); err == ErrNil {- return errOneofHasNil- } else if err != nil {- return err- }- }-- // Add unrecognized fields at the end.- if prop.unrecField.IsValid() {- v := *structPointer_Bytes(base, prop.unrecField)- if len(o.buf)+len(v) > maxMarshalSize {- return ErrTooLarge- }- if len(v) > 0 {- o.buf = append(o.buf, v...)- }- }-- return state.err-}--func size_struct(prop *StructProperties, base structPointer) (n int) {- for _, i := range prop.order {- p := prop.Prop[i]- if p.size != nil {- n += p.size(p, base)- }- }-- // Add unrecognized fields at the end.- if prop.unrecField.IsValid() {- v := *structPointer_Bytes(base, prop.unrecField)- n += len(v)- }-- // Factor in any oneof fields.- if prop.oneofSizer != nil {- m := structPointer_Interface(base, prop.stype).(Message)- n += prop.oneofSizer(m)- }-- return-}--var zeroes [20]byte // longer than any conceivable sizeVarint--// Encode a struct, preceded by its encoded length (as a varint).-func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {- return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)-}--// Encode something, preceded by its encoded length (as a varint).-func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {- iLen := len(o.buf)- o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length- iMsg := len(o.buf)- err := enc()- if err != nil && !state.shouldContinue(err, nil) {- return err- }- lMsg := len(o.buf) - iMsg- lLen := sizeVarint(uint64(lMsg))- switch x := lLen - (iMsg - iLen); {- case x > 0: // actual length is x bytes larger than the space we reserved- // Move msg x bytes right.- o.buf = append(o.buf, zeroes[:x]...)- copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])- case x < 0: // actual length is x bytes smaller than the space we reserved- // Move msg x bytes left.- copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])- o.buf = o.buf[:len(o.buf)+x] // x is negative- }- // Encode the length in the reserved space.- o.buf = o.buf[:iLen]- o.EncodeVarint(uint64(lMsg))- o.buf = o.buf[:len(o.buf)+lMsg]- return state.err-}--// errorState maintains the first error that occurs and updates that error-// with additional context.-type errorState struct {- err error-}--// shouldContinue reports whether encoding should continue upon encountering the-// given error. If the error is RequiredNotSetError, shouldContinue returns true-// and, if this is the first appearance of that error, remembers it for future-// reporting.-//-// If prop is not nil, it may update any error with additional context about the-// field with the error.-func (s *errorState) shouldContinue(err error, prop *Properties) bool {- // Ignore unset required fields.- reqNotSet, ok := err.(*RequiredNotSetError)- if !ok {- return false- }- if s.err == nil {- if prop != nil {- err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}- }- s.err = err- }- return true-}diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.goindex 2ed1cf596..d4db5a1c1 100644--- a/vendor/github.com/golang/protobuf/proto/equal.go+++ b/vendor/github.com/golang/protobuf/proto/equal.go@@ -109,15 +109,6 @@ func equalStruct(v1, v2 reflect.Value) bool {// set/unset mismatchreturn false}- b1, ok := f1.Interface().(raw)- if ok {- b2 := f2.Interface().(raw)- // RawMessage- if !bytes.Equal(b1.Bytes(), b2.Bytes()) {- return false- }- continue- }f1, f2 = f1.Elem(), f2.Elem()}if !equalAny(f1, f2, sprop.Prop[i]) {@@ -146,11 +137,7 @@ func equalStruct(v1, v2 reflect.Value) bool {u1 := uf.Bytes()u2 := v2.FieldByName("XXX_unrecognized").Bytes()- if !bytes.Equal(u1, u2) {- return false- }-- return true+ return bytes.Equal(u1, u2)}// v1 and v2 are known to have the same type.@@ -261,6 +248,15 @@ func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {m1, m2 := e1.value, e2.value+ if m1 == nil && m2 == nil {+ // Both have only encoded form.+ if bytes.Equal(e1.enc, e2.enc) {+ continue+ }+ // The bytes are different, but the extensions might still be+ // equal. We need to decode them to compare.+ }+if m1 != nil && m2 != nil {// Both are unencoded.if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {@@ -276,8 +272,12 @@ func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {desc = m[extNum]}if desc == nil {+ // If both have only encoded form and the bytes are the same,+ // it is handled above. We get here when the bytes are different.+ // We don't know how to decode it, so just compare them as byte+ // slices.log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)- continue+ return false}var err errorif m1 == nil {diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.goindex eaad21831..816a3b9d6 100644--- a/vendor/github.com/golang/protobuf/proto/extensions.go+++ b/vendor/github.com/golang/protobuf/proto/extensions.go@@ -38,6 +38,7 @@ package protoimport ("errors""fmt"+ "io""reflect""strconv""sync"@@ -91,14 +92,29 @@ func (n notLocker) Unlock() {}// extendable returns the extendableProto interface for the given generated proto message.// If the proto message has the old extension format, it returns a wrapper that implements// the extendableProto interface.-func extendable(p interface{}) (extendableProto, bool) {- if ep, ok := p.(extendableProto); ok {- return ep, ok- }- if ep, ok := p.(extendableProtoV1); ok {- return extensionAdapter{ep}, ok+func extendable(p interface{}) (extendableProto, error) {+ switch p := p.(type) {+ case extendableProto:+ if isNilPtr(p) {+ return nil, fmt.Errorf("proto: nil %T is not extendable", p)+ }+ return p, nil+ case extendableProtoV1:+ if isNilPtr(p) {+ return nil, fmt.Errorf("proto: nil %T is not extendable", p)+ }+ return extensionAdapter{p}, nil}- return nil, false+ // Don't allocate a specific error containing %T:+ // this is the hot path for Clone and MarshalText.+ return nil, errNotExtendable+}++var errNotExtendable = errors.New("proto: not an extendable proto.Message")++func isNilPtr(x interface{}) bool {+ v := reflect.ValueOf(x)+ return v.Kind() == reflect.Ptr && v.IsNil()}// XXX_InternalExtensions is an internal representation of proto extensions.@@ -143,9 +159,6 @@ func (e *XXX_InternalExtensions) extensionsRead() (map[int32]Extension, sync.Locreturn e.p.extensionMap, &e.p.mu}-var extendableProtoType = reflect.TypeOf((*extendableProto)(nil)).Elem()-var extendableProtoV1Type = reflect.TypeOf((*extendableProtoV1)(nil)).Elem()-// ExtensionDesc represents an extension specification.// Used in generated code from the protocol compiler.type ExtensionDesc struct {@@ -179,8 +192,8 @@ type Extension struct {// SetRawExtension is for testing only.func SetRawExtension(base Message, id int32, b []byte) {- epb, ok := extendable(base)- if !ok {+ epb, err := extendable(base)+ if err != nil {return}extmap := epb.extensionsWrite()@@ -205,7 +218,7 @@ func checkExtensionTypes(pb extendableProto, extension *ExtensionDesc) error {pbi = ea.extendableProtoV1}if a, b := reflect.TypeOf(pbi), reflect.TypeOf(extension.ExtendedType); a != b {- return errors.New("proto: bad extended type; " + b.String() + " does not extend " + a.String())+ return fmt.Errorf("proto: bad extended type; %v does not extend %v", b, a)}// Check the range.if !isExtensionField(pb, extension.Field) {@@ -250,85 +263,11 @@ func extensionProperties(ed *ExtensionDesc) *Properties {return prop}-// encode encodes any unmarshaled (unencoded) extensions in e.-func encodeExtensions(e *XXX_InternalExtensions) error {- m, mu := e.extensionsRead()- if m == nil {- return nil // fast path- }- mu.Lock()- defer mu.Unlock()- return encodeExtensionsMap(m)-}--// encode encodes any unmarshaled (unencoded) extensions in e.-func encodeExtensionsMap(m map[int32]Extension) error {- for k, e := range m {- if e.value == nil || e.desc == nil {- // Extension is only in its encoded form.- continue- }-- // We don't skip extensions that have an encoded form set,- // because the extension value may have been mutated after- // the last time this function was called.-- et := reflect.TypeOf(e.desc.ExtensionType)- props := extensionProperties(e.desc)-- p := NewBuffer(nil)- // If e.value has type T, the encoder expects a *struct{ X T }.- // Pass a *T with a zero field and hope it all works out.- x := reflect.New(et)- x.Elem().Set(reflect.ValueOf(e.value))- if err := props.enc(p, props, toStructPointer(x)); err != nil {- return err- }- e.enc = p.buf- m[k] = e- }- return nil-}--func extensionsSize(e *XXX_InternalExtensions) (n int) {- m, mu := e.extensionsRead()- if m == nil {- return 0- }- mu.Lock()- defer mu.Unlock()- return extensionsMapSize(m)-}--func extensionsMapSize(m map[int32]Extension) (n int) {- for _, e := range m {- if e.value == nil || e.desc == nil {- // Extension is only in its encoded form.- n += len(e.enc)- continue- }-- // We don't skip extensions that have an encoded form set,- // because the extension value may have been mutated after- // the last time this function was called.-- et := reflect.TypeOf(e.desc.ExtensionType)- props := extensionProperties(e.desc)-- // If e.value has type T, the encoder expects a *struct{ X T }.- // Pass a *T with a zero field and hope it all works out.- x := reflect.New(et)- x.Elem().Set(reflect.ValueOf(e.value))- n += props.size(props, toStructPointer(x))- }- return-}-// HasExtension returns whether the given extension is present in pb.func HasExtension(pb Message, extension *ExtensionDesc) bool {// TODO: Check types, field numbers, etc.?- epb, ok := extendable(pb)- if !ok {+ epb, err := extendable(pb)+ if err != nil {return false}extmap, mu := epb.extensionsRead()@@ -336,15 +275,15 @@ func HasExtension(pb Message, extension *ExtensionDesc) bool {return false}mu.Lock()- _, ok = extmap[extension.Field]+ _, ok := extmap[extension.Field]mu.Unlock()return ok}// ClearExtension removes the given extension from pb.func ClearExtension(pb Message, extension *ExtensionDesc) {- epb, ok := extendable(pb)- if !ok {+ epb, err := extendable(pb)+ if err != nil {return}// TODO: Check types, field numbers, etc.?@@ -352,16 +291,26 @@ func ClearExtension(pb Message, extension *ExtensionDesc) {delete(extmap, extension.Field)}-// GetExtension parses and returns the given extension of pb.-// If the extension is not present and has no default value it returns ErrMissingExtension.+// GetExtension retrieves a proto2 extended field from pb.+//+// If the descriptor is type complete (i.e., ExtensionDesc.ExtensionType is non-nil),+// then GetExtension parses the encoded field and returns a Go value of the specified type.+// If the field is not present, then the default value is returned (if one is specified),+// otherwise ErrMissingExtension is reported.+//+// If the descriptor is not type complete (i.e., ExtensionDesc.ExtensionType is nil),+// then GetExtension returns the raw encoded bytes of the field extension.func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {- epb, ok := extendable(pb)- if !ok {- return nil, errors.New("proto: not an extendable proto")+ epb, err := extendable(pb)+ if err != nil {+ return nil, err}- if err := checkExtensionTypes(epb, extension); err != nil {- return nil, err+ if extension.ExtendedType != nil {+ // can only check type if this is a complete descriptor+ if err := checkExtensionTypes(epb, extension); err != nil {+ return nil, err+ }}emap, mu := epb.extensionsRead()@@ -388,6 +337,11 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {return e.value, nil}+ if extension.ExtensionType == nil {+ // incomplete descriptor+ return e.enc, nil+ }+v, err := decodeExtension(e.enc, extension)if err != nil {return nil, err@@ -405,6 +359,11 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {// defaultExtensionValue returns the default value for extension.// If no default for an extension is defined ErrMissingExtension is returned.func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {+ if extension.ExtensionType == nil {+ // incomplete descriptor, so no default+ return nil, ErrMissingExtension+ }+t := reflect.TypeOf(extension.ExtensionType)props := extensionProperties(extension)@@ -439,31 +398,28 @@ func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {// decodeExtension decodes an extension encoded in b.func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {- o := NewBuffer(b)-t := reflect.TypeOf(extension.ExtensionType)-- props := extensionProperties(extension)+ unmarshal := typeUnmarshaler(t, extension.Tag)// t is a pointer to a struct, pointer to basic type or a slice.- // Allocate a "field" to store the pointer/slice itself; the- // pointer/slice will be stored here. We pass- // the address of this field to props.dec.- // This passes a zero field and a *t and lets props.dec- // interpret it as a *struct{ x t }.+ // Allocate space to store the pointer/slice.value := reflect.New(t).Elem()+ var err errorfor {- // Discard wire type and field number varint. It isn't needed.- if _, err := o.DecodeVarint(); err != nil {- return nil, err+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF}+ b = b[n:]+ wire := int(x) & 7- if err := props.dec(o, props, toStructPointer(value.Addr())); err != nil {+ b, err = unmarshal(b, valToPointer(value.Addr()), wire)+ if err != nil {return nil, err}- if o.index >= len(o.buf) {+ if len(b) == 0 {break}}@@ -473,9 +429,9 @@ func decodeExtension(b []byte, extension *ExtensionDesc) (interface{}, error) {// GetExtensions returns a slice of the extensions present in pb that are also listed in es.// The returned slice has the same length as es; missing extensions will appear as nil elements.func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, err error) {- epb, ok := extendable(pb)- if !ok {- return nil, errors.New("proto: not an extendable proto")+ epb, err := extendable(pb)+ if err != nil {+ return nil, err}extensions = make([]interface{}, len(es))for i, e := range es {@@ -494,9 +450,9 @@ func GetExtensions(pb Message, es []*ExtensionDesc) (extensions []interface{}, e// For non-registered extensions, ExtensionDescs returns an incomplete descriptor containing// just the Field field, which defines the extension's field number.func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {- epb, ok := extendable(pb)- if !ok {- return nil, fmt.Errorf("proto: %T is not an extendable proto.Message", pb)+ epb, err := extendable(pb)+ if err != nil {+ return nil, err}registeredExtensions := RegisteredExtensions(pb)@@ -523,9 +479,9 @@ func ExtensionDescs(pb Message) ([]*ExtensionDesc, error) {// SetExtension sets the specified extension of pb to the specified value.func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error {- epb, ok := extendable(pb)- if !ok {- return errors.New("proto: not an extendable proto")+ epb, err := extendable(pb)+ if err != nil {+ return err}if err := checkExtensionTypes(epb, extension); err != nil {return err@@ -550,8 +506,8 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error// ClearAllExtensions clears all extensions from pb.func ClearAllExtensions(pb Message) {- epb, ok := extendable(pb)- if !ok {+ epb, err := extendable(pb)+ if err != nil {return}m := epb.extensionsWrite()diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.goindex 1c225504a..75565cc6d 100644--- a/vendor/github.com/golang/protobuf/proto/lib.go+++ b/vendor/github.com/golang/protobuf/proto/lib.go@@ -273,6 +273,67 @@ import ("sync")+// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.+// Marshal reports this when a required field is not initialized.+// Unmarshal reports this when a required field is missing from the wire data.+type RequiredNotSetError struct{ field string }++func (e *RequiredNotSetError) Error() string {+ if e.field == "" {+ return fmt.Sprintf("proto: required field not set")+ }+ return fmt.Sprintf("proto: required field %q not set", e.field)+}+func (e *RequiredNotSetError) RequiredNotSet() bool {+ return true+}++type invalidUTF8Error struct{ field string }++func (e *invalidUTF8Error) Error() string {+ if e.field == "" {+ return "proto: invalid UTF-8 detected"+ }+ return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field)+}+func (e *invalidUTF8Error) InvalidUTF8() bool {+ return true+}++// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.+// This error should not be exposed to the external API as such errors should+// be recreated with the field information.+var errInvalidUTF8 = &invalidUTF8Error{}++// isNonFatal reports whether the error is either a RequiredNotSet error+// or a InvalidUTF8 error.+func isNonFatal(err error) bool {+ if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() {+ return true+ }+ if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() {+ return true+ }+ return false+}++type nonFatal struct{ E error }++// Merge merges err into nf and reports whether it was successful.+// Otherwise it returns false for any fatal non-nil errors.+func (nf *nonFatal) Merge(err error) (ok bool) {+ if err == nil {+ return true // not an error+ }+ if !isNonFatal(err) {+ return false // fatal error+ }+ if nf.E == nil {+ nf.E = err // store first instance of non-fatal error+ }+ return true+}+// Message is implemented by generated protocol buffer messages.type Message interface {Reset()@@ -309,16 +370,7 @@ type Buffer struct {buf []byte // encode/decode byte streamindex int // read point- // pools of basic types to amortize allocation.- bools []bool- uint32s []uint32- uint64s []uint64-- // extra pools, only used with pointer_reflect.go- int32s []int32- int64s []int64- float32s []float32- float64s []float64+ deterministic bool}// NewBuffer allocates a new Buffer and initializes its internal data to@@ -343,6 +395,30 @@ func (p *Buffer) SetBuf(s []byte) {// Bytes returns the contents of the Buffer.func (p *Buffer) Bytes() []byte { return p.buf }+// SetDeterministic sets whether to use deterministic serialization.+//+// Deterministic serialization guarantees that for a given binary, equal+// messages will always be serialized to the same bytes. This implies:+//+// - Repeated serialization of a message will return the same bytes.+// - Different processes of the same binary (which may be executing on+// different machines) will serialize equal messages to the same bytes.+//+// Note that the deterministic serialization is NOT canonical across+// languages. It is not guaranteed to remain stable over time. It is unstable+// across different builds with schema changes due to unknown fields.+// Users who need canonical serialization (e.g., persistent storage in a+// canonical form, fingerprinting, etc.) should define their own+// canonicalization specification and implement their own serializer rather+// than relying on this API.+//+// If deterministic serialization is requested, map entries will be sorted+// by keys in lexographical order. This is an implementation detail and+// subject to change.+func (p *Buffer) SetDeterministic(deterministic bool) {+ p.deterministic = deterministic+}+/** Helper routines for simplifying the creation of optional fields of basic type.*/@@ -831,22 +907,12 @@ func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMesreturn sf, false, nil}+// mapKeys returns a sort.Interface to be used for sorting the map keys.// Map fields may have key types of non-float scalars, strings and enums.-// The easiest way to sort them in some deterministic order is to use fmt.-// If this turns out to be inefficient we can always consider other options,-// such as doing a Schwartzian transform.-func mapKeys(vs []reflect.Value) sort.Interface {- s := mapKeySorter{- vs: vs,- // default Less function: textual comparison- less: func(a, b reflect.Value) bool {- return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())- },- }+ s := mapKeySorter{vs: vs}- // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps;- // numeric keys are sorted numerically.+ // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.if len(vs) == 0 {return s}@@ -855,6 +921,12 @@ func mapKeys(vs []reflect.Value) sort.Interface {s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }case reflect.Uint32, reflect.Uint64:s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }+ case reflect.Bool:+ s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true+ case reflect.String:+ s.less = func(a, b reflect.Value) bool { return a.String() < b.String() }+ default:+ panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind()))}return s@@ -895,3 +967,13 @@ const ProtoPackageIsVersion2 = true// ProtoPackageIsVersion1 is referenced from generated protocol buffer files// to assert that that code is compatible with this version of the proto package.const ProtoPackageIsVersion1 = true++// InternalMessageInfo is a type used internally by generated .pb.go files.+// This type is not intended to be used by non-generated code.+// This type is not subject to any compatibility guarantee.+type InternalMessageInfo struct {+ marshal *marshalInfo+ unmarshal *unmarshalInfo+ merge *mergeInfo+ discard *discardInfo+}diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.goindex fd982decd..3b6ca41d5 100644--- a/vendor/github.com/golang/protobuf/proto/message_set.go+++ b/vendor/github.com/golang/protobuf/proto/message_set.go@@ -42,6 +42,7 @@ import ("fmt""reflect""sort"+ "sync")// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.@@ -94,10 +95,7 @@ func (ms *messageSet) find(pb Message) *_MessageSet_Item {}func (ms *messageSet) Has(pb Message) bool {- if ms.find(pb) != nil {- return true- }- return false+ return ms.find(pb) != nil}func (ms *messageSet) Unmarshal(pb Message) error {@@ -150,46 +148,42 @@ func skipVarint(buf []byte) []byte {// MarshalMessageSet encodes the extension map represented by m in the message set wire format.// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.func MarshalMessageSet(exts interface{}) ([]byte, error) {- var m map[int32]Extension+ return marshalMessageSet(exts, false)+}++// marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.+func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {switch exts := exts.(type) {case *XXX_InternalExtensions:- if err := encodeExtensions(exts); err != nil {- return nil, err- }- m, _ = exts.extensionsRead()+ var u marshalInfo+ siz := u.sizeMessageSet(exts)+ b := make([]byte, 0, siz)+ return u.appendMessageSet(b, exts, deterministic)+case map[int32]Extension:- if err := encodeExtensionsMap(exts); err != nil {- return nil, err+ // This is an old-style extension map.+ // Wrap it in a new-style XXX_InternalExtensions.+ ie := XXX_InternalExtensions{+ p: &struct {+ mu sync.Mutex+ extensionMap map[int32]Extension+ }{+ extensionMap: exts,+ },}- m = exts++ var u marshalInfo+ siz := u.sizeMessageSet(&ie)+ b := make([]byte, 0, siz)+ return u.appendMessageSet(b, &ie, deterministic)+default:return nil, errors.New("proto: not an extension map")}-- // Sort extension IDs to provide a deterministic encoding.- // See also enc_map in encode.go.- ids := make([]int, 0, len(m))- for id := range m {- ids = append(ids, int(id))- }- sort.Ints(ids)-- ms := &messageSet{Item: make([]*_MessageSet_Item, 0, len(m))}- for _, id := range ids {- e := m[int32(id)]- // Remove the wire type and field number varint, as well as the length varint.- msg := skipVarint(skipVarint(e.enc))-- ms.Item = append(ms.Item, &_MessageSet_Item{- TypeId: Int32(int32(id)),- Message: msg,- })- }- return Marshal(ms)}// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.-// It is called by generated Unmarshal methods on protocol buffer messages with the message_set_wire_format option.+// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.func UnmarshalMessageSet(buf []byte, exts interface{}) error {var m map[int32]Extensionswitch exts := exts.(type) {@@ -235,7 +229,15 @@ func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {var m map[int32]Extensionswitch exts := exts.(type) {case *XXX_InternalExtensions:- m, _ = exts.extensionsRead()+ var mu sync.Locker+ m, mu = exts.extensionsRead()+ if m != nil {+ // Keep the extensions map locked until we're done marshaling to prevent+ // races between marshaling and unmarshaling the lazily-{en,de}coded+ // values.+ mu.Lock()+ defer mu.Unlock()+ }case map[int32]Extension:m = extsdefault:@@ -253,15 +255,16 @@ func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {for i, id := range ids {ext := m[id]- if i > 0 {- b.WriteByte(',')- }-msd, ok := messageSetMap[id]if !ok {// Unknown type; we can't render it, so skip it.continue}++ if i > 0 && b.Len() > 1 {+ b.WriteByte(',')+ }+fmt.Fprintf(&b, `"[%s]":`, msd.name)x := ext.valuediff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.goindex fb512e2e1..b6cad9083 100644--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go@@ -29,7 +29,7 @@// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.-// +build appengine js+// +build purego appengine js// This file contains an implementation of proto field accesses using package reflect.// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can@@ -38,32 +38,13 @@package protoimport (- "math""reflect"+ "sync")-// A structPointer is a pointer to a struct.-type structPointer struct {- v reflect.Value-}--// toStructPointer returns a structPointer equivalent to the given reflect value.-// The reflect value must itself be a pointer to a struct.-func toStructPointer(v reflect.Value) structPointer {- return structPointer{v}-}--// IsNil reports whether p is nil.-func structPointer_IsNil(p structPointer) bool {- return p.v.IsNil()-}+const unsafeAllowed = false-// Interface returns the struct pointer as an interface value.-func structPointer_Interface(p structPointer, _ reflect.Type) interface{} {- return p.v.Interface()-}--// A field identifies a field in a struct, accessible from a structPointer.+// A field identifies a field in a struct, accessible from a pointer.// In this implementation, a field is identified by the sequence of field indices// passed to reflect's FieldByIndex.type field []int@@ -76,409 +57,301 @@ func toField(f *reflect.StructField) field {// invalidField is an invalid field identifier.var invalidField = field(nil)+// zeroField is a noop when calling pointer.offset.+var zeroField = field([]int{})+// IsValid reports whether the field identifier is valid.func (f field) IsValid() bool { return f != nil }-// field returns the given field in the struct as a reflect value.-func structPointer_field(p structPointer, f field) reflect.Value {- // Special case: an extension map entry with a value of type T- // passes a *T to the struct-handling code with a zero field,- // expecting that it will be treated as equivalent to *struct{ X T },- // which has the same memory layout. We have to handle that case- // specially, because reflect will panic if we call FieldByIndex on a- // non-struct.- if f == nil {- return p.v.Elem()- }-- return p.v.Elem().FieldByIndex(f)+// The pointer type is for the table-driven decoder.+// The implementation here uses a reflect.Value of pointer type to+// create a generic pointer. In pointer_unsafe.go we use unsafe+// instead of reflect to implement the same (but faster) interface.+type pointer struct {+ v reflect.Value}-// ifield returns the given field in the struct as an interface value.-func structPointer_ifield(p structPointer, f field) interface{} {- return structPointer_field(p, f).Addr().Interface()+// toPointer converts an interface of pointer type to a pointer+// that points to the same target.+func toPointer(i *Message) pointer {+ return pointer{v: reflect.ValueOf(*i)}}-// Bytes returns the address of a []byte field in the struct.-func structPointer_Bytes(p structPointer, f field) *[]byte {- return structPointer_ifield(p, f).(*[]byte)+// toAddrPointer converts an interface to a pointer that points to+// the interface data.+func toAddrPointer(i *interface{}, isptr bool) pointer {+ v := reflect.ValueOf(*i)+ u := reflect.New(v.Type())+ u.Elem().Set(v)+ return pointer{v: u}}-// BytesSlice returns the address of a [][]byte field in the struct.-func structPointer_BytesSlice(p structPointer, f field) *[][]byte {- return structPointer_ifield(p, f).(*[][]byte)+// valToPointer converts v to a pointer. v must be of pointer type.+func valToPointer(v reflect.Value) pointer {+ return pointer{v: v}}-// Bool returns the address of a *bool field in the struct.-func structPointer_Bool(p structPointer, f field) **bool {- return structPointer_ifield(p, f).(**bool)+// offset converts from a pointer to a structure to a pointer to+// one of its fields.+func (p pointer) offset(f field) pointer {+ return pointer{v: p.v.Elem().FieldByIndex(f).Addr()}}-// BoolVal returns the address of a bool field in the struct.-func structPointer_BoolVal(p structPointer, f field) *bool {- return structPointer_ifield(p, f).(*bool)+func (p pointer) isNil() bool {+ return p.v.IsNil()}-// BoolSlice returns the address of a []bool field in the struct.-func structPointer_BoolSlice(p structPointer, f field) *[]bool {- return structPointer_ifield(p, f).(*[]bool)+// grow updates the slice s in place to make it one element longer.+// s must be addressable.+// Returns the (addressable) new element.+func grow(s reflect.Value) reflect.Value {+ n, m := s.Len(), s.Cap()+ if n < m {+ s.SetLen(n + 1)+ } else {+ s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem())))+ }+ return s.Index(n)}-// String returns the address of a *string field in the struct.-func structPointer_String(p structPointer, f field) **string {- return structPointer_ifield(p, f).(**string)+func (p pointer) toInt64() *int64 {+ return p.v.Interface().(*int64)}--// StringVal returns the address of a string field in the struct.-func structPointer_StringVal(p structPointer, f field) *string {- return structPointer_ifield(p, f).(*string)+func (p pointer) toInt64Ptr() **int64 {+ return p.v.Interface().(**int64)}--// StringSlice returns the address of a []string field in the struct.-func structPointer_StringSlice(p structPointer, f field) *[]string {- return structPointer_ifield(p, f).(*[]string)+func (p pointer) toInt64Slice() *[]int64 {+ return p.v.Interface().(*[]int64)}-// Extensions returns the address of an extension map field in the struct.-func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {- return structPointer_ifield(p, f).(*XXX_InternalExtensions)-}+var int32ptr = reflect.TypeOf((*int32)(nil))-// ExtMap returns the address of an extension map field in the struct.-func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {- return structPointer_ifield(p, f).(*map[int32]Extension)+func (p pointer) toInt32() *int32 {+ return p.v.Convert(int32ptr).Interface().(*int32)}-// NewAt returns the reflect.Value for a pointer to a field in the struct.-func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {- return structPointer_field(p, f).Addr()+// The toInt32Ptr/Slice methods don't work because of enums.+// Instead, we must use set/get methods for the int32ptr/slice case.+/*+ func (p pointer) toInt32Ptr() **int32 {+ return p.v.Interface().(**int32)}--// SetStructPointer writes a *struct field in the struct.-func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {- structPointer_field(p, f).Set(q.v)+ func (p pointer) toInt32Slice() *[]int32 {+ return p.v.Interface().(*[]int32)}--// GetStructPointer reads a *struct field in the struct.-func structPointer_GetStructPointer(p structPointer, f field) structPointer {- return structPointer{structPointer_field(p, f)}+*/+func (p pointer) getInt32Ptr() *int32 {+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {+ // raw int32 type+ return p.v.Elem().Interface().(*int32)+ }+ // an enum+ return p.v.Elem().Convert(int32PtrType).Interface().(*int32)+}+func (p pointer) setInt32Ptr(v int32) {+ // Allocate value in a *int32. Possibly convert that to a *enum.+ // Then assign it to a **int32 or **enum.+ // Note: we can convert *int32 to *enum, but we can't convert+ // **int32 to **enum!+ p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem()))+}++// getInt32Slice copies []int32 from p as a new slice.+// This behavior differs from the implementation in pointer_unsafe.go.+func (p pointer) getInt32Slice() []int32 {+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {+ // raw int32 type+ return p.v.Elem().Interface().([]int32)+ }+ // an enum+ // Allocate a []int32, then assign []enum's values into it.+ // Note: we can't convert []enum to []int32.+ slice := p.v.Elem()+ s := make([]int32, slice.Len())+ for i := 0; i < slice.Len(); i++ {+ s[i] = int32(slice.Index(i).Int())+ }+ return s}-// StructPointerSlice the address of a []*struct field in the struct.-func structPointer_StructPointerSlice(p structPointer, f field) structPointerSlice {- return structPointerSlice{structPointer_field(p, f)}+// setInt32Slice copies []int32 into p as a new slice.+// This behavior differs from the implementation in pointer_unsafe.go.+func (p pointer) setInt32Slice(v []int32) {+ if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) {+ // raw int32 type+ p.v.Elem().Set(reflect.ValueOf(v))+ return+ }+ // an enum+ // Allocate a []enum, then assign []int32's values into it.+ // Note: we can't convert []enum to []int32.+ slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v))+ for i, x := range v {+ slice.Index(i).SetInt(int64(x))+ }+ p.v.Elem().Set(slice)}--// A structPointerSlice represents the address of a slice of pointers to structs-// (themselves messages or groups). That is, v.Type() is *[]*struct{...}.-type structPointerSlice struct {- v reflect.Value+func (p pointer) appendInt32Slice(v int32) {+ grow(p.v.Elem()).SetInt(int64(v))}-func (p structPointerSlice) Len() int { return p.v.Len() }-func (p structPointerSlice) Index(i int) structPointer { return structPointer{p.v.Index(i)} }-func (p structPointerSlice) Append(q structPointer) {- p.v.Set(reflect.Append(p.v, q.v))+func (p pointer) toUint64() *uint64 {+ return p.v.Interface().(*uint64)}--var (- int32Type = reflect.TypeOf(int32(0))- uint32Type = reflect.TypeOf(uint32(0))- float32Type = reflect.TypeOf(float32(0))- int64Type = reflect.TypeOf(int64(0))- uint64Type = reflect.TypeOf(uint64(0))- float64Type = reflect.TypeOf(float64(0))-)--// A word32 represents a field of type *int32, *uint32, *float32, or *enum.-// That is, v.Type() is *int32, *uint32, *float32, or *enum and v is assignable.-type word32 struct {- v reflect.Value+func (p pointer) toUint64Ptr() **uint64 {+ return p.v.Interface().(**uint64)}--// IsNil reports whether p is nil.-func word32_IsNil(p word32) bool {- return p.v.IsNil()+func (p pointer) toUint64Slice() *[]uint64 {+ return p.v.Interface().(*[]uint64)}--// Set sets p to point at a newly allocated word with bits set to x.-func word32_Set(p word32, o *Buffer, x uint32) {- t := p.v.Type().Elem()- switch t {- case int32Type:- if len(o.int32s) == 0 {- o.int32s = make([]int32, uint32PoolSize)- }- o.int32s[0] = int32(x)- p.v.Set(reflect.ValueOf(&o.int32s[0]))- o.int32s = o.int32s[1:]- return- case uint32Type:- if len(o.uint32s) == 0 {- o.uint32s = make([]uint32, uint32PoolSize)- }- o.uint32s[0] = x- p.v.Set(reflect.ValueOf(&o.uint32s[0]))- o.uint32s = o.uint32s[1:]- return- case float32Type:- if len(o.float32s) == 0 {- o.float32s = make([]float32, uint32PoolSize)- }- o.float32s[0] = math.Float32frombits(x)- p.v.Set(reflect.ValueOf(&o.float32s[0]))- o.float32s = o.float32s[1:]- return- }-- // must be enum- p.v.Set(reflect.New(t))- p.v.Elem().SetInt(int64(int32(x)))+func (p pointer) toUint32() *uint32 {+ return p.v.Interface().(*uint32)}--// Get gets the bits pointed at by p, as a uint32.-func word32_Get(p word32) uint32 {- elem := p.v.Elem()- switch elem.Kind() {- case reflect.Int32:- return uint32(elem.Int())- case reflect.Uint32:- return uint32(elem.Uint())- case reflect.Float32:- return math.Float32bits(float32(elem.Float()))- }- panic("unreachable")+func (p pointer) toUint32Ptr() **uint32 {+ return p.v.Interface().(**uint32)}--// Word32 returns a reference to a *int32, *uint32, *float32, or *enum field in the struct.-func structPointer_Word32(p structPointer, f field) word32 {- return word32{structPointer_field(p, f)}+func (p pointer) toUint32Slice() *[]uint32 {+ return p.v.Interface().(*[]uint32)}--// A word32Val represents a field of type int32, uint32, float32, or enum.-// That is, v.Type() is int32, uint32, float32, or enum and v is assignable.-type word32Val struct {- v reflect.Value+func (p pointer) toBool() *bool {+ return p.v.Interface().(*bool)}--// Set sets *p to x.-func word32Val_Set(p word32Val, x uint32) {- switch p.v.Type() {- case int32Type:- p.v.SetInt(int64(x))- return- case uint32Type:- p.v.SetUint(uint64(x))- return- case float32Type:- p.v.SetFloat(float64(math.Float32frombits(x)))- return- }-- // must be enum- p.v.SetInt(int64(int32(x)))+func (p pointer) toBoolPtr() **bool {+ return p.v.Interface().(**bool)}--// Get gets the bits pointed at by p, as a uint32.-func word32Val_Get(p word32Val) uint32 {- elem := p.v- switch elem.Kind() {- case reflect.Int32:- return uint32(elem.Int())- case reflect.Uint32:- return uint32(elem.Uint())- case reflect.Float32:- return math.Float32bits(float32(elem.Float()))- }- panic("unreachable")+func (p pointer) toBoolSlice() *[]bool {+ return p.v.Interface().(*[]bool)}--// Word32Val returns a reference to a int32, uint32, float32, or enum field in the struct.-func structPointer_Word32Val(p structPointer, f field) word32Val {- return word32Val{structPointer_field(p, f)}+func (p pointer) toFloat64() *float64 {+ return p.v.Interface().(*float64)}--// A word32Slice is a slice of 32-bit values.-// That is, v.Type() is []int32, []uint32, []float32, or []enum.-type word32Slice struct {- v reflect.Value+func (p pointer) toFloat64Ptr() **float64 {+ return p.v.Interface().(**float64)}--func (p word32Slice) Append(x uint32) {- n, m := p.v.Len(), p.v.Cap()- if n < m {- p.v.SetLen(n + 1)- } else {- t := p.v.Type().Elem()- p.v.Set(reflect.Append(p.v, reflect.Zero(t)))- }- elem := p.v.Index(n)- switch elem.Kind() {- case reflect.Int32:- elem.SetInt(int64(int32(x)))- case reflect.Uint32:- elem.SetUint(uint64(x))- case reflect.Float32:- elem.SetFloat(float64(math.Float32frombits(x)))- }+func (p pointer) toFloat64Slice() *[]float64 {+ return p.v.Interface().(*[]float64)}--func (p word32Slice) Len() int {- return p.v.Len()+func (p pointer) toFloat32() *float32 {+ return p.v.Interface().(*float32)}--func (p word32Slice) Index(i int) uint32 {- elem := p.v.Index(i)- switch elem.Kind() {- case reflect.Int32:- return uint32(elem.Int())- case reflect.Uint32:- return uint32(elem.Uint())- case reflect.Float32:- return math.Float32bits(float32(elem.Float()))- }- panic("unreachable")+func (p pointer) toFloat32Ptr() **float32 {+ return p.v.Interface().(**float32)}--// Word32Slice returns a reference to a []int32, []uint32, []float32, or []enum field in the struct.-func structPointer_Word32Slice(p structPointer, f field) word32Slice {- return word32Slice{structPointer_field(p, f)}+func (p pointer) toFloat32Slice() *[]float32 {+ return p.v.Interface().(*[]float32)}--// word64 is like word32 but for 64-bit values.-type word64 struct {- v reflect.Value+func (p pointer) toString() *string {+ return p.v.Interface().(*string)}--func word64_Set(p word64, o *Buffer, x uint64) {- t := p.v.Type().Elem()- switch t {- case int64Type:- if len(o.int64s) == 0 {- o.int64s = make([]int64, uint64PoolSize)- }- o.int64s[0] = int64(x)- p.v.Set(reflect.ValueOf(&o.int64s[0]))- o.int64s = o.int64s[1:]- return- case uint64Type:- if len(o.uint64s) == 0 {- o.uint64s = make([]uint64, uint64PoolSize)- }- o.uint64s[0] = x- p.v.Set(reflect.ValueOf(&o.uint64s[0]))- o.uint64s = o.uint64s[1:]- return- case float64Type:- if len(o.float64s) == 0 {- o.float64s = make([]float64, uint64PoolSize)- }- o.float64s[0] = math.Float64frombits(x)- p.v.Set(reflect.ValueOf(&o.float64s[0]))- o.float64s = o.float64s[1:]- return- }- panic("unreachable")+func (p pointer) toStringPtr() **string {+ return p.v.Interface().(**string)}--func word64_IsNil(p word64) bool {- return p.v.IsNil()+func (p pointer) toStringSlice() *[]string {+ return p.v.Interface().(*[]string)}--func word64_Get(p word64) uint64 {- elem := p.v.Elem()- switch elem.Kind() {- case reflect.Int64:- return uint64(elem.Int())- case reflect.Uint64:- return elem.Uint()- case reflect.Float64:- return math.Float64bits(elem.Float())- }- panic("unreachable")+func (p pointer) toBytes() *[]byte {+ return p.v.Interface().(*[]byte)}--func structPointer_Word64(p structPointer, f field) word64 {- return word64{structPointer_field(p, f)}+func (p pointer) toBytesSlice() *[][]byte {+ return p.v.Interface().(*[][]byte)+}+func (p pointer) toExtensions() *XXX_InternalExtensions {+ return p.v.Interface().(*XXX_InternalExtensions)+}+func (p pointer) toOldExtensions() *map[int32]Extension {+ return p.v.Interface().(*map[int32]Extension)+}+func (p pointer) getPointer() pointer {+ return pointer{v: p.v.Elem()}+}+func (p pointer) setPointer(q pointer) {+ p.v.Elem().Set(q.v)+}+func (p pointer) appendPointer(q pointer) {+ grow(p.v.Elem()).Set(q.v)}-// word64Val is like word32Val but for 64-bit values.-type word64Val struct {- v reflect.Value+// getPointerSlice copies []*T from p as a new []pointer.+// This behavior differs from the implementation in pointer_unsafe.go.+func (p pointer) getPointerSlice() []pointer {+ if p.v.IsNil() {+ return nil+ }+ n := p.v.Elem().Len()+ s := make([]pointer, n)+ for i := 0; i < n; i++ {+ s[i] = pointer{v: p.v.Elem().Index(i)}+ }+ return s}-func word64Val_Set(p word64Val, o *Buffer, x uint64) {- switch p.v.Type() {- case int64Type:- p.v.SetInt(int64(x))- return- case uint64Type:- p.v.SetUint(x)- return- case float64Type:- p.v.SetFloat(math.Float64frombits(x))+// setPointerSlice copies []pointer into p as a new []*T.+// This behavior differs from the implementation in pointer_unsafe.go.+func (p pointer) setPointerSlice(v []pointer) {+ if v == nil {+ p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem())return}- panic("unreachable")+ s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v))+ for _, p := range v {+ s = reflect.Append(s, p.v)+ }+ p.v.Elem().Set(s)}-func word64Val_Get(p word64Val) uint64 {- elem := p.v- switch elem.Kind() {- case reflect.Int64:- return uint64(elem.Int())- case reflect.Uint64:- return elem.Uint()- case reflect.Float64:- return math.Float64bits(elem.Float())+// getInterfacePointer returns a pointer that points to the+// interface data of the interface pointed by p.+func (p pointer) getInterfacePointer() pointer {+ if p.v.Elem().IsNil() {+ return pointer{v: p.v.Elem()}}- panic("unreachable")+ return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct}-func structPointer_Word64Val(p structPointer, f field) word64Val {- return word64Val{structPointer_field(p, f)}+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {+ // TODO: check that p.v.Type().Elem() == t?+ return p.v}-type word64Slice struct {- v reflect.Value+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ return *p}--func (p word64Slice) Append(x uint64) {- n, m := p.v.Len(), p.v.Cap()- if n < m {- p.v.SetLen(n + 1)- } else {- t := p.v.Type().Elem()- p.v.Set(reflect.Append(p.v, reflect.Zero(t)))- }- elem := p.v.Index(n)- switch elem.Kind() {- case reflect.Int64:- elem.SetInt(int64(int64(x)))- case reflect.Uint64:- elem.SetUint(uint64(x))- case reflect.Float64:- elem.SetFloat(float64(math.Float64frombits(x)))- }+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ *p = v}--func (p word64Slice) Len() int {- return p.v.Len()+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ return *p}--func (p word64Slice) Index(i int) uint64 {- elem := p.v.Index(i)- switch elem.Kind() {- case reflect.Int64:- return uint64(elem.Int())- case reflect.Uint64:- return uint64(elem.Uint())- case reflect.Float64:- return math.Float64bits(float64(elem.Float()))- }- panic("unreachable")+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ *p = v}--func structPointer_Word64Slice(p structPointer, f field) word64Slice {- return word64Slice{structPointer_field(p, f)}+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ return *p+}+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ *p = v}+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ return *p+}+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {+ atomicLock.Lock()+ defer atomicLock.Unlock()+ *p = v+}++var atomicLock sync.Mutexdiff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.goindex 6b5567d47..d55a335d9 100644--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go@@ -29,7 +29,7 @@// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.-// +build !appengine,!js+// +build !purego,!appengine,!js// This file contains the implementation of the proto field accesses using package unsafe.@@ -37,38 +37,13 @@ package protoimport ("reflect"+ "sync/atomic""unsafe")-// NOTE: These type_Foo functions would more idiomatically be methods,-// but Go does not allow methods on pointer types, and we must preserve-// some pointer type for the garbage collector. We use these-// funcs with clunky names as our poor approximation to methods.-//-// An alternative would be-// type structPointer struct { p unsafe.Pointer }-// but that does not registerize as well.--// A structPointer is a pointer to a struct.-type structPointer unsafe.Pointer--// toStructPointer returns a structPointer equivalent to the given reflect value.-func toStructPointer(v reflect.Value) structPointer {- return structPointer(unsafe.Pointer(v.Pointer()))-}--// IsNil reports whether p is nil.-func structPointer_IsNil(p structPointer) bool {- return p == nil-}--// Interface returns the struct pointer, assumed to have element type t,-// as an interface value.-func structPointer_Interface(p structPointer, t reflect.Type) interface{} {- return reflect.NewAt(t, unsafe.Pointer(p)).Interface()-}+const unsafeAllowed = true-// A field identifies a field in a struct, accessible from a structPointer.+// A field identifies a field in a struct, accessible from a pointer.// In this implementation, a field is identified by its byte offset from the start of the struct.type field uintptr@@ -80,191 +55,254 @@ func toField(f *reflect.StructField) field {// invalidField is an invalid field identifier.const invalidField = ^field(0)+// zeroField is a noop when calling pointer.offset.+const zeroField = field(0)+// IsValid reports whether the field identifier is valid.func (f field) IsValid() bool {- return f != ^field(0)+ return f != invalidField}-// Bytes returns the address of a []byte field in the struct.-func structPointer_Bytes(p structPointer, f field) *[]byte {- return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// The pointer type below is for the new table-driven encoder/decoder.+// The implementation here uses unsafe.Pointer to create a generic pointer.+// In pointer_reflect.go we use reflect instead of unsafe to implement+// the same (but slower) interface.+type pointer struct {+ p unsafe.Pointer}-// BytesSlice returns the address of a [][]byte field in the struct.-func structPointer_BytesSlice(p structPointer, f field) *[][]byte {- return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f)))-}+// size of pointer+var ptrSize = unsafe.Sizeof(uintptr(0))-// Bool returns the address of a *bool field in the struct.-func structPointer_Bool(p structPointer, f field) **bool {- return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// toPointer converts an interface of pointer type to a pointer+// that points to the same target.+func toPointer(i *Message) pointer {+ // Super-tricky - read pointer out of data word of interface value.+ // Saves ~25ns over the equivalent:+ // return valToPointer(reflect.ValueOf(*i))+ return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}}-// BoolVal returns the address of a bool field in the struct.-func structPointer_BoolVal(p structPointer, f field) *bool {- return (*bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// toAddrPointer converts an interface to a pointer that points to+// the interface data.+func toAddrPointer(i *interface{}, isptr bool) pointer {+ // Super-tricky - read or get the address of data word of interface value.+ if isptr {+ // The interface is of pointer type, thus it is a direct interface.+ // The data word is the pointer data itself. We take its address.+ return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}+ }+ // The interface is not of pointer type. The data word is the pointer+ // to the data.+ return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}}-// BoolSlice returns the address of a []bool field in the struct.-func structPointer_BoolSlice(p structPointer, f field) *[]bool {- return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// valToPointer converts v to a pointer. v must be of pointer type.+func valToPointer(v reflect.Value) pointer {+ return pointer{p: unsafe.Pointer(v.Pointer())}}-// String returns the address of a *string field in the struct.-func structPointer_String(p structPointer, f field) **string {- return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// offset converts from a pointer to a structure to a pointer to+// one of its fields.+func (p pointer) offset(f field) pointer {+ // For safety, we should panic if !f.IsValid, however calling panic causes+ // this to no longer be inlineable, which is a serious performance cost.+ /*+ if !f.IsValid() {+ panic("invalid field")+ }+ */+ return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}}-// StringVal returns the address of a string field in the struct.-func structPointer_StringVal(p structPointer, f field) *string {- return (*string)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) isNil() bool {+ return p.p == nil}-// StringSlice returns the address of a []string field in the struct.-func structPointer_StringSlice(p structPointer, f field) *[]string {- return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) toInt64() *int64 {+ return (*int64)(p.p)}--// ExtMap returns the address of an extension map field in the struct.-func structPointer_Extensions(p structPointer, f field) *XXX_InternalExtensions {- return (*XXX_InternalExtensions)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) toInt64Ptr() **int64 {+ return (**int64)(p.p)}--func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension {- return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) toInt64Slice() *[]int64 {+ return (*[]int64)(p.p)}--// NewAt returns the reflect.Value for a pointer to a field in the struct.-func structPointer_NewAt(p structPointer, f field, typ reflect.Type) reflect.Value {- return reflect.NewAt(typ, unsafe.Pointer(uintptr(p)+uintptr(f)))+func (p pointer) toInt32() *int32 {+ return (*int32)(p.p)}-// SetStructPointer writes a *struct field in the struct.-func structPointer_SetStructPointer(p structPointer, f field, q structPointer) {- *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q+// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.+/*+ func (p pointer) toInt32Ptr() **int32 {+ return (**int32)(p.p)+ }+ func (p pointer) toInt32Slice() *[]int32 {+ return (*[]int32)(p.p)+ }+*/+func (p pointer) getInt32Ptr() *int32 {+ return *(**int32)(p.p)}--// GetStructPointer reads a *struct field in the struct.-func structPointer_GetStructPointer(p structPointer, f field) structPointer {- return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) setInt32Ptr(v int32) {+ *(**int32)(p.p) = &v}-// StructPointerSlice the address of a []*struct field in the struct.-func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice {- return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f)))+// getInt32Slice loads a []int32 from p.+// The value returned is aliased with the original slice.+// This behavior differs from the implementation in pointer_reflect.go.+func (p pointer) getInt32Slice() []int32 {+ return *(*[]int32)(p.p)}-// A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups).-type structPointerSlice []structPointer--func (v *structPointerSlice) Len() int { return len(*v) }-func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] }-func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) }--// A word32 is the address of a "pointer to 32-bit value" field.-type word32 **uint32--// IsNil reports whether *v is nil.-func word32_IsNil(p word32) bool {- return *p == nil+// setInt32Slice stores a []int32 to p.+// The value set is aliased with the input slice.+// This behavior differs from the implementation in pointer_reflect.go.+func (p pointer) setInt32Slice(v []int32) {+ *(*[]int32)(p.p) = v}-// Set sets *v to point at a newly allocated word set to x.-func word32_Set(p word32, o *Buffer, x uint32) {- if len(o.uint32s) == 0 {- o.uint32s = make([]uint32, uint32PoolSize)- }- o.uint32s[0] = x- *p = &o.uint32s[0]- o.uint32s = o.uint32s[1:]+// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?+func (p pointer) appendInt32Slice(v int32) {+ s := (*[]int32)(p.p)+ *s = append(*s, v)}-// Get gets the value pointed at by *v.-func word32_Get(p word32) uint32 {- return **p+func (p pointer) toUint64() *uint64 {+ return (*uint64)(p.p)}--// Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct.-func structPointer_Word32(p structPointer, f field) word32 {- return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))+func (p pointer) toUint64Ptr() **uint64 {+ return (**uint64)(p.p)}--// A word32Val is the address of a 32-bit value field.-type word32Val *uint32--// Set sets *p to x.-func word32Val_Set(p word32Val, x uint32) {- *p = x+func (p pointer) toUint64Slice() *[]uint64 {+ return (*[]uint64)(p.p)}--// Get gets the value pointed at by p.-func word32Val_Get(p word32Val) uint32 {- return *p+func (p pointer) toUint32() *uint32 {+ return (*uint32)(p.p)}--// Word32Val returns the address of a *int32, *uint32, *float32, or *enum field in the struct.-func structPointer_Word32Val(p structPointer, f field) word32Val {- return word32Val((*uint32)(unsafe.Pointer(uintptr(p) + uintptr(f))))+func (p pointer) toUint32Ptr() **uint32 {+ return (**uint32)(p.p)}--// A word32Slice is a slice of 32-bit values.-type word32Slice []uint32--func (v *word32Slice) Append(x uint32) { *v = append(*v, x) }-func (v *word32Slice) Len() int { return len(*v) }-func (v *word32Slice) Index(i int) uint32 { return (*v)[i] }--// Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct.-func structPointer_Word32Slice(p structPointer, f field) *word32Slice {- return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func (p pointer) toUint32Slice() *[]uint32 {+ return (*[]uint32)(p.p)}--// word64 is like word32 but for 64-bit values.-type word64 **uint64--func word64_Set(p word64, o *Buffer, x uint64) {- if len(o.uint64s) == 0 {- o.uint64s = make([]uint64, uint64PoolSize)- }- o.uint64s[0] = x- *p = &o.uint64s[0]- o.uint64s = o.uint64s[1:]+func (p pointer) toBool() *bool {+ return (*bool)(p.p)}--func word64_IsNil(p word64) bool {- return *p == nil+func (p pointer) toBoolPtr() **bool {+ return (**bool)(p.p)}--func word64_Get(p word64) uint64 {- return **p+func (p pointer) toBoolSlice() *[]bool {+ return (*[]bool)(p.p)+}+func (p pointer) toFloat64() *float64 {+ return (*float64)(p.p)+}+func (p pointer) toFloat64Ptr() **float64 {+ return (**float64)(p.p)+}+func (p pointer) toFloat64Slice() *[]float64 {+ return (*[]float64)(p.p)+}+func (p pointer) toFloat32() *float32 {+ return (*float32)(p.p)+}+func (p pointer) toFloat32Ptr() **float32 {+ return (**float32)(p.p)+}+func (p pointer) toFloat32Slice() *[]float32 {+ return (*[]float32)(p.p)+}+func (p pointer) toString() *string {+ return (*string)(p.p)+}+func (p pointer) toStringPtr() **string {+ return (**string)(p.p)+}+func (p pointer) toStringSlice() *[]string {+ return (*[]string)(p.p)+}+func (p pointer) toBytes() *[]byte {+ return (*[]byte)(p.p)+}+func (p pointer) toBytesSlice() *[][]byte {+ return (*[][]byte)(p.p)+}+func (p pointer) toExtensions() *XXX_InternalExtensions {+ return (*XXX_InternalExtensions)(p.p)+}+func (p pointer) toOldExtensions() *map[int32]Extension {+ return (*map[int32]Extension)(p.p)}-func structPointer_Word64(p structPointer, f field) word64 {- return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))+// getPointerSlice loads []*T from p as a []pointer.+// The value returned is aliased with the original slice.+// This behavior differs from the implementation in pointer_reflect.go.+func (p pointer) getPointerSlice() []pointer {+ // Super-tricky - p should point to a []*T where T is a+ // message type. We load it as []pointer.+ return *(*[]pointer)(p.p)}-// word64Val is like word32Val but for 64-bit values.-type word64Val *uint64+// setPointerSlice stores []pointer into p as a []*T.+// The value set is aliased with the input slice.+// This behavior differs from the implementation in pointer_reflect.go.+func (p pointer) setPointerSlice(v []pointer) {+ // Super-tricky - p should point to a []*T where T is a+ // message type. We store it as []pointer.+ *(*[]pointer)(p.p) = v+}-func word64Val_Set(p word64Val, o *Buffer, x uint64) {- *p = x+// getPointer loads the pointer at p and returns it.+func (p pointer) getPointer() pointer {+ return pointer{p: *(*unsafe.Pointer)(p.p)}}-func word64Val_Get(p word64Val) uint64 {- return *p+// setPointer stores the pointer q at p.+func (p pointer) setPointer(q pointer) {+ *(*unsafe.Pointer)(p.p) = q.p}-func structPointer_Word64Val(p structPointer, f field) word64Val {- return word64Val((*uint64)(unsafe.Pointer(uintptr(p) + uintptr(f))))+// append q to the slice pointed to by p.+func (p pointer) appendPointer(q pointer) {+ s := (*[]unsafe.Pointer)(p.p)+ *s = append(*s, q.p)}-// word64Slice is like word32Slice but for 64-bit values.-type word64Slice []uint64+// getInterfacePointer returns a pointer that points to the+// interface data of the interface pointed by p.+func (p pointer) getInterfacePointer() pointer {+ // Super-tricky - read pointer out of data word of interface value.+ return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]}+}-func (v *word64Slice) Append(x uint64) { *v = append(*v, x) }-func (v *word64Slice) Len() int { return len(*v) }-func (v *word64Slice) Index(i int) uint64 { return (*v)[i] }+// asPointerTo returns a reflect.Value that is a pointer to an+// object of type t stored at p.+func (p pointer) asPointerTo(t reflect.Type) reflect.Value {+ return reflect.NewAt(t, p.p)+}-func structPointer_Word64Slice(p structPointer, f field) *word64Slice {- return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f)))+func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo {+ return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))+}+func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) {+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))+}+func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo {+ return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))+}+func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) {+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))+}+func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo {+ return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))+}+func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) {+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))+}+func atomicLoadDiscardInfo(p **discardInfo) *discardInfo {+ return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p))))+}+func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) {+ atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v))}diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.goindex ec2289c00..50b99b83a 100644--- a/vendor/github.com/golang/protobuf/proto/properties.go+++ b/vendor/github.com/golang/protobuf/proto/properties.go@@ -58,42 +58,6 @@ const (WireFixed32 = 5)-const startSize = 10 // initial slice/string sizes--// Encoders are defined in encode.go-// An encoder outputs the full representation of a field, including its-// tag and encoder type.-type encoder func(p *Buffer, prop *Properties, base structPointer) error--// A valueEncoder encodes a single integer in a particular encoding.-type valueEncoder func(o *Buffer, x uint64) error--// Sizers are defined in encode.go-// A sizer returns the encoded size of a field, including its tag and encoder-// type.-type sizer func(prop *Properties, base structPointer) int--// A valueSizer returns the encoded size of a single integer in a particular-// encoding.-type valueSizer func(x uint64) int--// Decoders are defined in decode.go-// A decoder creates a value from its wire representation.-// Unrecognized subelements are saved in unrec.-type decoder func(p *Buffer, prop *Properties, base structPointer) error--// A valueDecoder decodes a single integer in a particular encoding.-type valueDecoder func(o *Buffer) (x uint64, err error)--// A oneofMarshaler does the marshaling for all oneof fields in a message.-type oneofMarshaler func(Message, *Buffer) error--// A oneofUnmarshaler does the unmarshaling for a oneof field in a message.-type oneofUnmarshaler func(Message, int, int, *Buffer) (bool, error)--// A oneofSizer does the sizing for all oneof fields in a message.-type oneofSizer func(Message) int-// tagMap is an optimization over map[int]int for typical protocol buffer// use-cases. Encoded protocol buffers are often in tag order with small tag// numbers.@@ -140,13 +104,6 @@ type StructProperties struct {decoderTags tagMap // map from proto tag to struct field numberdecoderOrigNames map[string]int // map from original name to struct field numberorder []int // list of struct field numbers in tag order- unrecField field // field id of the XXX_unrecognized []byte field- extendable bool // is this an extendable proto-- oneofMarshaler oneofMarshaler- oneofUnmarshaler oneofUnmarshaler- oneofSizer oneofSizer- stype reflect.Type// OneofTypes contains information about the oneof fields in this message.// It is keyed by the original name of a field.@@ -182,41 +139,24 @@ type Properties struct {Repeated boolPacked bool // relevant for repeated primitives onlyEnum string // set for enum types only- proto3 bool // whether this is known to be a proto3 field; set for []byte only+ proto3 bool // whether this is known to be a proto3 fieldoneof bool // whether this is a oneof fieldDefault string // default valueHasDefault bool // whether an explicit default was provided- def_uint64 uint64-- enc encoder- valEnc valueEncoder // set for bool and numeric types only- field field- tagcode []byte // encoding of EncodeVarint((Tag<<3)|WireType)- tagbuf [8]byte- stype reflect.Type // set for struct types only- sprop *StructProperties // set for struct types only- isMarshaler bool- isUnmarshaler bool-- mtype reflect.Type // set for map types only- mkeyprop *Properties // set for map types only- mvalprop *Properties // set for map types only-- size sizer- valSize valueSizer // set for bool and numeric types only-- dec decoder- valDec valueDecoder // set for bool and numeric types only-- // If this is a packable field, this will be the decoder for the packed version of the field.- packedDec decoder++ stype reflect.Type // set for struct types only+ sprop *StructProperties // set for struct types only++ mtype reflect.Type // set for map types only+ MapKeyProp *Properties // set for map types only+ MapValProp *Properties // set for map types only}// String formats the properties in the protobuf struct field tag style.func (p *Properties) String() string {s := p.Wire- s = ","+ s += ","s += strconv.Itoa(p.Tag)if p.Required {s += ",req"@@ -262,29 +202,14 @@ func (p *Properties) Parse(s string) {switch p.Wire {case "varint":p.WireType = WireVarint- p.valEnc = (*Buffer).EncodeVarint- p.valDec = (*Buffer).DecodeVarint- p.valSize = sizeVarintcase "fixed32":p.WireType = WireFixed32- p.valEnc = (*Buffer).EncodeFixed32- p.valDec = (*Buffer).DecodeFixed32- p.valSize = sizeFixed32case "fixed64":p.WireType = WireFixed64- p.valEnc = (*Buffer).EncodeFixed64- p.valDec = (*Buffer).DecodeFixed64- p.valSize = sizeFixed64case "zigzag32":p.WireType = WireVarint- p.valEnc = (*Buffer).EncodeZigzag32- p.valDec = (*Buffer).DecodeZigzag32- p.valSize = sizeZigzag32case "zigzag64":p.WireType = WireVarint- p.valEnc = (*Buffer).EncodeZigzag64- p.valDec = (*Buffer).DecodeZigzag64- p.valSize = sizeZigzag64case "bytes", "group":p.WireType = WireBytes// no numeric converter for non-numeric types@@ -299,6 +224,7 @@ func (p *Properties) Parse(s string) {return}+outer:for i := 2; i < len(fields); i++ {f := fields[i]switch {@@ -326,256 +252,41 @@ func (p *Properties) Parse(s string) {if i+1 < len(fields) {// Commas aren't escaped, and def is always last.p.Default += "," + strings.Join(fields[i+1:], ",")- break+ break outer}}}}-func logNoSliceEnc(t1, t2 reflect.Type) {- fmt.Fprintf(os.Stderr, "proto: no slice oenc for %T = []%T\n", t1, t2)-}-var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem()-// Initialize the fields for encoding and decoding.-func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {- p.enc = nil- p.dec = nil- p.size = nil-+// setFieldProps initializes the field properties for submessages and maps.+func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) {switch t1 := typ; t1.Kind() {- default:- fmt.Fprintf(os.Stderr, "proto: no coders for %v\n", t1)-- // proto3 scalar types-- case reflect.Bool:- p.enc = (*Buffer).enc_proto3_bool- p.dec = (*Buffer).dec_proto3_bool- p.size = size_proto3_bool- case reflect.Int32:- p.enc = (*Buffer).enc_proto3_int32- p.dec = (*Buffer).dec_proto3_int32- p.size = size_proto3_int32- case reflect.Uint32:- p.enc = (*Buffer).enc_proto3_uint32- p.dec = (*Buffer).dec_proto3_int32 // can reuse- p.size = size_proto3_uint32- case reflect.Int64, reflect.Uint64:- p.enc = (*Buffer).enc_proto3_int64- p.dec = (*Buffer).dec_proto3_int64- p.size = size_proto3_int64- case reflect.Float32:- p.enc = (*Buffer).enc_proto3_uint32 // can just treat them as bits- p.dec = (*Buffer).dec_proto3_int32- p.size = size_proto3_uint32- case reflect.Float64:- p.enc = (*Buffer).enc_proto3_int64 // can just treat them as bits- p.dec = (*Buffer).dec_proto3_int64- p.size = size_proto3_int64- case reflect.String:- p.enc = (*Buffer).enc_proto3_string- p.dec = (*Buffer).dec_proto3_string- p.size = size_proto3_string-case reflect.Ptr:- switch t2 := t1.Elem(); t2.Kind() {- default:- fmt.Fprintf(os.Stderr, "proto: no encoder function for %v -> %v\n", t1, t2)- break- case reflect.Bool:- p.enc = (*Buffer).enc_bool- p.dec = (*Buffer).dec_bool- p.size = size_bool- case reflect.Int32:- p.enc = (*Buffer).enc_int32- p.dec = (*Buffer).dec_int32- p.size = size_int32- case reflect.Uint32:- p.enc = (*Buffer).enc_uint32- p.dec = (*Buffer).dec_int32 // can reuse- p.size = size_uint32- case reflect.Int64, reflect.Uint64:- p.enc = (*Buffer).enc_int64- p.dec = (*Buffer).dec_int64- p.size = size_int64- case reflect.Float32:- p.enc = (*Buffer).enc_uint32 // can just treat them as bits- p.dec = (*Buffer).dec_int32- p.size = size_uint32- case reflect.Float64:- p.enc = (*Buffer).enc_int64 // can just treat them as bits- p.dec = (*Buffer).dec_int64- p.size = size_int64- case reflect.String:- p.enc = (*Buffer).enc_string- p.dec = (*Buffer).dec_string- p.size = size_string- case reflect.Struct:+ if t1.Elem().Kind() == reflect.Struct {p.stype = t1.Elem()- p.isMarshaler = isMarshaler(t1)- p.isUnmarshaler = isUnmarshaler(t1)- if p.Wire == "bytes" {- p.enc = (*Buffer).enc_struct_message- p.dec = (*Buffer).dec_struct_message- p.size = size_struct_message- } else {- p.enc = (*Buffer).enc_struct_group- p.dec = (*Buffer).dec_struct_group- p.size = size_struct_group- }}case reflect.Slice:- switch t2 := t1.Elem(); t2.Kind() {- default:- logNoSliceEnc(t1, t2)- break- case reflect.Bool:- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_bool- p.size = size_slice_packed_bool- } else {- p.enc = (*Buffer).enc_slice_bool- p.size = size_slice_bool- }- p.dec = (*Buffer).dec_slice_bool- p.packedDec = (*Buffer).dec_slice_packed_bool- case reflect.Int32:- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_int32- p.size = size_slice_packed_int32- } else {- p.enc = (*Buffer).enc_slice_int32- p.size = size_slice_int32- }- p.dec = (*Buffer).dec_slice_int32- p.packedDec = (*Buffer).dec_slice_packed_int32- case reflect.Uint32:- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_uint32- p.size = size_slice_packed_uint32- } else {- p.enc = (*Buffer).enc_slice_uint32- p.size = size_slice_uint32- }- p.dec = (*Buffer).dec_slice_int32- p.packedDec = (*Buffer).dec_slice_packed_int32- case reflect.Int64, reflect.Uint64:- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_int64- p.size = size_slice_packed_int64- } else {- p.enc = (*Buffer).enc_slice_int64- p.size = size_slice_int64- }- p.dec = (*Buffer).dec_slice_int64- p.packedDec = (*Buffer).dec_slice_packed_int64- case reflect.Uint8:- p.dec = (*Buffer).dec_slice_byte- if p.proto3 {- p.enc = (*Buffer).enc_proto3_slice_byte- p.size = size_proto3_slice_byte- } else {- p.enc = (*Buffer).enc_slice_byte- p.size = size_slice_byte- }- case reflect.Float32, reflect.Float64:- switch t2.Bits() {- case 32:- // can just treat them as bits- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_uint32- p.size = size_slice_packed_uint32- } else {- p.enc = (*Buffer).enc_slice_uint32- p.size = size_slice_uint32- }- p.dec = (*Buffer).dec_slice_int32- p.packedDec = (*Buffer).dec_slice_packed_int32- case 64:- // can just treat them as bits- if p.Packed {- p.enc = (*Buffer).enc_slice_packed_int64- p.size = size_slice_packed_int64- } else {- p.enc = (*Buffer).enc_slice_int64- p.size = size_slice_int64- }- p.dec = (*Buffer).dec_slice_int64- p.packedDec = (*Buffer).dec_slice_packed_int64- default:- logNoSliceEnc(t1, t2)- break- }- case reflect.String:- p.enc = (*Buffer).enc_slice_string- p.dec = (*Buffer).dec_slice_string- p.size = size_slice_string- case reflect.Ptr:- switch t3 := t2.Elem(); t3.Kind() {- default:- fmt.Fprintf(os.Stderr, "proto: no ptr oenc for %T -> %T -> %T\n", t1, t2, t3)- break- case reflect.Struct:- p.stype = t2.Elem()- p.isMarshaler = isMarshaler(t2)- p.isUnmarshaler = isUnmarshaler(t2)- if p.Wire == "bytes" {- p.enc = (*Buffer).enc_slice_struct_message- p.dec = (*Buffer).dec_slice_struct_message- p.size = size_slice_struct_message- } else {- p.enc = (*Buffer).enc_slice_struct_group- p.dec = (*Buffer).dec_slice_struct_group- p.size = size_slice_struct_group- }- }- case reflect.Slice:- switch t2.Elem().Kind() {- default:- fmt.Fprintf(os.Stderr, "proto: no slice elem oenc for %T -> %T -> %T\n", t1, t2, t2.Elem())- break- case reflect.Uint8:- p.enc = (*Buffer).enc_slice_slice_byte- p.dec = (*Buffer).dec_slice_slice_byte- p.size = size_slice_slice_byte- }+ if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct {+ p.stype = t2.Elem()}case reflect.Map:- p.enc = (*Buffer).enc_new_map- p.dec = (*Buffer).dec_new_map- p.size = size_new_map-p.mtype = t1- p.mkeyprop = &Properties{}- p.mkeyprop.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)- p.mvalprop = &Properties{}+ p.MapKeyProp = &Properties{}+ p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp)+ p.MapValProp = &Properties{}vtype := p.mtype.Elem()if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice {// The value type is not a message (*T) or bytes ([]byte),// so we need encoders for the pointer to this type.vtype = reflect.PtrTo(vtype)}- p.mvalprop.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)+ p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp)}- // precalculate tag code- wire := p.WireType- if p.Packed {- wire = WireBytes- }- x := uint32(p.Tag)<<3 | uint32(wire)- i := 0- for i = 0; x > 127; i++ {- p.tagbuf[i] = 0x80 | uint8(x&0x7F)- x >>= 7- }- p.tagbuf[i] = uint8(x)- p.tagcode = p.tagbuf[0 : i+1]-if p.stype != nil {if lockGetProp {p.sprop = GetProperties(p.stype)@@ -586,32 +297,9 @@ func (p *Properties) setEncAndDec(typ reflect.Type, f *reflect.StructField, lock}var (- marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()- unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()+ marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem())-// isMarshaler reports whether type t implements Marshaler.-func isMarshaler(t reflect.Type) bool {- // We're checking for (likely) pointer-receiver methods- // so if t is not a pointer, something is very wrong.- // The calls above only invoke isMarshaler on pointer types.- if t.Kind() != reflect.Ptr {- panic("proto: misuse of isMarshaler")- }- return t.Implements(marshalerType)-}--// isUnmarshaler reports whether type t implements Unmarshaler.-func isUnmarshaler(t reflect.Type) bool {- // We're checking for (likely) pointer-receiver methods- // so if t is not a pointer, something is very wrong.- // The calls above only invoke isUnmarshaler on pointer types.- if t.Kind() != reflect.Ptr {- panic("proto: misuse of isUnmarshaler")- }- return t.Implements(unmarshalerType)-}-// Init populates the properties from a protocol buffer struct tag.func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {p.init(typ, name, tag, f, true)@@ -621,14 +309,11 @@ func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructF// "bytes,49,opt,def=hello!"p.Name = namep.OrigName = name- if f != nil {- p.field = toField(f)- }if tag == "" {return}p.Parse(tag)- p.setEncAndDec(typ, f, lockGetProp)+ p.setFieldProps(typ, f, lockGetProp)}var (@@ -678,9 +363,6 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {propertiesMap[t] = prop// build properties- prop.extendable = reflect.PtrTo(t).Implements(extendableProtoType) ||- reflect.PtrTo(t).Implements(extendableProtoV1Type)- prop.unrecField = invalidFieldprop.Prop = make([]*Properties, t.NumField())prop.order = make([]int, t.NumField())@@ -690,17 +372,6 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {name := f.Namep.init(f.Type, name, f.Tag.Get("protobuf"), &f, false)- if f.Name == "XXX_InternalExtensions" { // special case- p.enc = (*Buffer).enc_exts- p.dec = nil // not needed- p.size = size_exts- } else if f.Name == "XXX_extensions" { // special case- p.enc = (*Buffer).enc_map- p.dec = nil // not needed- p.size = size_map- } else if f.Name == "XXX_unrecognized" { // special case- prop.unrecField = toField(&f)- }oneof := f.Tag.Get("protobuf_oneof") // special caseif oneof != "" {// Oneof fields don't use the traditional protobuf tag.@@ -715,9 +386,6 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {}print("\n")}- if p.enc == nil && !strings.HasPrefix(f.Name, "XXX_") && oneof == "" {- fmt.Fprintln(os.Stderr, "proto: no encoder for", f.Name, f.Type.String(), "[GetProperties]")- }}// Re-order prop.order.@@ -728,8 +396,7 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {}if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {var oots []interface{}- prop.oneofMarshaler, prop.oneofUnmarshaler, prop.oneofSizer, oots = om.XXX_OneofFuncs()- prop.stype = t+ _, _, _, oots = om.XXX_OneofFuncs()// Interpret oneof metadata.prop.OneofTypes = make(map[string]*OneofProperties)@@ -779,30 +446,6 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {return prop}-// Return the Properties object for the x[0]'th field of the structure.-func propByIndex(t reflect.Type, x []int) *Properties {- if len(x) != 1 {- fmt.Fprintf(os.Stderr, "proto: field index dimension %d (not 1) for type %s\n", len(x), t)- return nil- }- prop := GetProperties(t)- return prop.Prop[x[0]]-}--// Get the address and type of a pointer to a struct from an interface.-func getbase(pb Message) (t reflect.Type, b structPointer, err error) {- if pb == nil {- err = ErrNil- return- }- // get the reflect type of the pointer to the struct.- t = reflect.TypeOf(pb)- // get the address of the struct.- value := reflect.ValueOf(pb)- b = toStructPointer(value)- return-}-// A global registry of enum types.// The generated code will register the generated maps by calling RegisterEnum.@@ -826,20 +469,42 @@ func EnumValueMap(enumType string) map[string]int32 {// A registry of all linked message types.// The string is a fully-qualified proto name ("pkg.Message").var (- protoTypes = make(map[string]reflect.Type)- revProtoTypes = make(map[reflect.Type]string)+ protoTypedNils = make(map[string]Message) // a map from proto names to typed nil pointers+ protoMapTypes = make(map[string]reflect.Type) // a map from proto names to map types+ revProtoTypes = make(map[reflect.Type]string))// RegisterType is called from generated code and maps from the fully qualified// proto name to the type (pointer to struct) of the protocol buffer.func RegisterType(x Message, name string) {- if _, ok := protoTypes[name]; ok {+ if _, ok := protoTypedNils[name]; ok {// TODO: Some day, make this a panic.log.Printf("proto: duplicate proto type registered: %s", name)return}t := reflect.TypeOf(x)- protoTypes[name] = t+ if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 {+ // Generated code always calls RegisterType with nil x.+ // This check is just for extra safety.+ protoTypedNils[name] = x+ } else {+ protoTypedNils[name] = reflect.Zero(t).Interface().(Message)+ }+ revProtoTypes[t] = name+}++// RegisterMapType is called from generated code and maps from the fully qualified+// proto name to the native map type of the proto map definition.+func RegisterMapType(x interface{}, name string) {+ if reflect.TypeOf(x).Kind() != reflect.Map {+ panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name))+ }+ if _, ok := protoMapTypes[name]; ok {+ log.Printf("proto: duplicate proto type registered: %s", name)+ return+ }+ t := reflect.TypeOf(x)+ protoMapTypes[name] = trevProtoTypes[t] = name}@@ -855,7 +520,14 @@ func MessageName(x Message) string {}// MessageType returns the message type (pointer to struct) for a named message.-func MessageType(name string) reflect.Type { return protoTypes[name] }+// The type is not guaranteed to implement proto.Message if the name refers to a+// map entry.+func MessageType(name string) reflect.Type {+ if t, ok := protoTypedNils[name]; ok {+ return reflect.TypeOf(t)+ }+ return protoMapTypes[name]+}// A registry of all linked proto files.var (diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.gonew file mode 100644index 000000000..b16794496--- /dev/null+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go@@ -0,0 +1,2767 @@+// Go support for Protocol Buffers - Google's data interchange format+//+// Copyright 2016 The Go Authors. All rights reserved.+// https://github.com/golang/protobuf+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++package proto++import (+ "errors"+ "fmt"+ "math"+ "reflect"+ "sort"+ "strconv"+ "strings"+ "sync"+ "sync/atomic"+ "unicode/utf8"+)++// a sizer takes a pointer to a field and the size of its tag, computes the size of+// the encoded data.+type sizer func(pointer, int) int++// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),+// marshals the field to the end of the slice, returns the slice and error (if any).+type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)++// marshalInfo is the information used for marshaling a message.+type marshalInfo struct {+ typ reflect.Type+ fields []*marshalFieldInfo+ unrecognized field // offset of XXX_unrecognized+ extensions field // offset of XXX_InternalExtensions+ v1extensions field // offset of XXX_extensions+ sizecache field // offset of XXX_sizecache+ initialized int32 // 0 -- only typ is set, 1 -- fully initialized+ messageset bool // uses message set wire format+ hasmarshaler bool // has custom marshaler+ sync.RWMutex // protect extElems map, also for initialization+ extElems map[int32]*marshalElemInfo // info of extension elements+}++// marshalFieldInfo is the information used for marshaling a field of a message.+type marshalFieldInfo struct {+ field field+ wiretag uint64 // tag in wire format+ tagsize int // size of tag in wire format+ sizer sizer+ marshaler marshaler+ isPointer bool+ required bool // field is required+ name string // name of the field, for error reporting+ oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements+}++// marshalElemInfo is the information used for marshaling an extension or oneof element.+type marshalElemInfo struct {+ wiretag uint64 // tag in wire format+ tagsize int // size of tag in wire format+ sizer sizer+ marshaler marshaler+ isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)+}++var (+ marshalInfoMap = map[reflect.Type]*marshalInfo{}+ marshalInfoLock sync.Mutex+)++// getMarshalInfo returns the information to marshal a given type of message.+// The info it returns may not necessarily initialized.+// t is the type of the message (NOT the pointer to it).+func getMarshalInfo(t reflect.Type) *marshalInfo {+ marshalInfoLock.Lock()+ u, ok := marshalInfoMap[t]+ if !ok {+ u = &marshalInfo{typ: t}+ marshalInfoMap[t] = u+ }+ marshalInfoLock.Unlock()+ return u+}++// Size is the entry point from generated code,+// and should be ONLY called by generated code.+// It computes the size of encoded data of msg.+// a is a pointer to a place to store cached marshal info.+func (a *InternalMessageInfo) Size(msg Message) int {+ u := getMessageMarshalInfo(msg, a)+ ptr := toPointer(&msg)+ if ptr.isNil() {+ // We get here if msg is a typed nil ((*SomeMessage)(nil)),+ // so it satisfies the interface, and msg == nil wouldn't+ // catch it. We don't want crash in this case.+ return 0+ }+ return u.size(ptr)+}++// Marshal is the entry point from generated code,+// and should be ONLY called by generated code.+// It marshals msg to the end of b.+// a is a pointer to a place to store cached marshal info.+func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {+ u := getMessageMarshalInfo(msg, a)+ ptr := toPointer(&msg)+ if ptr.isNil() {+ // We get here if msg is a typed nil ((*SomeMessage)(nil)),+ // so it satisfies the interface, and msg == nil wouldn't+ // catch it. We don't want crash in this case.+ return b, ErrNil+ }+ return u.marshal(b, ptr, deterministic)+}++func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {+ // u := a.marshal, but atomically.+ // We use an atomic here to ensure memory consistency.+ u := atomicLoadMarshalInfo(&a.marshal)+ if u == nil {+ // Get marshal information from type of message.+ t := reflect.ValueOf(msg).Type()+ if t.Kind() != reflect.Ptr {+ panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))+ }+ u = getMarshalInfo(t.Elem())+ // Store it in the cache for later users.+ // a.marshal = u, but atomically.+ atomicStoreMarshalInfo(&a.marshal, u)+ }+ return u+}++// size is the main function to compute the size of the encoded data of a message.+// ptr is the pointer to the message.+func (u *marshalInfo) size(ptr pointer) int {+ if atomic.LoadInt32(&u.initialized) == 0 {+ u.computeMarshalInfo()+ }++ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ if u.hasmarshaler {+ m := ptr.asPointerTo(u.typ).Interface().(Marshaler)+ b, _ := m.Marshal()+ return len(b)+ }++ n := 0+ for _, f := range u.fields {+ if f.isPointer && ptr.offset(f.field).getPointer().isNil() {+ // nil pointer always marshals to nothing+ continue+ }+ n += f.sizer(ptr.offset(f.field), f.tagsize)+ }+ if u.extensions.IsValid() {+ e := ptr.offset(u.extensions).toExtensions()+ if u.messageset {+ n += u.sizeMessageSet(e)+ } else {+ n += u.sizeExtensions(e)+ }+ }+ if u.v1extensions.IsValid() {+ m := *ptr.offset(u.v1extensions).toOldExtensions()+ n += u.sizeV1Extensions(m)+ }+ if u.unrecognized.IsValid() {+ s := *ptr.offset(u.unrecognized).toBytes()+ n += len(s)+ }+ // cache the result for use in marshal+ if u.sizecache.IsValid() {+ atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))+ }+ return n+}++// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),+// fall back to compute the size.+func (u *marshalInfo) cachedsize(ptr pointer) int {+ if u.sizecache.IsValid() {+ return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))+ }+ return u.size(ptr)+}++// marshal is the main function to marshal a message. It takes a byte slice and appends+// the encoded data to the end of the slice, returns the slice and error (if any).+// ptr is the pointer to the message.+// If deterministic is true, map is marshaled in deterministic order.+func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {+ if atomic.LoadInt32(&u.initialized) == 0 {+ u.computeMarshalInfo()+ }++ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ if u.hasmarshaler {+ m := ptr.asPointerTo(u.typ).Interface().(Marshaler)+ b1, err := m.Marshal()+ b = append(b, b1...)+ return b, err+ }++ var err, errLater error+ // The old marshaler encodes extensions at beginning.+ if u.extensions.IsValid() {+ e := ptr.offset(u.extensions).toExtensions()+ if u.messageset {+ b, err = u.appendMessageSet(b, e, deterministic)+ } else {+ b, err = u.appendExtensions(b, e, deterministic)+ }+ if err != nil {+ return b, err+ }+ }+ if u.v1extensions.IsValid() {+ m := *ptr.offset(u.v1extensions).toOldExtensions()+ b, err = u.appendV1Extensions(b, m, deterministic)+ if err != nil {+ return b, err+ }+ }+ for _, f := range u.fields {+ if f.required {+ if ptr.offset(f.field).getPointer().isNil() {+ // Required field is not set.+ // We record the error but keep going, to give a complete marshaling.+ if errLater == nil {+ errLater = &RequiredNotSetError{f.name}+ }+ continue+ }+ }+ if f.isPointer && ptr.offset(f.field).getPointer().isNil() {+ // nil pointer always marshals to nothing+ continue+ }+ b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)+ if err != nil {+ if err1, ok := err.(*RequiredNotSetError); ok {+ // Required field in submessage is not set.+ // We record the error but keep going, to give a complete marshaling.+ if errLater == nil {+ errLater = &RequiredNotSetError{f.name + "." + err1.field}+ }+ continue+ }+ if err == errRepeatedHasNil {+ err = errors.New("proto: repeated field " + f.name + " has nil element")+ }+ if err == errInvalidUTF8 {+ if errLater == nil {+ fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name+ errLater = &invalidUTF8Error{fullName}+ }+ continue+ }+ return b, err+ }+ }+ if u.unrecognized.IsValid() {+ s := *ptr.offset(u.unrecognized).toBytes()+ b = append(b, s...)+ }+ return b, errLater+}++// computeMarshalInfo initializes the marshal info.+func (u *marshalInfo) computeMarshalInfo() {+ u.Lock()+ defer u.Unlock()+ if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock+ return+ }++ t := u.typ+ u.unrecognized = invalidField+ u.extensions = invalidField+ u.v1extensions = invalidField+ u.sizecache = invalidField++ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ if reflect.PtrTo(t).Implements(marshalerType) {+ u.hasmarshaler = true+ atomic.StoreInt32(&u.initialized, 1)+ return+ }++ // get oneof implementers+ var oneofImplementers []interface{}+ if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok {+ _, _, _, oneofImplementers = m.XXX_OneofFuncs()+ }++ n := t.NumField()++ // deal with XXX fields first+ for i := 0; i < t.NumField(); i++ {+ f := t.Field(i)+ if !strings.HasPrefix(f.Name, "XXX_") {+ continue+ }+ switch f.Name {+ case "XXX_sizecache":+ u.sizecache = toField(&f)+ case "XXX_unrecognized":+ u.unrecognized = toField(&f)+ case "XXX_InternalExtensions":+ u.extensions = toField(&f)+ u.messageset = f.Tag.Get("protobuf_messageset") == "1"+ case "XXX_extensions":+ u.v1extensions = toField(&f)+ case "XXX_NoUnkeyedLiteral":+ // nothing to do+ default:+ panic("unknown XXX field: " + f.Name)+ }+ n--+ }++ // normal fields+ fields := make([]marshalFieldInfo, n) // batch allocation+ u.fields = make([]*marshalFieldInfo, 0, n)+ for i, j := 0, 0; i < t.NumField(); i++ {+ f := t.Field(i)++ if strings.HasPrefix(f.Name, "XXX_") {+ continue+ }+ field := &fields[j]+ j+++ field.name = f.Name+ u.fields = append(u.fields, field)+ if f.Tag.Get("protobuf_oneof") != "" {+ field.computeOneofFieldInfo(&f, oneofImplementers)+ continue+ }+ if f.Tag.Get("protobuf") == "" {+ // field has no tag (not in generated message), ignore it+ u.fields = u.fields[:len(u.fields)-1]+ j--+ continue+ }+ field.computeMarshalFieldInfo(&f)+ }++ // fields are marshaled in tag order on the wire.+ sort.Sort(byTag(u.fields))++ atomic.StoreInt32(&u.initialized, 1)+}++// helper for sorting fields by tag+type byTag []*marshalFieldInfo++func (a byTag) Len() int { return len(a) }+func (a byTag) Swap(i, j int) { a[i], a[j] = a[j], a[i] }+func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }++// getExtElemInfo returns the information to marshal an extension element.+// The info it returns is initialized.+func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {+ // get from cache first+ u.RLock()+ e, ok := u.extElems[desc.Field]+ u.RUnlock()+ if ok {+ return e+ }++ t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct+ tags := strings.Split(desc.Tag, ",")+ tag, err := strconv.Atoi(tags[1])+ if err != nil {+ panic("tag is not an integer")+ }+ wt := wiretype(tags[0])+ sizer, marshaler := typeMarshaler(t, tags, false, false)+ e = &marshalElemInfo{+ wiretag: uint64(tag)<<3 | wt,+ tagsize: SizeVarint(uint64(tag) << 3),+ sizer: sizer,+ marshaler: marshaler,+ isptr: t.Kind() == reflect.Ptr,+ }++ // update cache+ u.Lock()+ if u.extElems == nil {+ u.extElems = make(map[int32]*marshalElemInfo)+ }+ u.extElems[desc.Field] = e+ u.Unlock()+ return e+}++// computeMarshalFieldInfo fills up the information to marshal a field.+func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {+ // parse protobuf tag of the field.+ // tag has format of "bytes,49,opt,name=foo,def=hello!"+ tags := strings.Split(f.Tag.Get("protobuf"), ",")+ if tags[0] == "" {+ return+ }+ tag, err := strconv.Atoi(tags[1])+ if err != nil {+ panic("tag is not an integer")+ }+ wt := wiretype(tags[0])+ if tags[2] == "req" {+ fi.required = true+ }+ fi.setTag(f, tag, wt)+ fi.setMarshaler(f, tags)+}++func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {+ fi.field = toField(f)+ fi.wiretag = 1<<31 - 1 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.+ fi.isPointer = true+ fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)+ fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)++ ityp := f.Type // interface type+ for _, o := range oneofImplementers {+ t := reflect.TypeOf(o)+ if !t.Implements(ityp) {+ continue+ }+ sf := t.Elem().Field(0) // oneof implementer is a struct with a single field+ tags := strings.Split(sf.Tag.Get("protobuf"), ",")+ tag, err := strconv.Atoi(tags[1])+ if err != nil {+ panic("tag is not an integer")+ }+ wt := wiretype(tags[0])+ sizer, marshaler := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value+ fi.oneofElems[t.Elem()] = &marshalElemInfo{+ wiretag: uint64(tag)<<3 | wt,+ tagsize: SizeVarint(uint64(tag) << 3),+ sizer: sizer,+ marshaler: marshaler,+ }+ }+}++type oneofMessage interface {+ XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})+}++// wiretype returns the wire encoding of the type.+func wiretype(encoding string) uint64 {+ switch encoding {+ case "fixed32":+ return WireFixed32+ case "fixed64":+ return WireFixed64+ case "varint", "zigzag32", "zigzag64":+ return WireVarint+ case "bytes":+ return WireBytes+ case "group":+ return WireStartGroup+ }+ panic("unknown wire type " + encoding)+}++// setTag fills up the tag (in wire format) and its size in the info of a field.+func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {+ fi.field = toField(f)+ fi.wiretag = uint64(tag)<<3 | wt+ fi.tagsize = SizeVarint(uint64(tag) << 3)+}++// setMarshaler fills up the sizer and marshaler in the info of a field.+func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {+ switch f.Type.Kind() {+ case reflect.Map:+ // map field+ fi.isPointer = true+ fi.sizer, fi.marshaler = makeMapMarshaler(f)+ return+ case reflect.Ptr, reflect.Slice:+ fi.isPointer = true+ }+ fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)+}++// typeMarshaler returns the sizer and marshaler of a given field.+// t is the type of the field.+// tags is the generated "protobuf" tag of the field.+// If nozero is true, zero value is not marshaled to the wire.+// If oneof is true, it is a oneof field.+func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {+ encoding := tags[0]++ pointer := false+ slice := false+ if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {+ slice = true+ t = t.Elem()+ }+ if t.Kind() == reflect.Ptr {+ pointer = true+ t = t.Elem()+ }++ packed := false+ proto3 := false+ validateUTF8 := true+ for i := 2; i < len(tags); i++ {+ if tags[i] == "packed" {+ packed = true+ }+ if tags[i] == "proto3" {+ proto3 = true+ }+ }+ validateUTF8 = validateUTF8 && proto3++ switch t.Kind() {+ case reflect.Bool:+ if pointer {+ return sizeBoolPtr, appendBoolPtr+ }+ if slice {+ if packed {+ return sizeBoolPackedSlice, appendBoolPackedSlice+ }+ return sizeBoolSlice, appendBoolSlice+ }+ if nozero {+ return sizeBoolValueNoZero, appendBoolValueNoZero+ }+ return sizeBoolValue, appendBoolValue+ case reflect.Uint32:+ switch encoding {+ case "fixed32":+ if pointer {+ return sizeFixed32Ptr, appendFixed32Ptr+ }+ if slice {+ if packed {+ return sizeFixed32PackedSlice, appendFixed32PackedSlice+ }+ return sizeFixed32Slice, appendFixed32Slice+ }+ if nozero {+ return sizeFixed32ValueNoZero, appendFixed32ValueNoZero+ }+ return sizeFixed32Value, appendFixed32Value+ case "varint":+ if pointer {+ return sizeVarint32Ptr, appendVarint32Ptr+ }+ if slice {+ if packed {+ return sizeVarint32PackedSlice, appendVarint32PackedSlice+ }+ return sizeVarint32Slice, appendVarint32Slice+ }+ if nozero {+ return sizeVarint32ValueNoZero, appendVarint32ValueNoZero+ }+ return sizeVarint32Value, appendVarint32Value+ }+ case reflect.Int32:+ switch encoding {+ case "fixed32":+ if pointer {+ return sizeFixedS32Ptr, appendFixedS32Ptr+ }+ if slice {+ if packed {+ return sizeFixedS32PackedSlice, appendFixedS32PackedSlice+ }+ return sizeFixedS32Slice, appendFixedS32Slice+ }+ if nozero {+ return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero+ }+ return sizeFixedS32Value, appendFixedS32Value+ case "varint":+ if pointer {+ return sizeVarintS32Ptr, appendVarintS32Ptr+ }+ if slice {+ if packed {+ return sizeVarintS32PackedSlice, appendVarintS32PackedSlice+ }+ return sizeVarintS32Slice, appendVarintS32Slice+ }+ if nozero {+ return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero+ }+ return sizeVarintS32Value, appendVarintS32Value+ case "zigzag32":+ if pointer {+ return sizeZigzag32Ptr, appendZigzag32Ptr+ }+ if slice {+ if packed {+ return sizeZigzag32PackedSlice, appendZigzag32PackedSlice+ }+ return sizeZigzag32Slice, appendZigzag32Slice+ }+ if nozero {+ return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero+ }+ return sizeZigzag32Value, appendZigzag32Value+ }+ case reflect.Uint64:+ switch encoding {+ case "fixed64":+ if pointer {+ return sizeFixed64Ptr, appendFixed64Ptr+ }+ if slice {+ if packed {+ return sizeFixed64PackedSlice, appendFixed64PackedSlice+ }+ return sizeFixed64Slice, appendFixed64Slice+ }+ if nozero {+ return sizeFixed64ValueNoZero, appendFixed64ValueNoZero+ }+ return sizeFixed64Value, appendFixed64Value+ case "varint":+ if pointer {+ return sizeVarint64Ptr, appendVarint64Ptr+ }+ if slice {+ if packed {+ return sizeVarint64PackedSlice, appendVarint64PackedSlice+ }+ return sizeVarint64Slice, appendVarint64Slice+ }+ if nozero {+ return sizeVarint64ValueNoZero, appendVarint64ValueNoZero+ }+ return sizeVarint64Value, appendVarint64Value+ }+ case reflect.Int64:+ switch encoding {+ case "fixed64":+ if pointer {+ return sizeFixedS64Ptr, appendFixedS64Ptr+ }+ if slice {+ if packed {+ return sizeFixedS64PackedSlice, appendFixedS64PackedSlice+ }+ return sizeFixedS64Slice, appendFixedS64Slice+ }+ if nozero {+ return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero+ }+ return sizeFixedS64Value, appendFixedS64Value+ case "varint":+ if pointer {+ return sizeVarintS64Ptr, appendVarintS64Ptr+ }+ if slice {+ if packed {+ return sizeVarintS64PackedSlice, appendVarintS64PackedSlice+ }+ return sizeVarintS64Slice, appendVarintS64Slice+ }+ if nozero {+ return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero+ }+ return sizeVarintS64Value, appendVarintS64Value+ case "zigzag64":+ if pointer {+ return sizeZigzag64Ptr, appendZigzag64Ptr+ }+ if slice {+ if packed {+ return sizeZigzag64PackedSlice, appendZigzag64PackedSlice+ }+ return sizeZigzag64Slice, appendZigzag64Slice+ }+ if nozero {+ return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero+ }+ return sizeZigzag64Value, appendZigzag64Value+ }+ case reflect.Float32:+ if pointer {+ return sizeFloat32Ptr, appendFloat32Ptr+ }+ if slice {+ if packed {+ return sizeFloat32PackedSlice, appendFloat32PackedSlice+ }+ return sizeFloat32Slice, appendFloat32Slice+ }+ if nozero {+ return sizeFloat32ValueNoZero, appendFloat32ValueNoZero+ }+ return sizeFloat32Value, appendFloat32Value+ case reflect.Float64:+ if pointer {+ return sizeFloat64Ptr, appendFloat64Ptr+ }+ if slice {+ if packed {+ return sizeFloat64PackedSlice, appendFloat64PackedSlice+ }+ return sizeFloat64Slice, appendFloat64Slice+ }+ if nozero {+ return sizeFloat64ValueNoZero, appendFloat64ValueNoZero+ }+ return sizeFloat64Value, appendFloat64Value+ case reflect.String:+ if validateUTF8 {+ if pointer {+ return sizeStringPtr, appendUTF8StringPtr+ }+ if slice {+ return sizeStringSlice, appendUTF8StringSlice+ }+ if nozero {+ return sizeStringValueNoZero, appendUTF8StringValueNoZero+ }+ return sizeStringValue, appendUTF8StringValue+ }+ if pointer {+ return sizeStringPtr, appendStringPtr+ }+ if slice {+ return sizeStringSlice, appendStringSlice+ }+ if nozero {+ return sizeStringValueNoZero, appendStringValueNoZero+ }+ return sizeStringValue, appendStringValue+ case reflect.Slice:+ if slice {+ return sizeBytesSlice, appendBytesSlice+ }+ if oneof {+ // Oneof bytes field may also have "proto3" tag.+ // We want to marshal it as a oneof field. Do this+ // check before the proto3 check.+ return sizeBytesOneof, appendBytesOneof+ }+ if proto3 {+ return sizeBytes3, appendBytes3+ }+ return sizeBytes, appendBytes+ case reflect.Struct:+ switch encoding {+ case "group":+ if slice {+ return makeGroupSliceMarshaler(getMarshalInfo(t))+ }+ return makeGroupMarshaler(getMarshalInfo(t))+ case "bytes":+ if slice {+ return makeMessageSliceMarshaler(getMarshalInfo(t))+ }+ return makeMessageMarshaler(getMarshalInfo(t))+ }+ }+ panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))+}++// Below are functions to size/marshal a specific type of a field.+// They are stored in the field's info, and called by function pointers.+// They have type sizer or marshaler.++func sizeFixed32Value(_ pointer, tagsize int) int {+ return 4 + tagsize+}+func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toUint32()+ if v == 0 {+ return 0+ }+ return 4 + tagsize+}+func sizeFixed32Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toUint32Ptr()+ if p == nil {+ return 0+ }+ return 4 + tagsize+}+func sizeFixed32Slice(ptr pointer, tagsize int) int {+ s := *ptr.toUint32Slice()+ return (4 + tagsize) * len(s)+}+func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toUint32Slice()+ if len(s) == 0 {+ return 0+ }+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize+}+func sizeFixedS32Value(_ pointer, tagsize int) int {+ return 4 + tagsize+}+func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt32()+ if v == 0 {+ return 0+ }+ return 4 + tagsize+}+func sizeFixedS32Ptr(ptr pointer, tagsize int) int {+ p := ptr.getInt32Ptr()+ if p == nil {+ return 0+ }+ return 4 + tagsize+}+func sizeFixedS32Slice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ return (4 + tagsize) * len(s)+}+func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return 0+ }+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize+}+func sizeFloat32Value(_ pointer, tagsize int) int {+ return 4 + tagsize+}+func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {+ v := math.Float32bits(*ptr.toFloat32())+ if v == 0 {+ return 0+ }+ return 4 + tagsize+}+func sizeFloat32Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toFloat32Ptr()+ if p == nil {+ return 0+ }+ return 4 + tagsize+}+func sizeFloat32Slice(ptr pointer, tagsize int) int {+ s := *ptr.toFloat32Slice()+ return (4 + tagsize) * len(s)+}+func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toFloat32Slice()+ if len(s) == 0 {+ return 0+ }+ return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize+}+func sizeFixed64Value(_ pointer, tagsize int) int {+ return 8 + tagsize+}+func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toUint64()+ if v == 0 {+ return 0+ }+ return 8 + tagsize+}+func sizeFixed64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toUint64Ptr()+ if p == nil {+ return 0+ }+ return 8 + tagsize+}+func sizeFixed64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toUint64Slice()+ return (8 + tagsize) * len(s)+}+func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toUint64Slice()+ if len(s) == 0 {+ return 0+ }+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize+}+func sizeFixedS64Value(_ pointer, tagsize int) int {+ return 8 + tagsize+}+func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt64()+ if v == 0 {+ return 0+ }+ return 8 + tagsize+}+func sizeFixedS64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return 0+ }+ return 8 + tagsize+}+func sizeFixedS64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ return (8 + tagsize) * len(s)+}+func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return 0+ }+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize+}+func sizeFloat64Value(_ pointer, tagsize int) int {+ return 8 + tagsize+}+func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {+ v := math.Float64bits(*ptr.toFloat64())+ if v == 0 {+ return 0+ }+ return 8 + tagsize+}+func sizeFloat64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toFloat64Ptr()+ if p == nil {+ return 0+ }+ return 8 + tagsize+}+func sizeFloat64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toFloat64Slice()+ return (8 + tagsize) * len(s)+}+func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toFloat64Slice()+ if len(s) == 0 {+ return 0+ }+ return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize+}+func sizeVarint32Value(ptr pointer, tagsize int) int {+ v := *ptr.toUint32()+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toUint32()+ if v == 0 {+ return 0+ }+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarint32Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toUint32Ptr()+ if p == nil {+ return 0+ }+ return SizeVarint(uint64(*p)) + tagsize+}+func sizeVarint32Slice(ptr pointer, tagsize int) int {+ s := *ptr.toUint32Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v)) + tagsize+ }+ return n+}+func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toUint32Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeVarintS32Value(ptr pointer, tagsize int) int {+ v := *ptr.toInt32()+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt32()+ if v == 0 {+ return 0+ }+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarintS32Ptr(ptr pointer, tagsize int) int {+ p := ptr.getInt32Ptr()+ if p == nil {+ return 0+ }+ return SizeVarint(uint64(*p)) + tagsize+}+func sizeVarintS32Slice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v)) + tagsize+ }+ return n+}+func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeVarint64Value(ptr pointer, tagsize int) int {+ v := *ptr.toUint64()+ return SizeVarint(v) + tagsize+}+func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toUint64()+ if v == 0 {+ return 0+ }+ return SizeVarint(v) + tagsize+}+func sizeVarint64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toUint64Ptr()+ if p == nil {+ return 0+ }+ return SizeVarint(*p) + tagsize+}+func sizeVarint64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toUint64Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(v) + tagsize+ }+ return n+}+func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toUint64Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(v)+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeVarintS64Value(ptr pointer, tagsize int) int {+ v := *ptr.toInt64()+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt64()+ if v == 0 {+ return 0+ }+ return SizeVarint(uint64(v)) + tagsize+}+func sizeVarintS64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return 0+ }+ return SizeVarint(uint64(*p)) + tagsize+}+func sizeVarintS64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v)) + tagsize+ }+ return n+}+func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeZigzag32Value(ptr pointer, tagsize int) int {+ v := *ptr.toInt32()+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize+}+func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt32()+ if v == 0 {+ return 0+ }+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize+}+func sizeZigzag32Ptr(ptr pointer, tagsize int) int {+ p := ptr.getInt32Ptr()+ if p == nil {+ return 0+ }+ v := *p+ return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize+}+func sizeZigzag32Slice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize+ }+ return n+}+func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeZigzag64Value(ptr pointer, tagsize int) int {+ v := *ptr.toInt64()+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize+}+func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toInt64()+ if v == 0 {+ return 0+ }+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize+}+func sizeZigzag64Ptr(ptr pointer, tagsize int) int {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return 0+ }+ v := *p+ return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize+}+func sizeZigzag64Slice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize+ }+ return n+}+func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return 0+ }+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))+ }+ return n + SizeVarint(uint64(n)) + tagsize+}+func sizeBoolValue(_ pointer, tagsize int) int {+ return 1 + tagsize+}+func sizeBoolValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toBool()+ if !v {+ return 0+ }+ return 1 + tagsize+}+func sizeBoolPtr(ptr pointer, tagsize int) int {+ p := *ptr.toBoolPtr()+ if p == nil {+ return 0+ }+ return 1 + tagsize+}+func sizeBoolSlice(ptr pointer, tagsize int) int {+ s := *ptr.toBoolSlice()+ return (1 + tagsize) * len(s)+}+func sizeBoolPackedSlice(ptr pointer, tagsize int) int {+ s := *ptr.toBoolSlice()+ if len(s) == 0 {+ return 0+ }+ return len(s) + SizeVarint(uint64(len(s))) + tagsize+}+func sizeStringValue(ptr pointer, tagsize int) int {+ v := *ptr.toString()+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeStringValueNoZero(ptr pointer, tagsize int) int {+ v := *ptr.toString()+ if v == "" {+ return 0+ }+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeStringPtr(ptr pointer, tagsize int) int {+ p := *ptr.toStringPtr()+ if p == nil {+ return 0+ }+ v := *p+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeStringSlice(ptr pointer, tagsize int) int {+ s := *ptr.toStringSlice()+ n := 0+ for _, v := range s {+ n += len(v) + SizeVarint(uint64(len(v))) + tagsize+ }+ return n+}+func sizeBytes(ptr pointer, tagsize int) int {+ v := *ptr.toBytes()+ if v == nil {+ return 0+ }+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeBytes3(ptr pointer, tagsize int) int {+ v := *ptr.toBytes()+ if len(v) == 0 {+ return 0+ }+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeBytesOneof(ptr pointer, tagsize int) int {+ v := *ptr.toBytes()+ return len(v) + SizeVarint(uint64(len(v))) + tagsize+}+func sizeBytesSlice(ptr pointer, tagsize int) int {+ s := *ptr.toBytesSlice()+ n := 0+ for _, v := range s {+ n += len(v) + SizeVarint(uint64(len(v))) + tagsize+ }+ return n+}++// appendFixed32 appends an encoded fixed32 to b.+func appendFixed32(b []byte, v uint32) []byte {+ b = append(b,+ byte(v),+ byte(v>>8),+ byte(v>>16),+ byte(v>>24))+ return b+}++// appendFixed64 appends an encoded fixed64 to b.+func appendFixed64(b []byte, v uint64) []byte {+ b = append(b,+ byte(v),+ byte(v>>8),+ byte(v>>16),+ byte(v>>24),+ byte(v>>32),+ byte(v>>40),+ byte(v>>48),+ byte(v>>56))+ return b+}++// appendVarint appends an encoded varint to b.+func appendVarint(b []byte, v uint64) []byte {+ // TODO: make 1-byte (maybe 2-byte) case inline-able, once we+ // have non-leaf inliner.+ switch {+ case v < 1<<7:+ b = append(b, byte(v))+ case v < 1<<14:+ b = append(b,+ byte(v&0x7f|0x80),+ byte(v>>7))+ case v < 1<<21:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte(v>>14))+ case v < 1<<28:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte(v>>21))+ case v < 1<<35:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte(v>>28))+ case v < 1<<42:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte((v>>28)&0x7f|0x80),+ byte(v>>35))+ case v < 1<<49:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte((v>>28)&0x7f|0x80),+ byte((v>>35)&0x7f|0x80),+ byte(v>>42))+ case v < 1<<56:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte((v>>28)&0x7f|0x80),+ byte((v>>35)&0x7f|0x80),+ byte((v>>42)&0x7f|0x80),+ byte(v>>49))+ case v < 1<<63:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte((v>>28)&0x7f|0x80),+ byte((v>>35)&0x7f|0x80),+ byte((v>>42)&0x7f|0x80),+ byte((v>>49)&0x7f|0x80),+ byte(v>>56))+ default:+ b = append(b,+ byte(v&0x7f|0x80),+ byte((v>>7)&0x7f|0x80),+ byte((v>>14)&0x7f|0x80),+ byte((v>>21)&0x7f|0x80),+ byte((v>>28)&0x7f|0x80),+ byte((v>>35)&0x7f|0x80),+ byte((v>>42)&0x7f|0x80),+ byte((v>>49)&0x7f|0x80),+ byte((v>>56)&0x7f|0x80),+ 1)+ }+ return b+}++func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint32()+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, v)+ return b, nil+}+func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint32()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, v)+ return b, nil+}+func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toUint32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, *p)+ return b, nil+}+func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, v)+ }+ return b, nil+}+func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(4*len(s)))+ for _, v := range s {+ b = appendFixed32(b, v)+ }+ return b, nil+}+func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, uint32(v))+ return b, nil+}+func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, uint32(v))+ return b, nil+}+func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := ptr.getInt32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, uint32(*p))+ return b, nil+}+func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, uint32(v))+ }+ return b, nil+}+func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(4*len(s)))+ for _, v := range s {+ b = appendFixed32(b, uint32(v))+ }+ return b, nil+}+func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := math.Float32bits(*ptr.toFloat32())+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, v)+ return b, nil+}+func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := math.Float32bits(*ptr.toFloat32())+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, v)+ return b, nil+}+func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toFloat32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, math.Float32bits(*p))+ return b, nil+}+func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toFloat32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed32(b, math.Float32bits(v))+ }+ return b, nil+}+func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toFloat32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(4*len(s)))+ for _, v := range s {+ b = appendFixed32(b, math.Float32bits(v))+ }+ return b, nil+}+func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint64()+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, v)+ return b, nil+}+func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint64()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, v)+ return b, nil+}+func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toUint64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, *p)+ return b, nil+}+func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, v)+ }+ return b, nil+}+func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(8*len(s)))+ for _, v := range s {+ b = appendFixed64(b, v)+ }+ return b, nil+}+func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, uint64(v))+ return b, nil+}+func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, uint64(v))+ return b, nil+}+func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, uint64(*p))+ return b, nil+}+func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, uint64(v))+ }+ return b, nil+}+func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(8*len(s)))+ for _, v := range s {+ b = appendFixed64(b, uint64(v))+ }+ return b, nil+}+func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := math.Float64bits(*ptr.toFloat64())+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, v)+ return b, nil+}+func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := math.Float64bits(*ptr.toFloat64())+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, v)+ return b, nil+}+func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toFloat64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, math.Float64bits(*p))+ return b, nil+}+func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toFloat64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendFixed64(b, math.Float64bits(v))+ }+ return b, nil+}+func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toFloat64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(8*len(s)))+ for _, v := range s {+ b = appendFixed64(b, math.Float64bits(v))+ }+ return b, nil+}+func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint32()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint32()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toUint32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(*p))+ return b, nil+}+func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := ptr.getInt32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(*p))+ return b, nil+}+func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint64()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, v)+ return b, nil+}+func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toUint64()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, v)+ return b, nil+}+func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toUint64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, *p)+ return b, nil+}+func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, v)+ }+ return b, nil+}+func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toUint64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(v)+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, v)+ }+ return b, nil+}+func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ return b, nil+}+func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(*p))+ return b, nil+}+func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v))+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, uint64(v))+ }+ return b, nil+}+func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))+ return b, nil+}+func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt32()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))+ return b, nil+}+func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := ptr.getInt32Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ v := *p+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))+ return b, nil+}+func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))+ }+ return b, nil+}+func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := ptr.getInt32Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))+ }+ return b, nil+}+func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))+ return b, nil+}+func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toInt64()+ if v == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))+ return b, nil+}+func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toInt64Ptr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ v := *p+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))+ return b, nil+}+func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))+ }+ return b, nil+}+func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toInt64Slice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ // compute size+ n := 0+ for _, v := range s {+ n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))+ }+ b = appendVarint(b, uint64(n))+ for _, v := range s {+ b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))+ }+ return b, nil+}+func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toBool()+ b = appendVarint(b, wiretag)+ if v {+ b = append(b, 1)+ } else {+ b = append(b, 0)+ }+ return b, nil+}+func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toBool()+ if !v {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = append(b, 1)+ return b, nil+}++func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toBoolPtr()+ if p == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ if *p {+ b = append(b, 1)+ } else {+ b = append(b, 0)+ }+ return b, nil+}+func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toBoolSlice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ if v {+ b = append(b, 1)+ } else {+ b = append(b, 0)+ }+ }+ return b, nil+}+func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toBoolSlice()+ if len(s) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag&^7|WireBytes)+ b = appendVarint(b, uint64(len(s)))+ for _, v := range s {+ if v {+ b = append(b, 1)+ } else {+ b = append(b, 0)+ }+ }+ return b, nil+}+func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toString()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toString()+ if v == "" {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ p := *ptr.toStringPtr()+ if p == nil {+ return b, nil+ }+ v := *p+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toStringSlice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ }+ return b, nil+}+func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ var invalidUTF8 bool+ v := *ptr.toString()+ if !utf8.ValidString(v) {+ invalidUTF8 = true+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ if invalidUTF8 {+ return b, errInvalidUTF8+ }+ return b, nil+}+func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ var invalidUTF8 bool+ v := *ptr.toString()+ if v == "" {+ return b, nil+ }+ if !utf8.ValidString(v) {+ invalidUTF8 = true+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ if invalidUTF8 {+ return b, errInvalidUTF8+ }+ return b, nil+}+func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ var invalidUTF8 bool+ p := *ptr.toStringPtr()+ if p == nil {+ return b, nil+ }+ v := *p+ if !utf8.ValidString(v) {+ invalidUTF8 = true+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ if invalidUTF8 {+ return b, errInvalidUTF8+ }+ return b, nil+}+func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ var invalidUTF8 bool+ s := *ptr.toStringSlice()+ for _, v := range s {+ if !utf8.ValidString(v) {+ invalidUTF8 = true+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ }+ if invalidUTF8 {+ return b, errInvalidUTF8+ }+ return b, nil+}+func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toBytes()+ if v == nil {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toBytes()+ if len(v) == 0 {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ v := *ptr.toBytes()+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ return b, nil+}+func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {+ s := *ptr.toBytesSlice()+ for _, v := range s {+ b = appendVarint(b, wiretag)+ b = appendVarint(b, uint64(len(v)))+ b = append(b, v...)+ }+ return b, nil+}++// makeGroupMarshaler returns the sizer and marshaler for a group.+// u is the marshal info of the underlying message.+func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {+ return func(ptr pointer, tagsize int) int {+ p := ptr.getPointer()+ if p.isNil() {+ return 0+ }+ return u.size(p) + 2*tagsize+ },+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {+ p := ptr.getPointer()+ if p.isNil() {+ return b, nil+ }+ var err error+ b = appendVarint(b, wiretag) // start group+ b, err = u.marshal(b, p, deterministic)+ b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group+ return b, err+ }+}++// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.+// u is the marshal info of the underlying message.+func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {+ return func(ptr pointer, tagsize int) int {+ s := ptr.getPointerSlice()+ n := 0+ for _, v := range s {+ if v.isNil() {+ continue+ }+ n += u.size(v) + 2*tagsize+ }+ return n+ },+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {+ s := ptr.getPointerSlice()+ var err error+ var nerr nonFatal+ for _, v := range s {+ if v.isNil() {+ return b, errRepeatedHasNil+ }+ b = appendVarint(b, wiretag) // start group+ b, err = u.marshal(b, v, deterministic)+ b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group+ if !nerr.Merge(err) {+ if err == ErrNil {+ err = errRepeatedHasNil+ }+ return b, err+ }+ }+ return b, nerr.E+ }+}++// makeMessageMarshaler returns the sizer and marshaler for a message field.+// u is the marshal info of the message.+func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {+ return func(ptr pointer, tagsize int) int {+ p := ptr.getPointer()+ if p.isNil() {+ return 0+ }+ siz := u.size(p)+ return siz + SizeVarint(uint64(siz)) + tagsize+ },+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {+ p := ptr.getPointer()+ if p.isNil() {+ return b, nil+ }+ b = appendVarint(b, wiretag)+ siz := u.cachedsize(p)+ b = appendVarint(b, uint64(siz))+ return u.marshal(b, p, deterministic)+ }+}++// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.+// u is the marshal info of the message.+func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {+ return func(ptr pointer, tagsize int) int {+ s := ptr.getPointerSlice()+ n := 0+ for _, v := range s {+ if v.isNil() {+ continue+ }+ siz := u.size(v)+ n += siz + SizeVarint(uint64(siz)) + tagsize+ }+ return n+ },+ func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {+ s := ptr.getPointerSlice()+ var err error+ var nerr nonFatal+ for _, v := range s {+ if v.isNil() {+ return b, errRepeatedHasNil+ }+ b = appendVarint(b, wiretag)+ siz := u.cachedsize(v)+ b = appendVarint(b, uint64(siz))+ b, err = u.marshal(b, v, deterministic)++ if !nerr.Merge(err) {+ if err == ErrNil {+ err = errRepeatedHasNil+ }+ return b, err+ }+ }+ return b, nerr.E+ }+}++// makeMapMarshaler returns the sizer and marshaler for a map field.+// f is the pointer to the reflect data structure of the field.+func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {+ // figure out key and value type+ t := f.Type+ keyType := t.Key()+ valType := t.Elem()+ keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")+ valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")+ keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map+ valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map+ keyWireTag := 1<<3 | wiretype(keyTags[0])+ valWireTag := 2<<3 | wiretype(valTags[0])++ // We create an interface to get the addresses of the map key and value.+ // If value is pointer-typed, the interface is a direct interface, the+ // idata itself is the value. Otherwise, the idata is the pointer to the+ // value.+ // Key cannot be pointer-typed.+ valIsPtr := valType.Kind() == reflect.Ptr++ // If value is a message with nested maps, calling+ // valSizer in marshal may be quadratic. We should use+ // cached version in marshal (but not in size).+ // If value is not message type, we don't have size cache,+ // but it cannot be nested either. Just use valSizer.+ valCachedSizer := valSizer+ if valIsPtr && valType.Elem().Kind() == reflect.Struct {+ u := getMarshalInfo(valType.Elem())+ valCachedSizer = func(ptr pointer, tagsize int) int {+ // Same as message sizer, but use cache.+ p := ptr.getPointer()+ if p.isNil() {+ return 0+ }+ siz := u.cachedsize(p)+ return siz + SizeVarint(uint64(siz)) + tagsize+ }+ }+ return func(ptr pointer, tagsize int) int {+ m := ptr.asPointerTo(t).Elem() // the map+ n := 0+ for _, k := range m.MapKeys() {+ ki := k.Interface()+ vi := m.MapIndex(k).Interface()+ kaddr := toAddrPointer(&ki, false) // pointer to key+ vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value+ siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)+ n += siz + SizeVarint(uint64(siz)) + tagsize+ }+ return n+ },+ func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {+ m := ptr.asPointerTo(t).Elem() // the map+ var err error+ keys := m.MapKeys()+ if len(keys) > 1 && deterministic {+ sort.Sort(mapKeys(keys))+ }++ var nerr nonFatal+ for _, k := range keys {+ ki := k.Interface()+ vi := m.MapIndex(k).Interface()+ kaddr := toAddrPointer(&ki, false) // pointer to key+ vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value+ b = appendVarint(b, tag)+ siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)+ b = appendVarint(b, uint64(siz))+ b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)+ if !nerr.Merge(err) {+ return b, err+ }+ b, err = valMarshaler(b, vaddr, valWireTag, deterministic)+ if err != ErrNil && !nerr.Merge(err) { // allow nil value in map+ return b, err+ }+ }+ return b, nerr.E+ }+}++// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.+// fi is the marshal info of the field.+// f is the pointer to the reflect data structure of the field.+func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {+ // Oneof field is an interface. We need to get the actual data type on the fly.+ t := f.Type+ return func(ptr pointer, _ int) int {+ p := ptr.getInterfacePointer()+ if p.isNil() {+ return 0+ }+ v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct+ telem := v.Type()+ e := fi.oneofElems[telem]+ return e.sizer(p, e.tagsize)+ },+ func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {+ p := ptr.getInterfacePointer()+ if p.isNil() {+ return b, nil+ }+ v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct+ telem := v.Type()+ if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {+ return b, errOneofHasNil+ }+ e := fi.oneofElems[telem]+ return e.marshaler(b, p, e.wiretag, deterministic)+ }+}++// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.+func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {+ m, mu := ext.extensionsRead()+ if m == nil {+ return 0+ }+ mu.Lock()++ n := 0+ for _, e := range m {+ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ n += len(e.enc)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.+ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ n += ei.sizer(p, ei.tagsize)+ }+ mu.Unlock()+ return n+}++// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.+func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {+ m, mu := ext.extensionsRead()+ if m == nil {+ return b, nil+ }+ mu.Lock()+ defer mu.Unlock()++ var err error+ var nerr nonFatal++ // Fast-path for common cases: zero or one extensions.+ // Don't bother sorting the keys.+ if len(m) <= 1 {+ for _, e := range m {+ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ b = append(b, e.enc...)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)+ if !nerr.Merge(err) {+ return b, err+ }+ }+ return b, nerr.E+ }++ // Sort the keys to provide a deterministic encoding.+ // Not sure this is required, but the old code does it.+ keys := make([]int, 0, len(m))+ for k := range m {+ keys = append(keys, int(k))+ }+ sort.Ints(keys)++ for _, k := range keys {+ e := m[int32(k)]+ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ b = append(b, e.enc...)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)+ if !nerr.Merge(err) {+ return b, err+ }+ }+ return b, nerr.E+}++// message set format is:+// message MessageSet {+// repeated group Item = 1 {+// required int32 type_id = 2;+// required string message = 3;+// };+// }++// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field+// in message set format (above).+func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {+ m, mu := ext.extensionsRead()+ if m == nil {+ return 0+ }+ mu.Lock()++ n := 0+ for id, e := range m {+ n += 2 // start group, end group. tag = 1 (size=1)+ n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)++ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint+ siz := len(msgWithLen)+ n += siz + 1 // message, tag = 3 (size=1)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ n += ei.sizer(p, 1) // message, tag = 3 (size=1)+ }+ mu.Unlock()+ return n+}++// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)+// to the end of byte slice b.+func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {+ m, mu := ext.extensionsRead()+ if m == nil {+ return b, nil+ }+ mu.Lock()+ defer mu.Unlock()++ var err error+ var nerr nonFatal++ // Fast-path for common cases: zero or one extensions.+ // Don't bother sorting the keys.+ if len(m) <= 1 {+ for id, e := range m {+ b = append(b, 1<<3|WireStartGroup)+ b = append(b, 2<<3|WireVarint)+ b = appendVarint(b, uint64(id))++ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint+ b = append(b, 3<<3|WireBytes)+ b = append(b, msgWithLen...)+ b = append(b, 1<<3|WireEndGroup)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)+ if !nerr.Merge(err) {+ return b, err+ }+ b = append(b, 1<<3|WireEndGroup)+ }+ return b, nerr.E+ }++ // Sort the keys to provide a deterministic encoding.+ keys := make([]int, 0, len(m))+ for k := range m {+ keys = append(keys, int(k))+ }+ sort.Ints(keys)++ for _, id := range keys {+ e := m[int32(id)]+ b = append(b, 1<<3|WireStartGroup)+ b = append(b, 2<<3|WireVarint)+ b = appendVarint(b, uint64(id))++ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint+ b = append(b, 3<<3|WireBytes)+ b = append(b, msgWithLen...)+ b = append(b, 1<<3|WireEndGroup)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)+ b = append(b, 1<<3|WireEndGroup)+ if !nerr.Merge(err) {+ return b, err+ }+ }+ return b, nerr.E+}++// sizeV1Extensions computes the size of encoded data for a V1-API extension field.+func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {+ if m == nil {+ return 0+ }++ n := 0+ for _, e := range m {+ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ n += len(e.enc)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ n += ei.sizer(p, ei.tagsize)+ }+ return n+}++// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.+func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {+ if m == nil {+ return b, nil+ }++ // Sort the keys to provide a deterministic encoding.+ keys := make([]int, 0, len(m))+ for k := range m {+ keys = append(keys, int(k))+ }+ sort.Ints(keys)++ var err error+ var nerr nonFatal+ for _, k := range keys {+ e := m[int32(k)]+ if e.value == nil || e.desc == nil {+ // Extension is only in its encoded form.+ b = append(b, e.enc...)+ continue+ }++ // We don't skip extensions that have an encoded form set,+ // because the extension value may have been mutated after+ // the last time this function was called.++ ei := u.getExtElemInfo(e.desc)+ v := e.value+ p := toAddrPointer(&v, ei.isptr)+ b, err = ei.marshaler(b, p, ei.wiretag, deterministic)+ if !nerr.Merge(err) {+ return b, err+ }+ }+ return b, nerr.E+}++// newMarshaler is the interface representing objects that can marshal themselves.+//+// This exists to support protoc-gen-go generated messages.+// The proto package will stop type-asserting to this interface in the future.+//+// DO NOT DEPEND ON THIS.+type newMarshaler interface {+ XXX_Size() int+ XXX_Marshal(b []byte, deterministic bool) ([]byte, error)+}++// Size returns the encoded size of a protocol buffer message.+// This is the main entry point.+func Size(pb Message) int {+ if m, ok := pb.(newMarshaler); ok {+ return m.XXX_Size()+ }+ if m, ok := pb.(Marshaler); ok {+ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ b, _ := m.Marshal()+ return len(b)+ }+ // in case somehow we didn't generate the wrapper+ if pb == nil {+ return 0+ }+ var info InternalMessageInfo+ return info.Size(pb)+}++// Marshal takes a protocol buffer message+// and encodes it into the wire format, returning the data.+// This is the main entry point.+func Marshal(pb Message) ([]byte, error) {+ if m, ok := pb.(newMarshaler); ok {+ siz := m.XXX_Size()+ b := make([]byte, 0, siz)+ return m.XXX_Marshal(b, false)+ }+ if m, ok := pb.(Marshaler); ok {+ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ return m.Marshal()+ }+ // in case somehow we didn't generate the wrapper+ if pb == nil {+ return nil, ErrNil+ }+ var info InternalMessageInfo+ siz := info.Size(pb)+ b := make([]byte, 0, siz)+ return info.Marshal(b, pb, false)+}++// Marshal takes a protocol buffer message+// and encodes it into the wire format, writing the result to the+// Buffer.+// This is an alternative entry point. It is not necessary to use+// a Buffer for most applications.+func (p *Buffer) Marshal(pb Message) error {+ var err error+ if m, ok := pb.(newMarshaler); ok {+ siz := m.XXX_Size()+ p.grow(siz) // make sure buf has enough capacity+ p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)+ return err+ }+ if m, ok := pb.(Marshaler); ok {+ // If the message can marshal itself, let it do it, for compatibility.+ // NOTE: This is not efficient.+ b, err := m.Marshal()+ p.buf = append(p.buf, b...)+ return err+ }+ // in case somehow we didn't generate the wrapper+ if pb == nil {+ return ErrNil+ }+ var info InternalMessageInfo+ siz := info.Size(pb)+ p.grow(siz) // make sure buf has enough capacity+ p.buf, err = info.Marshal(p.buf, pb, p.deterministic)+ return err+}++// grow grows the buffer's capacity, if necessary, to guarantee space for+// another n bytes. After grow(n), at least n bytes can be written to the+// buffer without another allocation.+func (p *Buffer) grow(n int) {+ need := len(p.buf) + n+ if need <= cap(p.buf) {+ return+ }+ newCap := len(p.buf) * 2+ if newCap < need {+ newCap = need+ }+ p.buf = append(make([]byte, 0, newCap), p.buf...)+}diff --git a/vendor/github.com/golang/protobuf/proto/table_merge.go b/vendor/github.com/golang/protobuf/proto/table_merge.gonew file mode 100644index 000000000..5525def6a--- /dev/null+++ b/vendor/github.com/golang/protobuf/proto/table_merge.go@@ -0,0 +1,654 @@+// Go support for Protocol Buffers - Google's data interchange format+//+// Copyright 2016 The Go Authors. All rights reserved.+// https://github.com/golang/protobuf+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++package proto++import (+ "fmt"+ "reflect"+ "strings"+ "sync"+ "sync/atomic"+)++// Merge merges the src message into dst.+// This assumes that dst and src of the same type and are non-nil.+func (a *InternalMessageInfo) Merge(dst, src Message) {+ mi := atomicLoadMergeInfo(&a.merge)+ if mi == nil {+ mi = getMergeInfo(reflect.TypeOf(dst).Elem())+ atomicStoreMergeInfo(&a.merge, mi)+ }+ mi.merge(toPointer(&dst), toPointer(&src))+}++type mergeInfo struct {+ typ reflect.Type++ initialized int32 // 0: only typ is valid, 1: everything is valid+ lock sync.Mutex++ fields []mergeFieldInfo+ unrecognized field // Offset of XXX_unrecognized+}++type mergeFieldInfo struct {+ field field // Offset of field, guaranteed to be valid++ // isPointer reports whether the value in the field is a pointer.+ // This is true for the following situations:+ // * Pointer to struct+ // * Pointer to basic type (proto2 only)+ // * Slice (first value in slice header is a pointer)+ // * String (first value in string header is a pointer)+ isPointer bool++ // basicWidth reports the width of the field assuming that it is directly+ // embedded in the struct (as is the case for basic types in proto3).+ // The possible values are:+ // 0: invalid+ // 1: bool+ // 4: int32, uint32, float32+ // 8: int64, uint64, float64+ basicWidth int++ // Where dst and src are pointers to the types being merged.+ merge func(dst, src pointer)+}++var (+ mergeInfoMap = map[reflect.Type]*mergeInfo{}+ mergeInfoLock sync.Mutex+)++func getMergeInfo(t reflect.Type) *mergeInfo {+ mergeInfoLock.Lock()+ defer mergeInfoLock.Unlock()+ mi := mergeInfoMap[t]+ if mi == nil {+ mi = &mergeInfo{typ: t}+ mergeInfoMap[t] = mi+ }+ return mi+}++// merge merges src into dst assuming they are both of type *mi.typ.+func (mi *mergeInfo) merge(dst, src pointer) {+ if dst.isNil() {+ panic("proto: nil destination")+ }+ if src.isNil() {+ return // Nothing to do.+ }++ if atomic.LoadInt32(&mi.initialized) == 0 {+ mi.computeMergeInfo()+ }++ for _, fi := range mi.fields {+ sfp := src.offset(fi.field)++ // As an optimization, we can avoid the merge function call cost+ // if we know for sure that the source will have no effect+ // by checking if it is the zero value.+ if unsafeAllowed {+ if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string+ continue+ }+ if fi.basicWidth > 0 {+ switch {+ case fi.basicWidth == 1 && !*sfp.toBool():+ continue+ case fi.basicWidth == 4 && *sfp.toUint32() == 0:+ continue+ case fi.basicWidth == 8 && *sfp.toUint64() == 0:+ continue+ }+ }+ }++ dfp := dst.offset(fi.field)+ fi.merge(dfp, sfp)+ }++ // TODO: Make this faster?+ out := dst.asPointerTo(mi.typ).Elem()+ in := src.asPointerTo(mi.typ).Elem()+ if emIn, err := extendable(in.Addr().Interface()); err == nil {+ emOut, _ := extendable(out.Addr().Interface())+ mIn, muIn := emIn.extensionsRead()+ if mIn != nil {+ mOut := emOut.extensionsWrite()+ muIn.Lock()+ mergeExtension(mOut, mIn)+ muIn.Unlock()+ }+ }++ if mi.unrecognized.IsValid() {+ if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 {+ *dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...)+ }+ }+}++func (mi *mergeInfo) computeMergeInfo() {+ mi.lock.Lock()+ defer mi.lock.Unlock()+ if mi.initialized != 0 {+ return+ }+ t := mi.typ+ n := t.NumField()++ props := GetProperties(t)+ for i := 0; i < n; i++ {+ f := t.Field(i)+ if strings.HasPrefix(f.Name, "XXX_") {+ continue+ }++ mfi := mergeFieldInfo{field: toField(&f)}+ tf := f.Type++ // As an optimization, we can avoid the merge function call cost+ // if we know for sure that the source will have no effect+ // by checking if it is the zero value.+ if unsafeAllowed {+ switch tf.Kind() {+ case reflect.Ptr, reflect.Slice, reflect.String:+ // As a special case, we assume slices and strings are pointers+ // since we know that the first field in the SliceSlice or+ // StringHeader is a data pointer.+ mfi.isPointer = true+ case reflect.Bool:+ mfi.basicWidth = 1+ case reflect.Int32, reflect.Uint32, reflect.Float32:+ mfi.basicWidth = 4+ case reflect.Int64, reflect.Uint64, reflect.Float64:+ mfi.basicWidth = 8+ }+ }++ // Unwrap tf to get at its most basic type.+ var isPointer, isSlice bool+ if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 {+ isSlice = true+ tf = tf.Elem()+ }+ if tf.Kind() == reflect.Ptr {+ isPointer = true+ tf = tf.Elem()+ }+ if isPointer && isSlice && tf.Kind() != reflect.Struct {+ panic("both pointer and slice for basic type in " + tf.Name())+ }++ switch tf.Kind() {+ case reflect.Int32:+ switch {+ case isSlice: // E.g., []int32+ mfi.merge = func(dst, src pointer) {+ // NOTE: toInt32Slice is not defined (see pointer_reflect.go).+ /*+ sfsp := src.toInt32Slice()+ if *sfsp != nil {+ dfsp := dst.toInt32Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []int64{}+ }+ }+ */+ sfs := src.getInt32Slice()+ if sfs != nil {+ dfs := dst.getInt32Slice()+ dfs = append(dfs, sfs...)+ if dfs == nil {+ dfs = []int32{}+ }+ dst.setInt32Slice(dfs)+ }+ }+ case isPointer: // E.g., *int32+ mfi.merge = func(dst, src pointer) {+ // NOTE: toInt32Ptr is not defined (see pointer_reflect.go).+ /*+ sfpp := src.toInt32Ptr()+ if *sfpp != nil {+ dfpp := dst.toInt32Ptr()+ if *dfpp == nil {+ *dfpp = Int32(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ */+ sfp := src.getInt32Ptr()+ if sfp != nil {+ dfp := dst.getInt32Ptr()+ if dfp == nil {+ dst.setInt32Ptr(*sfp)+ } else {+ *dfp = *sfp+ }+ }+ }+ default: // E.g., int32+ mfi.merge = func(dst, src pointer) {+ if v := *src.toInt32(); v != 0 {+ *dst.toInt32() = v+ }+ }+ }+ case reflect.Int64:+ switch {+ case isSlice: // E.g., []int64+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toInt64Slice()+ if *sfsp != nil {+ dfsp := dst.toInt64Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []int64{}+ }+ }+ }+ case isPointer: // E.g., *int64+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toInt64Ptr()+ if *sfpp != nil {+ dfpp := dst.toInt64Ptr()+ if *dfpp == nil {+ *dfpp = Int64(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., int64+ mfi.merge = func(dst, src pointer) {+ if v := *src.toInt64(); v != 0 {+ *dst.toInt64() = v+ }+ }+ }+ case reflect.Uint32:+ switch {+ case isSlice: // E.g., []uint32+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toUint32Slice()+ if *sfsp != nil {+ dfsp := dst.toUint32Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []uint32{}+ }+ }+ }+ case isPointer: // E.g., *uint32+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toUint32Ptr()+ if *sfpp != nil {+ dfpp := dst.toUint32Ptr()+ if *dfpp == nil {+ *dfpp = Uint32(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., uint32+ mfi.merge = func(dst, src pointer) {+ if v := *src.toUint32(); v != 0 {+ *dst.toUint32() = v+ }+ }+ }+ case reflect.Uint64:+ switch {+ case isSlice: // E.g., []uint64+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toUint64Slice()+ if *sfsp != nil {+ dfsp := dst.toUint64Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []uint64{}+ }+ }+ }+ case isPointer: // E.g., *uint64+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toUint64Ptr()+ if *sfpp != nil {+ dfpp := dst.toUint64Ptr()+ if *dfpp == nil {+ *dfpp = Uint64(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., uint64+ mfi.merge = func(dst, src pointer) {+ if v := *src.toUint64(); v != 0 {+ *dst.toUint64() = v+ }+ }+ }+ case reflect.Float32:+ switch {+ case isSlice: // E.g., []float32+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toFloat32Slice()+ if *sfsp != nil {+ dfsp := dst.toFloat32Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []float32{}+ }+ }+ }+ case isPointer: // E.g., *float32+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toFloat32Ptr()+ if *sfpp != nil {+ dfpp := dst.toFloat32Ptr()+ if *dfpp == nil {+ *dfpp = Float32(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., float32+ mfi.merge = func(dst, src pointer) {+ if v := *src.toFloat32(); v != 0 {+ *dst.toFloat32() = v+ }+ }+ }+ case reflect.Float64:+ switch {+ case isSlice: // E.g., []float64+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toFloat64Slice()+ if *sfsp != nil {+ dfsp := dst.toFloat64Slice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []float64{}+ }+ }+ }+ case isPointer: // E.g., *float64+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toFloat64Ptr()+ if *sfpp != nil {+ dfpp := dst.toFloat64Ptr()+ if *dfpp == nil {+ *dfpp = Float64(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., float64+ mfi.merge = func(dst, src pointer) {+ if v := *src.toFloat64(); v != 0 {+ *dst.toFloat64() = v+ }+ }+ }+ case reflect.Bool:+ switch {+ case isSlice: // E.g., []bool+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toBoolSlice()+ if *sfsp != nil {+ dfsp := dst.toBoolSlice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []bool{}+ }+ }+ }+ case isPointer: // E.g., *bool+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toBoolPtr()+ if *sfpp != nil {+ dfpp := dst.toBoolPtr()+ if *dfpp == nil {+ *dfpp = Bool(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., bool+ mfi.merge = func(dst, src pointer) {+ if v := *src.toBool(); v {+ *dst.toBool() = v+ }+ }+ }+ case reflect.String:+ switch {+ case isSlice: // E.g., []string+ mfi.merge = func(dst, src pointer) {+ sfsp := src.toStringSlice()+ if *sfsp != nil {+ dfsp := dst.toStringSlice()+ *dfsp = append(*dfsp, *sfsp...)+ if *dfsp == nil {+ *dfsp = []string{}+ }+ }+ }+ case isPointer: // E.g., *string+ mfi.merge = func(dst, src pointer) {+ sfpp := src.toStringPtr()+ if *sfpp != nil {+ dfpp := dst.toStringPtr()+ if *dfpp == nil {+ *dfpp = String(**sfpp)+ } else {+ **dfpp = **sfpp+ }+ }+ }+ default: // E.g., string+ mfi.merge = func(dst, src pointer) {+ if v := *src.toString(); v != "" {+ *dst.toString() = v+ }+ }+ }+ case reflect.Slice:+ isProto3 := props.Prop[i].proto3+ switch {+ case isPointer:+ panic("bad pointer in byte slice case in " + tf.Name())+ case tf.Elem().Kind() != reflect.Uint8:+ panic("bad element kind in byte slice case in " + tf.Name())+ case isSlice: // E.g., [][]byte+ mfi.merge = func(dst, src pointer) {+ sbsp := src.toBytesSlice()+ if *sbsp != nil {+ dbsp := dst.toBytesSlice()+ for _, sb := range *sbsp {+ if sb == nil {+ *dbsp = append(*dbsp, nil)+ } else {+ *dbsp = append(*dbsp, append([]byte{}, sb...))+ }+ }+ if *dbsp == nil {+ *dbsp = [][]byte{}+ }+ }+ }+ default: // E.g., []byte+ mfi.merge = func(dst, src pointer) {+ sbp := src.toBytes()+ if *sbp != nil {+ dbp := dst.toBytes()+ if !isProto3 || len(*sbp) > 0 {+ *dbp = append([]byte{}, *sbp...)+ }+ }+ }+ }+ case reflect.Struct:+ switch {+ case !isPointer:+ panic(fmt.Sprintf("message field %s without pointer", tf))+ case isSlice: // E.g., []*pb.T+ mi := getMergeInfo(tf)+ mfi.merge = func(dst, src pointer) {+ sps := src.getPointerSlice()+ if sps != nil {+ dps := dst.getPointerSlice()+ for _, sp := range sps {+ var dp pointer+ if !sp.isNil() {+ dp = valToPointer(reflect.New(tf))+ mi.merge(dp, sp)+ }+ dps = append(dps, dp)+ }+ if dps == nil {+ dps = []pointer{}+ }+ dst.setPointerSlice(dps)+ }+ }+ default: // E.g., *pb.T+ mi := getMergeInfo(tf)+ mfi.merge = func(dst, src pointer) {+ sp := src.getPointer()+ if !sp.isNil() {+ dp := dst.getPointer()+ if dp.isNil() {+ dp = valToPointer(reflect.New(tf))+ dst.setPointer(dp)+ }+ mi.merge(dp, sp)+ }+ }+ }+ case reflect.Map:+ switch {+ case isPointer || isSlice:+ panic("bad pointer or slice in map case in " + tf.Name())+ default: // E.g., map[K]V+ mfi.merge = func(dst, src pointer) {+ sm := src.asPointerTo(tf).Elem()+ if sm.Len() == 0 {+ return+ }+ dm := dst.asPointerTo(tf).Elem()+ if dm.IsNil() {+ dm.Set(reflect.MakeMap(tf))+ }++ switch tf.Elem().Kind() {+ case reflect.Ptr: // Proto struct (e.g., *T)+ for _, key := range sm.MapKeys() {+ val := sm.MapIndex(key)+ val = reflect.ValueOf(Clone(val.Interface().(Message)))+ dm.SetMapIndex(key, val)+ }+ case reflect.Slice: // E.g. Bytes type (e.g., []byte)+ for _, key := range sm.MapKeys() {+ val := sm.MapIndex(key)+ val = reflect.ValueOf(append([]byte{}, val.Bytes()...))+ dm.SetMapIndex(key, val)+ }+ default: // Basic type (e.g., string)+ for _, key := range sm.MapKeys() {+ val := sm.MapIndex(key)+ dm.SetMapIndex(key, val)+ }+ }+ }+ }+ case reflect.Interface:+ // Must be oneof field.+ switch {+ case isPointer || isSlice:+ panic("bad pointer or slice in interface case in " + tf.Name())+ default: // E.g., interface{}+ // TODO: Make this faster?+ mfi.merge = func(dst, src pointer) {+ su := src.asPointerTo(tf).Elem()+ if !su.IsNil() {+ du := dst.asPointerTo(tf).Elem()+ typ := su.Elem().Type()+ if du.IsNil() || du.Elem().Type() != typ {+ du.Set(reflect.New(typ.Elem())) // Initialize interface if empty+ }+ sv := su.Elem().Elem().Field(0)+ if sv.Kind() == reflect.Ptr && sv.IsNil() {+ return+ }+ dv := du.Elem().Elem().Field(0)+ if dv.Kind() == reflect.Ptr && dv.IsNil() {+ dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty+ }+ switch sv.Type().Kind() {+ case reflect.Ptr: // Proto struct (e.g., *T)+ Merge(dv.Interface().(Message), sv.Interface().(Message))+ case reflect.Slice: // E.g. Bytes type (e.g., []byte)+ dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...)))+ default: // Basic type (e.g., string)+ dv.Set(sv)+ }+ }+ }+ }+ default:+ panic(fmt.Sprintf("merger not found for type:%s", tf))+ }+ mi.fields = append(mi.fields, mfi)+ }++ mi.unrecognized = invalidField+ if f, ok := t.FieldByName("XXX_unrecognized"); ok {+ if f.Type != reflect.TypeOf([]byte{}) {+ panic("expected XXX_unrecognized to be of type []byte")+ }+ mi.unrecognized = toField(&f)+ }++ atomic.StoreInt32(&mi.initialized, 1)+}diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.gonew file mode 100644index 000000000..ebf1caa56--- /dev/null+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go@@ -0,0 +1,2051 @@+// Go support for Protocol Buffers - Google's data interchange format+//+// Copyright 2016 The Go Authors. All rights reserved.+// https://github.com/golang/protobuf+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++package proto++import (+ "errors"+ "fmt"+ "io"+ "math"+ "reflect"+ "strconv"+ "strings"+ "sync"+ "sync/atomic"+ "unicode/utf8"+)++// Unmarshal is the entry point from the generated .pb.go files.+// This function is not intended to be used by non-generated code.+// This function is not subject to any compatibility guarantee.+// msg contains a pointer to a protocol buffer struct.+// b is the data to be unmarshaled into the protocol buffer.+// a is a pointer to a place to store cached unmarshal information.+func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {+ // Load the unmarshal information for this message type.+ // The atomic load ensures memory consistency.+ u := atomicLoadUnmarshalInfo(&a.unmarshal)+ if u == nil {+ // Slow path: find unmarshal info for msg, update a with it.+ u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())+ atomicStoreUnmarshalInfo(&a.unmarshal, u)+ }+ // Then do the unmarshaling.+ err := u.unmarshal(toPointer(&msg), b)+ return err+}++type unmarshalInfo struct {+ typ reflect.Type // type of the protobuf struct++ // 0 = only typ field is initialized+ // 1 = completely initialized+ initialized int32+ lock sync.Mutex // prevents double initialization+ dense []unmarshalFieldInfo // fields indexed by tag #+ sparse map[uint64]unmarshalFieldInfo // fields indexed by tag #+ reqFields []string // names of required fields+ reqMask uint64 // 1<<len(reqFields)-1+ unrecognized field // offset of []byte to put unrecognized data (or invalidField if we should throw it away)+ extensions field // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist+ oldExtensions field // offset of old-form extensions field (of type map[int]Extension)+ extensionRanges []ExtensionRange // if non-nil, implies extensions field is valid+ isMessageSet bool // if true, implies extensions field is valid+}++// An unmarshaler takes a stream of bytes and a pointer to a field of a message.+// It decodes the field, stores it at f, and returns the unused bytes.+// w is the wire encoding.+// b is the data after the tag and wire encoding have been read.+type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)++type unmarshalFieldInfo struct {+ // location of the field in the proto message structure.+ field field++ // function to unmarshal the data for the field.+ unmarshal unmarshaler++ // if a required field, contains a single set bit at this field's index in the required field list.+ reqMask uint64++ name string // name of the field, for error reporting+}++var (+ unmarshalInfoMap = map[reflect.Type]*unmarshalInfo{}+ unmarshalInfoLock sync.Mutex+)++// getUnmarshalInfo returns the data structure which can be+// subsequently used to unmarshal a message of the given type.+// t is the type of the message (note: not pointer to message).+func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {+ // It would be correct to return a new unmarshalInfo+ // unconditionally. We would end up allocating one+ // per occurrence of that type as a message or submessage.+ // We use a cache here just to reduce memory usage.+ unmarshalInfoLock.Lock()+ defer unmarshalInfoLock.Unlock()+ u := unmarshalInfoMap[t]+ if u == nil {+ u = &unmarshalInfo{typ: t}+ // Note: we just set the type here. The rest of the fields+ // will be initialized on first use.+ unmarshalInfoMap[t] = u+ }+ return u+}++// unmarshal does the main work of unmarshaling a message.+// u provides type information used to unmarshal the message.+// m is a pointer to a protocol buffer message.+// b is a byte stream to unmarshal into m.+// This is top routine used when recursively unmarshaling submessages.+func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {+ if atomic.LoadInt32(&u.initialized) == 0 {+ u.computeUnmarshalInfo()+ }+ if u.isMessageSet {+ return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions())+ }+ var reqMask uint64 // bitmask of required fields we've seen.+ var errLater error+ for len(b) > 0 {+ // Read tag and wire type.+ // Special case 1 and 2 byte varints.+ var x uint64+ if b[0] < 128 {+ x = uint64(b[0])+ b = b[1:]+ } else if len(b) >= 2 && b[1] < 128 {+ x = uint64(b[0]&0x7f) + uint64(b[1])<<7+ b = b[2:]+ } else {+ var n int+ x, n = decodeVarint(b)+ if n == 0 {+ return io.ErrUnexpectedEOF+ }+ b = b[n:]+ }+ tag := x >> 3+ wire := int(x) & 7++ // Dispatch on the tag to one of the unmarshal* functions below.+ var f unmarshalFieldInfo+ if tag < uint64(len(u.dense)) {+ f = u.dense[tag]+ } else {+ f = u.sparse[tag]+ }+ if fn := f.unmarshal; fn != nil {+ var err error+ b, err = fn(b, m.offset(f.field), wire)+ if err == nil {+ reqMask |= f.reqMask+ continue+ }+ if r, ok := err.(*RequiredNotSetError); ok {+ // Remember this error, but keep parsing. We need to produce+ // a full parse even if a required field is missing.+ if errLater == nil {+ errLater = r+ }+ reqMask |= f.reqMask+ continue+ }+ if err != errInternalBadWireType {+ if err == errInvalidUTF8 {+ if errLater == nil {+ fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name+ errLater = &invalidUTF8Error{fullName}+ }+ continue+ }+ return err+ }+ // Fragments with bad wire type are treated as unknown fields.+ }++ // Unknown tag.+ if !u.unrecognized.IsValid() {+ // Don't keep unrecognized data; just skip it.+ var err error+ b, err = skipField(b, wire)+ if err != nil {+ return err+ }+ continue+ }+ // Keep unrecognized data around.+ // maybe in extensions, maybe in the unrecognized field.+ z := m.offset(u.unrecognized).toBytes()+ var emap map[int32]Extension+ var e Extension+ for _, r := range u.extensionRanges {+ if uint64(r.Start) <= tag && tag <= uint64(r.End) {+ if u.extensions.IsValid() {+ mp := m.offset(u.extensions).toExtensions()+ emap = mp.extensionsWrite()+ e = emap[int32(tag)]+ z = &e.enc+ break+ }+ if u.oldExtensions.IsValid() {+ p := m.offset(u.oldExtensions).toOldExtensions()+ emap = *p+ if emap == nil {+ emap = map[int32]Extension{}+ *p = emap+ }+ e = emap[int32(tag)]+ z = &e.enc+ break+ }+ panic("no extensions field available")+ }+ }++ // Use wire type to skip data.+ var err error+ b0 := b+ b, err = skipField(b, wire)+ if err != nil {+ return err+ }+ *z = encodeVarint(*z, tag<<3|uint64(wire))+ *z = append(*z, b0[:len(b0)-len(b)]...)++ if emap != nil {+ emap[int32(tag)] = e+ }+ }+ if reqMask != u.reqMask && errLater == nil {+ // A required field of this message is missing.+ for _, n := range u.reqFields {+ if reqMask&1 == 0 {+ errLater = &RequiredNotSetError{n}+ }+ reqMask >>= 1+ }+ }+ return errLater+}++// computeUnmarshalInfo fills in u with information for use+// in unmarshaling protocol buffers of type u.typ.+func (u *unmarshalInfo) computeUnmarshalInfo() {+ u.lock.Lock()+ defer u.lock.Unlock()+ if u.initialized != 0 {+ return+ }+ t := u.typ+ n := t.NumField()++ // Set up the "not found" value for the unrecognized byte buffer.+ // This is the default for proto3.+ u.unrecognized = invalidField+ u.extensions = invalidField+ u.oldExtensions = invalidField++ // List of the generated type and offset for each oneof field.+ type oneofField struct {+ ityp reflect.Type // interface type of oneof field+ field field // offset in containing message+ }+ var oneofFields []oneofField++ for i := 0; i < n; i++ {+ f := t.Field(i)+ if f.Name == "XXX_unrecognized" {+ // The byte slice used to hold unrecognized input is special.+ if f.Type != reflect.TypeOf(([]byte)(nil)) {+ panic("bad type for XXX_unrecognized field: " + f.Type.Name())+ }+ u.unrecognized = toField(&f)+ continue+ }+ if f.Name == "XXX_InternalExtensions" {+ // Ditto here.+ if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {+ panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())+ }+ u.extensions = toField(&f)+ if f.Tag.Get("protobuf_messageset") == "1" {+ u.isMessageSet = true+ }+ continue+ }+ if f.Name == "XXX_extensions" {+ // An older form of the extensions field.+ if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {+ panic("bad type for XXX_extensions field: " + f.Type.Name())+ }+ u.oldExtensions = toField(&f)+ continue+ }+ if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {+ continue+ }++ oneof := f.Tag.Get("protobuf_oneof")+ if oneof != "" {+ oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})+ // The rest of oneof processing happens below.+ continue+ }++ tags := f.Tag.Get("protobuf")+ tagArray := strings.Split(tags, ",")+ if len(tagArray) < 2 {+ panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)+ }+ tag, err := strconv.Atoi(tagArray[1])+ if err != nil {+ panic("protobuf tag field not an integer: " + tagArray[1])+ }++ name := ""+ for _, tag := range tagArray[3:] {+ if strings.HasPrefix(tag, "name=") {+ name = tag[5:]+ }+ }++ // Extract unmarshaling function from the field (its type and tags).+ unmarshal := fieldUnmarshaler(&f)++ // Required field?+ var reqMask uint64+ if tagArray[2] == "req" {+ bit := len(u.reqFields)+ u.reqFields = append(u.reqFields, name)+ reqMask = uint64(1) << uint(bit)+ // TODO: if we have more than 64 required fields, we end up+ // not verifying that all required fields are present.+ // Fix this, perhaps using a count of required fields?+ }++ // Store the info in the correct slot in the message.+ u.setTag(tag, toField(&f), unmarshal, reqMask, name)+ }++ // Find any types associated with oneof fields.+ // TODO: XXX_OneofFuncs returns more info than we need. Get rid of some of it?+ fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs")+ if fn.IsValid() {+ res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{}+ for i := res.Len() - 1; i >= 0; i-- {+ v := res.Index(i) // interface{}+ tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X+ typ := tptr.Elem() // Msg_X++ f := typ.Field(0) // oneof implementers have one field+ baseUnmarshal := fieldUnmarshaler(&f)+ tags := strings.Split(f.Tag.Get("protobuf"), ",")+ fieldNum, err := strconv.Atoi(tags[1])+ if err != nil {+ panic("protobuf tag field not an integer: " + tags[1])+ }+ var name string+ for _, tag := range tags {+ if strings.HasPrefix(tag, "name=") {+ name = strings.TrimPrefix(tag, "name=")+ break+ }+ }++ // Find the oneof field that this struct implements.+ // Might take O(n^2) to process all of the oneofs, but who cares.+ for _, of := range oneofFields {+ if tptr.Implements(of.ityp) {+ // We have found the corresponding interface for this struct.+ // That lets us know where this struct should be stored+ // when we encounter it during unmarshaling.+ unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)+ u.setTag(fieldNum, of.field, unmarshal, 0, name)+ }+ }+ }+ }++ // Get extension ranges, if any.+ fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")+ if fn.IsValid() {+ if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {+ panic("a message with extensions, but no extensions field in " + t.Name())+ }+ u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)+ }++ // Explicitly disallow tag 0. This will ensure we flag an error+ // when decoding a buffer of all zeros. Without this code, we+ // would decode and skip an all-zero buffer of even length.+ // [0 0] is [tag=0/wiretype=varint varint-encoded-0].+ u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {+ return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)+ }, 0, "")++ // Set mask for required field check.+ u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1++ atomic.StoreInt32(&u.initialized, 1)+}++// setTag stores the unmarshal information for the given tag.+// tag = tag # for field+// field/unmarshal = unmarshal info for that field.+// reqMask = if required, bitmask for field position in required field list. 0 otherwise.+// name = short name of the field.+func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {+ i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}+ n := u.typ.NumField()+ if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?+ for len(u.dense) <= tag {+ u.dense = append(u.dense, unmarshalFieldInfo{})+ }+ u.dense[tag] = i+ return+ }+ if u.sparse == nil {+ u.sparse = map[uint64]unmarshalFieldInfo{}+ }+ u.sparse[uint64(tag)] = i+}++// fieldUnmarshaler returns an unmarshaler for the given field.+func fieldUnmarshaler(f *reflect.StructField) unmarshaler {+ if f.Type.Kind() == reflect.Map {+ return makeUnmarshalMap(f)+ }+ return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))+}++// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.+func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {+ tagArray := strings.Split(tags, ",")+ encoding := tagArray[0]+ name := "unknown"+ proto3 := false+ validateUTF8 := true+ for _, tag := range tagArray[3:] {+ if strings.HasPrefix(tag, "name=") {+ name = tag[5:]+ }+ if tag == "proto3" {+ proto3 = true+ }+ }+ validateUTF8 = validateUTF8 && proto3++ // Figure out packaging (pointer, slice, or both)+ slice := false+ pointer := false+ if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {+ slice = true+ t = t.Elem()+ }+ if t.Kind() == reflect.Ptr {+ pointer = true+ t = t.Elem()+ }++ // We'll never have both pointer and slice for basic types.+ if pointer && slice && t.Kind() != reflect.Struct {+ panic("both pointer and slice for basic type in " + t.Name())+ }++ switch t.Kind() {+ case reflect.Bool:+ if pointer {+ return unmarshalBoolPtr+ }+ if slice {+ return unmarshalBoolSlice+ }+ return unmarshalBoolValue+ case reflect.Int32:+ switch encoding {+ case "fixed32":+ if pointer {+ return unmarshalFixedS32Ptr+ }+ if slice {+ return unmarshalFixedS32Slice+ }+ return unmarshalFixedS32Value+ case "varint":+ // this could be int32 or enum+ if pointer {+ return unmarshalInt32Ptr+ }+ if slice {+ return unmarshalInt32Slice+ }+ return unmarshalInt32Value+ case "zigzag32":+ if pointer {+ return unmarshalSint32Ptr+ }+ if slice {+ return unmarshalSint32Slice+ }+ return unmarshalSint32Value+ }+ case reflect.Int64:+ switch encoding {+ case "fixed64":+ if pointer {+ return unmarshalFixedS64Ptr+ }+ if slice {+ return unmarshalFixedS64Slice+ }+ return unmarshalFixedS64Value+ case "varint":+ if pointer {+ return unmarshalInt64Ptr+ }+ if slice {+ return unmarshalInt64Slice+ }+ return unmarshalInt64Value+ case "zigzag64":+ if pointer {+ return unmarshalSint64Ptr+ }+ if slice {+ return unmarshalSint64Slice+ }+ return unmarshalSint64Value+ }+ case reflect.Uint32:+ switch encoding {+ case "fixed32":+ if pointer {+ return unmarshalFixed32Ptr+ }+ if slice {+ return unmarshalFixed32Slice+ }+ return unmarshalFixed32Value+ case "varint":+ if pointer {+ return unmarshalUint32Ptr+ }+ if slice {+ return unmarshalUint32Slice+ }+ return unmarshalUint32Value+ }+ case reflect.Uint64:+ switch encoding {+ case "fixed64":+ if pointer {+ return unmarshalFixed64Ptr+ }+ if slice {+ return unmarshalFixed64Slice+ }+ return unmarshalFixed64Value+ case "varint":+ if pointer {+ return unmarshalUint64Ptr+ }+ if slice {+ return unmarshalUint64Slice+ }+ return unmarshalUint64Value+ }+ case reflect.Float32:+ if pointer {+ return unmarshalFloat32Ptr+ }+ if slice {+ return unmarshalFloat32Slice+ }+ return unmarshalFloat32Value+ case reflect.Float64:+ if pointer {+ return unmarshalFloat64Ptr+ }+ if slice {+ return unmarshalFloat64Slice+ }+ return unmarshalFloat64Value+ case reflect.Map:+ panic("map type in typeUnmarshaler in " + t.Name())+ case reflect.Slice:+ if pointer {+ panic("bad pointer in slice case in " + t.Name())+ }+ if slice {+ return unmarshalBytesSlice+ }+ return unmarshalBytesValue+ case reflect.String:+ if validateUTF8 {+ if pointer {+ return unmarshalUTF8StringPtr+ }+ if slice {+ return unmarshalUTF8StringSlice+ }+ return unmarshalUTF8StringValue+ }+ if pointer {+ return unmarshalStringPtr+ }+ if slice {+ return unmarshalStringSlice+ }+ return unmarshalStringValue+ case reflect.Struct:+ // message or group field+ if !pointer {+ panic(fmt.Sprintf("message/group field %s:%s without pointer", t, encoding))+ }+ switch encoding {+ case "bytes":+ if slice {+ return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)+ }+ return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)+ case "group":+ if slice {+ return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)+ }+ return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)+ }+ }+ panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))+}++// Below are all the unmarshalers for individual fields of various types.++func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x)+ *f.toInt64() = v+ return b, nil+}++func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x)+ *f.toInt64Ptr() = &v+ return b, nil+}++func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x)+ s := f.toInt64Slice()+ *s = append(*s, v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x)+ s := f.toInt64Slice()+ *s = append(*s, v)+ return b, nil+}++func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x>>1) ^ int64(x)<<63>>63+ *f.toInt64() = v+ return b, nil+}++func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x>>1) ^ int64(x)<<63>>63+ *f.toInt64Ptr() = &v+ return b, nil+}++func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x>>1) ^ int64(x)<<63>>63+ s := f.toInt64Slice()+ *s = append(*s, v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int64(x>>1) ^ int64(x)<<63>>63+ s := f.toInt64Slice()+ *s = append(*s, v)+ return b, nil+}++func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint64(x)+ *f.toUint64() = v+ return b, nil+}++func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint64(x)+ *f.toUint64Ptr() = &v+ return b, nil+}++func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint64(x)+ s := f.toUint64Slice()+ *s = append(*s, v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint64(x)+ s := f.toUint64Slice()+ *s = append(*s, v)+ return b, nil+}++func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x)+ *f.toInt32() = v+ return b, nil+}++func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x)+ f.setInt32Ptr(v)+ return b, nil+}++func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x)+ f.appendInt32Slice(v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x)+ f.appendInt32Slice(v)+ return b, nil+}++func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x>>1) ^ int32(x)<<31>>31+ *f.toInt32() = v+ return b, nil+}++func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x>>1) ^ int32(x)<<31>>31+ f.setInt32Ptr(v)+ return b, nil+}++func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x>>1) ^ int32(x)<<31>>31+ f.appendInt32Slice(v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := int32(x>>1) ^ int32(x)<<31>>31+ f.appendInt32Slice(v)+ return b, nil+}++func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint32(x)+ *f.toUint32() = v+ return b, nil+}++func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint32(x)+ *f.toUint32Ptr() = &v+ return b, nil+}++func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint32(x)+ s := f.toUint32Slice()+ *s = append(*s, v)+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ v := uint32(x)+ s := f.toUint32Slice()+ *s = append(*s, v)+ return b, nil+}++func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56+ *f.toUint64() = v+ return b[8:], nil+}++func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56+ *f.toUint64Ptr() = &v+ return b[8:], nil+}++func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56+ s := f.toUint64Slice()+ *s = append(*s, v)+ b = b[8:]+ }+ return res, nil+ }+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56+ s := f.toUint64Slice()+ *s = append(*s, v)+ return b[8:], nil+}++func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56+ *f.toInt64() = v+ return b[8:], nil+}++func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56+ *f.toInt64Ptr() = &v+ return b[8:], nil+}++func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56+ s := f.toInt64Slice()+ *s = append(*s, v)+ b = b[8:]+ }+ return res, nil+ }+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56+ s := f.toInt64Slice()+ *s = append(*s, v)+ return b[8:], nil+}++func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24+ *f.toUint32() = v+ return b[4:], nil+}++func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24+ *f.toUint32Ptr() = &v+ return b[4:], nil+}++func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24+ s := f.toUint32Slice()+ *s = append(*s, v)+ b = b[4:]+ }+ return res, nil+ }+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24+ s := f.toUint32Slice()+ *s = append(*s, v)+ return b[4:], nil+}++func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24+ *f.toInt32() = v+ return b[4:], nil+}++func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24+ f.setInt32Ptr(v)+ return b[4:], nil+}++func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24+ f.appendInt32Slice(v)+ b = b[4:]+ }+ return res, nil+ }+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24+ f.appendInt32Slice(v)+ return b[4:], nil+}++func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ // Note: any length varint is allowed, even though any sane+ // encoder will use one byte.+ // See https://github.com/golang/protobuf/issues/76+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ // TODO: check if x>1? Tests seem to indicate no.+ v := x != 0+ *f.toBool() = v+ return b[n:], nil+}++func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ v := x != 0+ *f.toBoolPtr() = &v+ return b[n:], nil+}++func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ x, n = decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ v := x != 0+ s := f.toBoolSlice()+ *s = append(*s, v)+ b = b[n:]+ }+ return res, nil+ }+ if w != WireVarint {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ v := x != 0+ s := f.toBoolSlice()+ *s = append(*s, v)+ return b[n:], nil+}++func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)+ *f.toFloat64() = v+ return b[8:], nil+}++func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)+ *f.toFloat64Ptr() = &v+ return b[8:], nil+}++func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)+ s := f.toFloat64Slice()+ *s = append(*s, v)+ b = b[8:]+ }+ return res, nil+ }+ if w != WireFixed64 {+ return b, errInternalBadWireType+ }+ if len(b) < 8 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)+ s := f.toFloat64Slice()+ *s = append(*s, v)+ return b[8:], nil+}++func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)+ *f.toFloat32() = v+ return b[4:], nil+}++func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)+ *f.toFloat32Ptr() = &v+ return b[4:], nil+}++func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {+ if w == WireBytes { // packed+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ res := b[x:]+ b = b[:x]+ for len(b) > 0 {+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)+ s := f.toFloat32Slice()+ *s = append(*s, v)+ b = b[4:]+ }+ return res, nil+ }+ if w != WireFixed32 {+ return b, errInternalBadWireType+ }+ if len(b) < 4 {+ return nil, io.ErrUnexpectedEOF+ }+ v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)+ s := f.toFloat32Slice()+ *s = append(*s, v)+ return b[4:], nil+}++func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ *f.toString() = v+ return b[x:], nil+}++func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ *f.toStringPtr() = &v+ return b[x:], nil+}++func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ s := f.toStringSlice()+ *s = append(*s, v)+ return b[x:], nil+}++func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ *f.toString() = v+ if !utf8.ValidString(v) {+ return b[x:], errInvalidUTF8+ }+ return b[x:], nil+}++func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ *f.toStringPtr() = &v+ if !utf8.ValidString(v) {+ return b[x:], errInvalidUTF8+ }+ return b[x:], nil+}++func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := string(b[:x])+ s := f.toStringSlice()+ *s = append(*s, v)+ if !utf8.ValidString(v) {+ return b[x:], errInvalidUTF8+ }+ return b[x:], nil+}++var emptyBuf [0]byte++func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ // The use of append here is a trick which avoids the zeroing+ // that would be required if we used a make/copy pair.+ // We append to emptyBuf instead of nil because we want+ // a non-nil result even when the length is 0.+ v := append(emptyBuf[:], b[:x]...)+ *f.toBytes() = v+ return b[x:], nil+}++func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := append(emptyBuf[:], b[:x]...)+ s := f.toBytesSlice()+ *s = append(*s, v)+ return b[x:], nil+}++func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {+ return func(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ // First read the message field to see if something is there.+ // The semantics of multiple submessages are weird. Instead of+ // the last one winning (as it is for all other fields), multiple+ // submessages are merged.+ v := f.getPointer()+ if v.isNil() {+ v = valToPointer(reflect.New(sub.typ))+ f.setPointer(v)+ }+ err := sub.unmarshal(v, b[:x])+ if err != nil {+ if r, ok := err.(*RequiredNotSetError); ok {+ r.field = name + "." + r.field+ } else {+ return nil, err+ }+ }+ return b[x:], err+ }+}++func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {+ return func(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireBytes {+ return b, errInternalBadWireType+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ v := valToPointer(reflect.New(sub.typ))+ err := sub.unmarshal(v, b[:x])+ if err != nil {+ if r, ok := err.(*RequiredNotSetError); ok {+ r.field = name + "." + r.field+ } else {+ return nil, err+ }+ }+ f.appendPointer(v)+ return b[x:], err+ }+}++func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {+ return func(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireStartGroup {+ return b, errInternalBadWireType+ }+ x, y := findEndGroup(b)+ if x < 0 {+ return nil, io.ErrUnexpectedEOF+ }+ v := f.getPointer()+ if v.isNil() {+ v = valToPointer(reflect.New(sub.typ))+ f.setPointer(v)+ }+ err := sub.unmarshal(v, b[:x])+ if err != nil {+ if r, ok := err.(*RequiredNotSetError); ok {+ r.field = name + "." + r.field+ } else {+ return nil, err+ }+ }+ return b[y:], err+ }+}++func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {+ return func(b []byte, f pointer, w int) ([]byte, error) {+ if w != WireStartGroup {+ return b, errInternalBadWireType+ }+ x, y := findEndGroup(b)+ if x < 0 {+ return nil, io.ErrUnexpectedEOF+ }+ v := valToPointer(reflect.New(sub.typ))+ err := sub.unmarshal(v, b[:x])+ if err != nil {+ if r, ok := err.(*RequiredNotSetError); ok {+ r.field = name + "." + r.field+ } else {+ return nil, err+ }+ }+ f.appendPointer(v)+ return b[y:], err+ }+}++func makeUnmarshalMap(f *reflect.StructField) unmarshaler {+ t := f.Type+ kt := t.Key()+ vt := t.Elem()+ unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))+ unmarshalVal := typeUnmarshaler(vt, f.Tag.Get("protobuf_val"))+ return func(b []byte, f pointer, w int) ([]byte, error) {+ // The map entry is a submessage. Figure out how big it is.+ if w != WireBytes {+ return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)+ }+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ b = b[n:]+ if x > uint64(len(b)) {+ return nil, io.ErrUnexpectedEOF+ }+ r := b[x:] // unused data to return+ b = b[:x] // data for map entry++ // Note: we could use #keys * #values ~= 200 functions+ // to do map decoding without reflection. Probably not worth it.+ // Maps will be somewhat slow. Oh well.++ // Read key and value from data.+ var nerr nonFatal+ k := reflect.New(kt)+ v := reflect.New(vt)+ for len(b) > 0 {+ x, n := decodeVarint(b)+ if n == 0 {+ return nil, io.ErrUnexpectedEOF+ }+ wire := int(x) & 7+ b = b[n:]++ var err error+ switch x >> 3 {+ case 1:+ b, err = unmarshalKey(b, valToPointer(k), wire)+ case 2:+ b, err = unmarshalVal(b, valToPointer(v), wire)+ default:+ err = errInternalBadWireType // skip unknown tag+ }++ if nerr.Merge(err) {+ continue+ }+ if err != errInternalBadWireType {+ return nil, err+ }++ // Skip past unknown fields.+ b, err = skipField(b, wire)+ if err != nil {+ return nil, err+ }+ }++ // Get map, allocate if needed.+ m := f.asPointerTo(t).Elem() // an addressable map[K]T+ if m.IsNil() {+ m.Set(reflect.MakeMap(t))+ }++ // Insert into map.+ m.SetMapIndex(k.Elem(), v.Elem())++ return r, nerr.E+ }+}++// makeUnmarshalOneof makes an unmarshaler for oneof fields.+// for:+// message Msg {+// oneof F {+// int64 X = 1;+// float64 Y = 2;+// }+// }+// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).+// ityp is the interface type of the oneof field (e.g. isMsg_F).+// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).+// Note that this function will be called once for each case in the oneof.+func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {+ sf := typ.Field(0)+ field0 := toField(&sf)+ return func(b []byte, f pointer, w int) ([]byte, error) {+ // Allocate holder for value.+ v := reflect.New(typ)++ // Unmarshal data into holder.+ // We unmarshal into the first field of the holder object.+ var err error+ var nerr nonFatal+ b, err = unmarshal(b, valToPointer(v).offset(field0), w)+ if !nerr.Merge(err) {+ return nil, err+ }++ // Write pointer to holder into target field.+ f.asPointerTo(ityp).Elem().Set(v)++ return b, nerr.E+ }+}++// Error used by decode internally.+var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")++// skipField skips past a field of type wire and returns the remaining bytes.+func skipField(b []byte, wire int) ([]byte, error) {+ switch wire {+ case WireVarint:+ _, k := decodeVarint(b)+ if k == 0 {+ return b, io.ErrUnexpectedEOF+ }+ b = b[k:]+ case WireFixed32:+ if len(b) < 4 {+ return b, io.ErrUnexpectedEOF+ }+ b = b[4:]+ case WireFixed64:+ if len(b) < 8 {+ return b, io.ErrUnexpectedEOF+ }+ b = b[8:]+ case WireBytes:+ m, k := decodeVarint(b)+ if k == 0 || uint64(len(b)-k) < m {+ return b, io.ErrUnexpectedEOF+ }+ b = b[uint64(k)+m:]+ case WireStartGroup:+ _, i := findEndGroup(b)+ if i == -1 {+ return b, io.ErrUnexpectedEOF+ }+ b = b[i:]+ default:+ return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)+ }+ return b, nil+}++// findEndGroup finds the index of the next EndGroup tag.+// Groups may be nested, so the "next" EndGroup tag is the first+// unpaired EndGroup.+// findEndGroup returns the indexes of the start and end of the EndGroup tag.+// Returns (-1,-1) if it can't find one.+func findEndGroup(b []byte) (int, int) {+ depth := 1+ i := 0+ for {+ x, n := decodeVarint(b[i:])+ if n == 0 {+ return -1, -1+ }+ j := i+ i += n+ switch x & 7 {+ case WireVarint:+ _, k := decodeVarint(b[i:])+ if k == 0 {+ return -1, -1+ }+ i += k+ case WireFixed32:+ if len(b)-4 < i {+ return -1, -1+ }+ i += 4+ case WireFixed64:+ if len(b)-8 < i {+ return -1, -1+ }+ i += 8+ case WireBytes:+ m, k := decodeVarint(b[i:])+ if k == 0 {+ return -1, -1+ }+ i += k+ if uint64(len(b)-i) < m {+ return -1, -1+ }+ i += int(m)+ case WireStartGroup:+ depth+++ case WireEndGroup:+ depth--+ if depth == 0 {+ return j, i+ }+ default:+ return -1, -1+ }+ }+}++// encodeVarint appends a varint-encoded integer to b and returns the result.+func encodeVarint(b []byte, x uint64) []byte {+ for x >= 1<<7 {+ b = append(b, byte(x&0x7f|0x80))+ x >>= 7+ }+ return append(b, byte(x))+}++// decodeVarint reads a varint-encoded integer from b.+// Returns the decoded integer and the number of bytes read.+// If there is an error, it returns 0,0.+func decodeVarint(b []byte) (uint64, int) {+ var x, y uint64+ if len(b) <= 0 {+ goto bad+ }+ x = uint64(b[0])+ if x < 0x80 {+ return x, 1+ }+ x -= 0x80++ if len(b) <= 1 {+ goto bad+ }+ y = uint64(b[1])+ x += y << 7+ if y < 0x80 {+ return x, 2+ }+ x -= 0x80 << 7++ if len(b) <= 2 {+ goto bad+ }+ y = uint64(b[2])+ x += y << 14+ if y < 0x80 {+ return x, 3+ }+ x -= 0x80 << 14++ if len(b) <= 3 {+ goto bad+ }+ y = uint64(b[3])+ x += y << 21+ if y < 0x80 {+ return x, 4+ }+ x -= 0x80 << 21++ if len(b) <= 4 {+ goto bad+ }+ y = uint64(b[4])+ x += y << 28+ if y < 0x80 {+ return x, 5+ }+ x -= 0x80 << 28++ if len(b) <= 5 {+ goto bad+ }+ y = uint64(b[5])+ x += y << 35+ if y < 0x80 {+ return x, 6+ }+ x -= 0x80 << 35++ if len(b) <= 6 {+ goto bad+ }+ y = uint64(b[6])+ x += y << 42+ if y < 0x80 {+ return x, 7+ }+ x -= 0x80 << 42++ if len(b) <= 7 {+ goto bad+ }+ y = uint64(b[7])+ x += y << 49+ if y < 0x80 {+ return x, 8+ }+ x -= 0x80 << 49++ if len(b) <= 8 {+ goto bad+ }+ y = uint64(b[8])+ x += y << 56+ if y < 0x80 {+ return x, 9+ }+ x -= 0x80 << 56++ if len(b) <= 9 {+ goto bad+ }+ y = uint64(b[9])+ x += y << 63+ if y < 2 {+ return x, 10+ }++bad:+ return 0, 0+}diff --git a/vendor/github.com/golang/protobuf/proto/text.go b/vendor/github.com/golang/protobuf/proto/text.goindex 965876bf0..1aaee725b 100644--- a/vendor/github.com/golang/protobuf/proto/text.go+++ b/vendor/github.com/golang/protobuf/proto/text.go@@ -50,7 +50,6 @@ import (var (newline = []byte("\n")spaces = []byte(" ")- gtNewline = []byte(">\n")endBraceNewline = []byte("}\n")backslashN = []byte{'\\', 'n'}backslashR = []byte{'\\', 'r'}@@ -170,11 +169,6 @@ func writeName(w *textWriter, props *Properties) error {return nil}-// raw is the interface satisfied by RawMessage.-type raw interface {- Bytes() []byte-}-func requiresQuotes(u string) bool {// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.for _, ch := range u {@@ -269,6 +263,10 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {props := sprops.Prop[i]name := st.Field(i).Name+ if name == "XXX_NoUnkeyedLiteral" {+ continue+ }+if strings.HasPrefix(name, "XXX_") {// There are two XXX_ fields:// XXX_unrecognized []byte@@ -355,7 +353,7 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {return err}}- if err := tm.writeAny(w, key, props.mkeyprop); err != nil {+ if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {return err}if err := w.WriteByte('\n'); err != nil {@@ -372,7 +370,7 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {return err}}- if err := tm.writeAny(w, val, props.mvalprop); err != nil {+ if err := tm.writeAny(w, val, props.MapValProp); err != nil {return err}if err := w.WriteByte('\n'); err != nil {@@ -436,12 +434,6 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {return err}}- if b, ok := fv.Interface().(raw); ok {- if err := writeRaw(w, b.Bytes()); err != nil {- return err- }- continue- }// Enums have a String method, so writeAny will work fine.if err := tm.writeAny(w, fv, props); err != nil {@@ -455,7 +447,7 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {// Extensions (the XXX_extensions field).pv := sv.Addr()- if _, ok := extendable(pv.Interface()); ok {+ if _, err := extendable(pv.Interface()); err == nil {if err := tm.writeExtensions(w, pv); err != nil {return err}@@ -464,27 +456,6 @@ func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {return nil}-// writeRaw writes an uninterpreted raw message.-func writeRaw(w *textWriter, b []byte) error {- if err := w.WriteByte('<'); err != nil {- return err- }- if !w.compact {- if err := w.WriteByte('\n'); err != nil {- return err- }- }- w.indent()- if err := writeUnknownStruct(w, b); err != nil {- return err- }- w.unindent()- if err := w.WriteByte('>'); err != nil {- return err- }- return nil-}-// writeAny writes an arbitrary field.func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {v = reflect.Indirect(v)@@ -535,6 +506,19 @@ func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Propert}}w.indent()+ if v.CanAddr() {+ // Calling v.Interface on a struct causes the reflect package to+ // copy the entire struct. This is racy with the new Marshaler+ // since we atomically update the XXX_sizecache.+ //+ // Thus, we retrieve a pointer to the struct if possible to avoid+ // a race since v.Interface on the pointer doesn't copy the struct.+ //+ // If v is not addressable, then we are not worried about a race+ // since it implies that the binary Marshaler cannot possibly be+ // mutating this value.+ v = v.Addr()+ }if etm, ok := v.Interface().(encoding.TextMarshaler); ok {text, err := etm.MarshalText()if err != nil {@@ -543,8 +527,13 @@ func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Propertif _, err = w.Write(text); err != nil {return err}- } else if err := tm.writeStruct(w, v); err != nil {- return err+ } else {+ if v.Kind() == reflect.Ptr {+ v = v.Elem()+ }+ if err := tm.writeStruct(w, v); err != nil {+ return err+ }}w.unindent()if err := w.WriteByte(ket); err != nil {diff --git a/vendor/github.com/golang/protobuf/proto/text_parser.go b/vendor/github.com/golang/protobuf/proto/text_parser.goindex 5e14513f2..bb55a3af2 100644--- a/vendor/github.com/golang/protobuf/proto/text_parser.go+++ b/vendor/github.com/golang/protobuf/proto/text_parser.go@@ -206,7 +206,6 @@ func (p *textParser) advance() {var (errBadUTF8 = errors.New("proto: bad UTF-8")- errBadHex = errors.New("proto: bad hexadecimal"))func unquoteC(s string, quote rune) (string, error) {@@ -277,60 +276,47 @@ func unescape(s string) (ch string, tail string, err error) {return "?", s, nil // trigraph workaroundcase '\'', '"', '\\':return string(r), s, nil- case '0', '1', '2', '3', '4', '5', '6', '7', 'x', 'X':+ case '0', '1', '2', '3', '4', '5', '6', '7':if len(s) < 2 {return "", "", fmt.Errorf(`\%c requires 2 following digits`, r)}- base := 8- ss := s[:2]+ ss := string(r) + s[:2]s = s[2:]- if r == 'x' || r == 'X' {- base = 16- } else {- ss = string(r) + ss- }- i, err := strconv.ParseUint(ss, base, 8)+ i, err := strconv.ParseUint(ss, 8, 8)if err != nil {- return "", "", err+ return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss)}return string([]byte{byte(i)}), s, nil- case 'u', 'U':- n := 4- if r == 'U' {+ case 'x', 'X', 'u', 'U':+ var n int+ switch r {+ case 'x', 'X':+ n = 2+ case 'u':+ n = 4+ case 'U':n = 8}if len(s) < n {- return "", "", fmt.Errorf(`\%c requires %d digits`, r, n)- }-- bs := make([]byte, n/2)- for i := 0; i < n; i += 2 {- a, ok1 := unhex(s[i])- b, ok2 := unhex(s[i+1])- if !ok1 || !ok2 {- return "", "", errBadHex- }- bs[i/2] = a<<4 | b+ return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n)}+ ss := s[:n]s = s[n:]- return string(bs), s, nil+ i, err := strconv.ParseUint(ss, 16, 64)+ if err != nil {+ return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss)+ }+ if r == 'x' || r == 'X' {+ return string([]byte{byte(i)}), s, nil+ }+ if i > utf8.MaxRune {+ return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss)+ }+ return string(i), s, nil}return "", "", fmt.Errorf(`unknown escape \%c`, r)}-// Adapted from src/pkg/strconv/quote.go.-func unhex(b byte) (v byte, ok bool) {- switch {- case '0' <= b && b <= '9':- return b - '0', true- case 'a' <= b && b <= 'f':- return b - 'a' + 10, true- case 'A' <= b && b <= 'F':- return b - 'A' + 10, true- }- return 0, false-}-// Back off the parser by one token. Can only be done between calls to next().// It makes the next advance() a no-op.func (p *textParser) back() { p.backed = true }@@ -644,17 +630,17 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) error {if err := p.consumeToken(":"); err != nil {return err}- if err := p.readAny(key, props.mkeyprop); err != nil {+ if err := p.readAny(key, props.MapKeyProp); err != nil {return err}if err := p.consumeOptionalSeparator(); err != nil {return err}case "value":- if err := p.checkForColon(props.mvalprop, dst.Type().Elem()); err != nil {+ if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil {return err}- if err := p.readAny(val, props.mvalprop); err != nil {+ if err := p.readAny(val, props.MapValProp); err != nil {return err}if err := p.consumeOptionalSeparator(); err != nil {@@ -728,6 +714,9 @@ func (p *textParser) consumeExtName() (string, error) {if tok.err != nil {return "", p.errorf("unrecognized type_url or extension name: %s", tok.err)}+ if p.done && tok.value != "]" {+ return "", p.errorf("unclosed type_url or extension name")+ }}return strings.Join(parts, ""), nil}@@ -865,7 +854,7 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {return p.readStruct(fv, terminator)case reflect.Uint32:if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil {- fv.SetUint(x)+ fv.SetUint(uint64(x))return nil}case reflect.Uint64:@@ -883,13 +872,9 @@ func (p *textParser) readAny(v reflect.Value, props *Properties) error {// UnmarshalText returns *RequiredNotSetError.func UnmarshalText(s string, pb Message) error {if um, ok := pb.(encoding.TextUnmarshaler); ok {- err := um.UnmarshalText([]byte(s))- return err+ return um.UnmarshalText([]byte(s))}pb.Reset()v := reflect.ValueOf(pb)- if pe := newTextParser(s).readStruct(v.Elem(), ""); pe != nil {- return pe- }- return nil+ return newTextParser(s).readStruct(v.Elem(), "")}diff --git a/vendor/github.com/gosimple/slug/.travis.yml b/vendor/github.com/gosimple/slug/.travis.ymlnew file mode 100644index 000000000..0ab4df4f4--- /dev/null+++ b/vendor/github.com/gosimple/slug/.travis.yml@@ -0,0 +1,20 @@+language: go++go:+ - "1.x"+ - master+matrix:+ allow_failures:+ - go: master+ fast_finish: true++before_script:+ - go get -t -v ./...+ - go get -v golang.org/x/lint/golint+ - go get -v honnef.co/go/tools/cmd/megacheck+ - go vet ./...+script:+ # run all our tests with race detector+ - go test -v -race ./...+ # "go vet on steroids" + linter+ - megacheck ./...diff --git a/vendor/github.com/gosimple/slug/README.md b/vendor/github.com/gosimple/slug/README.mdindex b1f16b281..5c8b57f89 100644--- a/vendor/github.com/gosimple/slug/README.md+++ b/vendor/github.com/gosimple/slug/README.md@@ -5,45 +5,49 @@ Package `slug` generate slug from unicode string, URL-friendly slugify withmultiple languages support.[](https://godoc.org/github.com/gosimple/slug)-[](https://drone.io/github.com/gosimple/slug/latest)+[](https://travis-ci.com/gosimple/slug)[Documentation online](http://godoc.org/github.com/gosimple/slug)## Example- package main+```go+package main- import(- "github.com/gosimple/slug"- "fmt"- )+import (+ "fmt"+ "github.com/gosimple/slug"+)- func main () {- text := slug.Make("Hellö Wörld хелло ворлд")- fmt.Println(text) // Will print: "hello-world-khello-vorld"+func main() {+ text := slug.Make("Hellö Wörld хелло ворлд")+ fmt.Println(text) // Will print: "hello-world-khello-vorld"- someText := slug.Make("影師")- fmt.Println(someText) // Will print: "ying-shi"+ someText := slug.Make("影師")+ fmt.Println(someText) // Will print: "ying-shi"- enText := slug.MakeLang("This & that", "en")- fmt.Println(enText) // Will print: "this-and-that"+ enText := slug.MakeLang("This & that", "en")+ fmt.Println(enText) // Will print: "this-and-that"- deText := slug.MakeLang("Diese & Dass", "de")- fmt.Println(deText) // Will print: "diese-und-dass"+ deText := slug.MakeLang("Diese & Dass", "de")+ fmt.Println(deText) // Will print: "diese-und-dass"- slug.CustomSub = map[string]string{- "water": "sand",- }- textSub := slug.Make("water is hot")- fmt.Println(textSub) // Will print: "sand-is-hot"+ slug.CustomSub = map[string]string{+ "water": "sand",}+ textSub := slug.Make("water is hot")+ fmt.Println(textSub) // Will print: "sand-is-hot"+}++```### Requests or bugs?<https://github.com/gosimple/slug/issues>## Installation-- go get -u github.com/gosimple/slug+```sh+go get -u github.com/gosimple/slug+```## Licensediff --git a/vendor/github.com/gosimple/slug/languages_substitution.go b/vendor/github.com/gosimple/slug/languages_substitution.goindex ba8ad0181..d6664e261 100644--- a/vendor/github.com/gosimple/slug/languages_substitution.go+++ b/vendor/github.com/gosimple/slug/languages_substitution.go@@ -7,7 +7,9 @@ package slugfunc init() {// Merge language subs with the default one- for _, sub := range []*map[rune]string{&deSub, &enSub, &plSub, &esSub} {+ for _, sub := range []*map[rune]string{+ &deSub, &enSub, &esSub, &fiSub, &grSub, &nlSub, &plSub,+ } {for key, value := range defaultSub {(*sub)[key] = value}@@ -27,6 +29,12 @@ var defaultSub = map[rune]string{var deSub = map[rune]string{'&': "und",'@': "an",+ 'ä': "ae",+ 'Ä': "ae",+ 'ö': "oe",+ 'Ö': "oe",+ 'ü': "ue",+ 'Ü': "ue",}var enSub = map[rune]string{@@ -34,16 +42,16 @@ var enSub = map[rune]string{'@': "at",}-var plSub = map[rune]string{- '&': "i",- '@': "na",-}-var esSub = map[rune]string{'&': "y",'@': "en",}+var fiSub = map[rune]string{+ '&': "ja",+ '@': "at",+}+var grSub = map[rune]string{'&': "kai",'η': "i",@@ -51,7 +59,22 @@ var grSub = map[rune]string{'Η': "i",'ι': "i",'ί': "i",+ 'ϊ': "i",'Ι': "i",'χ': "x",'Χ': "x",+ 'ω': "w",+ 'ώ': "w",+ 'Ω': "w",+ 'ϋ': "u",+}++var nlSub = map[rune]string{+ '&': "en",+ '@': "at",+}++var plSub = map[rune]string{+ '&': "i",+ '@': "na",}diff --git a/vendor/github.com/gosimple/slug/slug.go b/vendor/github.com/gosimple/slug/slug.goindex bd3ec51aa..0c6801ff6 100644--- a/vendor/github.com/gosimple/slug/slug.go+++ b/vendor/github.com/gosimple/slug/slug.go@@ -56,12 +56,16 @@ func MakeLang(s string, lang string) (slug string) {slug = SubstituteRune(slug, deSub)case "en":slug = SubstituteRune(slug, enSub)- case "pl":- slug = SubstituteRune(slug, plSub)case "es":slug = SubstituteRune(slug, esSub)+ case "fi":+ slug = SubstituteRune(slug, fiSub)case "gr":slug = SubstituteRune(slug, grSub)+ case "nl":+ slug = SubstituteRune(slug, nlSub)+ case "pl":+ slug = SubstituteRune(slug, plSub)default: // fallback to "en" if lang not foundslug = SubstituteRune(slug, enSub)}@@ -74,7 +78,7 @@ func MakeLang(s string, lang string) (slug string) {// Process all remaining symbolsslug = regexpNonAuthorizedChars.ReplaceAllString(slug, "-")slug = regexpMultipleDashes.ReplaceAllString(slug, "-")- slug = strings.Trim(slug, "-")+ slug = strings.Trim(slug, "-_")if MaxLength > 0 {slug = smartTruncate(slug)diff --git a/vendor/github.com/lib/pq/.travis.sh b/vendor/github.com/lib/pq/.travis.shindex a297dc452..21a526443 100755--- a/vendor/github.com/lib/pq/.travis.sh+++ b/vendor/github.com/lib/pq/.travis.sh@@ -80,7 +80,7 @@ megacheck_install() {}golint_install() {- go get github.com/golang/lint/golint+ go get golang.org/x/lint/golint}$1diff --git a/vendor/github.com/lib/pq/.travis.yml b/vendor/github.com/lib/pq/.travis.ymlindex 18556e089..f0305809f 100644--- a/vendor/github.com/lib/pq/.travis.yml+++ b/vendor/github.com/lib/pq/.travis.yml@@ -1,9 +1,9 @@language: gogo:- - 1.8.x- 1.9.x- 1.10.x+ - 1.11.x- mastersudo: true@@ -44,7 +44,7 @@ script:- >goimports -d -e $(find -name '*.go') | awk '{ print } END { exit NR == 0 ? 0 : 1 }'- go vet ./...- - megacheck -go 1.8 ./...+ - megacheck -go 1.9 ./...- golint ./...- PQTEST_BINARY_PARAMETERS=no go test -race -v ./...- PQTEST_BINARY_PARAMETERS=yes go test -race -v ./...diff --git a/vendor/github.com/lib/pq/README.md b/vendor/github.com/lib/pq/README.mdindex d71f3c2c3..385fe7350 100644--- a/vendor/github.com/lib/pq/README.md+++ b/vendor/github.com/lib/pq/README.md@@ -10,7 +10,7 @@## DocsFor detailed documentation and basic usage examples, please see the package-documentation at <http://godoc.org/github.com/lib/pq>.+documentation at <https://godoc.org/github.com/lib/pq>.## Testsdiff --git a/vendor/github.com/lib/pq/conn_go18.go b/vendor/github.com/lib/pq/conn_go18.goindex a5254f2b4..81c9ee475 100644--- a/vendor/github.com/lib/pq/conn_go18.go+++ b/vendor/github.com/lib/pq/conn_go18.go@@ -1,5 +1,3 @@-// +build go1.8-package pqimport (diff --git a/vendor/github.com/lib/pq/doc.go b/vendor/github.com/lib/pq/doc.goindex a1b029713..2a60054e2 100644--- a/vendor/github.com/lib/pq/doc.go+++ b/vendor/github.com/lib/pq/doc.go@@ -239,7 +239,7 @@ for more information). Note that the channel name will be truncated to 63bytes by the PostgreSQL server.You can find a complete, working example of Listener usage at-http://godoc.org/github.com/lib/pq/example/listen.+https://godoc.org/github.com/lib/pq/example/listen.*/package pqdiff --git a/vendor/github.com/lib/pq/go.mod b/vendor/github.com/lib/pq/go.modnew file mode 100644index 000000000..edf0b343f--- /dev/null+++ b/vendor/github.com/lib/pq/go.mod@@ -0,0 +1 @@+module github.com/lib/pqdiff --git a/vendor/github.com/lib/pq/notify.go b/vendor/github.com/lib/pq/notify.goindex 947d189f4..850bb9040 100644--- a/vendor/github.com/lib/pq/notify.go+++ b/vendor/github.com/lib/pq/notify.go@@ -725,6 +725,9 @@ func (l *Listener) Close() error {}l.isClosed = true+ // Unblock calls to Listen()+ l.reconnectCond.Broadcast()+return nil}diff --git a/vendor/github.com/lib/pq/ssl.go b/vendor/github.com/lib/pq/ssl.goindex e1a326a0d..d90208455 100644--- a/vendor/github.com/lib/pq/ssl.go+++ b/vendor/github.com/lib/pq/ssl.go@@ -58,7 +58,13 @@ func ssl(o values) (func(net.Conn) (net.Conn, error), error) {if err != nil {return nil, err}- sslRenegotiation(&tlsConf)++ // Accept renegotiation requests initiated by the backend.+ //+ // Renegotiation was deprecated then removed from PostgreSQL 9.5, but+ // the default configuration of older versions has it enabled. Redshift+ // also initiates renegotiations and cannot be reconfigured.+ tlsConf.Renegotiation = tls.RenegotiateFreelyAsClientreturn func(conn net.Conn) (net.Conn, error) {client := tls.Client(conn, &tlsConf)diff --git a/vendor/github.com/lib/pq/ssl_go1.7.go b/vendor/github.com/lib/pq/ssl_go1.7.godeleted file mode 100644index d7ba43b32..000000000--- a/vendor/github.com/lib/pq/ssl_go1.7.go+++ /dev/null@@ -1,14 +0,0 @@-// +build go1.7--package pq--import "crypto/tls"--// Accept renegotiation requests initiated by the backend.-//-// Renegotiation was deprecated then removed from PostgreSQL 9.5, but-// the default configuration of older versions has it enabled. Redshift-// also initiates renegotiations and cannot be reconfigured.-func sslRenegotiation(conf *tls.Config) {- conf.Renegotiation = tls.RenegotiateFreelyAsClient-}diff --git a/vendor/github.com/lib/pq/ssl_renegotiation.go b/vendor/github.com/lib/pq/ssl_renegotiation.godeleted file mode 100644index 85ed5e437..000000000--- a/vendor/github.com/lib/pq/ssl_renegotiation.go+++ /dev/null@@ -1,8 +0,0 @@-// +build !go1.7--package pq--import "crypto/tls"--// Renegotiation is not supported by crypto/tls until Go 1.7.-func sslRenegotiation(*tls.Config) {}diff --git a/vendor/github.com/russross/blackfriday/.travis.yml b/vendor/github.com/russross/blackfriday/.travis.ymlindex a1687f17a..2f3351d7a 100644--- a/vendor/github.com/russross/blackfriday/.travis.yml+++ b/vendor/github.com/russross/blackfriday/.travis.yml@@ -1,26 +1,13 @@sudo: falselanguage: gogo:- - 1.5.4- - 1.6.2+ - "1.9.x"+ - "1.10.x"- tipmatrix:- include:- - go: 1.2.2- script:- - go get -t -v ./...- - go test -v -race ./...- - go: 1.3.3- script:- - go get -t -v ./...- - go test -v -race ./...- - go: 1.4.3- script:- - go get -t -v ./...- - go test -v -race ./...+ fast_finish: trueallow_failures:- go: tip- fast_finish: trueinstall:- # Do nothing. This is needed to prevent default install action "go get -t -v ./..." from happening here (we want it to happen inside script step).script:diff --git a/vendor/github.com/russross/blackfriday/README.md b/vendor/github.com/russross/blackfriday/README.mdindex a6c94b79e..3c62e1375 100644--- a/vendor/github.com/russross/blackfriday/README.md+++ b/vendor/github.com/russross/blackfriday/README.md@@ -34,7 +34,7 @@ developed on its own branch: https://github.com/russross/blackfriday/tree/v2 anddocumentation is available athttps://godoc.org/gopkg.in/russross/blackfriday.v2.-It is `go get`-able via via [gopkg.in][6] at `gopkg.in/russross/blackfriday.v2`,+It is `go get`-able via [gopkg.in][6] at `gopkg.in/russross/blackfriday.v2`,but we highly recommend using package management tool like [dep][7] or[Glide][8] and make use of semantic versioning. With package management youshould import `github.com/russross/blackfriday` and specify that you're using@@ -331,6 +331,12 @@ are a few of note:* [LaTeX output](https://bitbucket.org/ambrevar/blackfriday-latex):renders output as LaTeX.+* [bfchroma](https://github.com/Depado/bfchroma/): provides convenience+ integration with the [Chroma](https://github.com/alecthomas/chroma) code+ highlighting library. bfchroma is only compatible with v2 of Blackfriday and+ provides a drop-in renderer ready to use with Blackfriday, as well as+ options and means for further customization.+TODO----diff --git a/vendor/github.com/russross/blackfriday/block.go b/vendor/github.com/russross/blackfriday/block.goindex 7fc731d54..45c21a6c2 100644--- a/vendor/github.com/russross/blackfriday/block.go+++ b/vendor/github.com/russross/blackfriday/block.go@@ -15,6 +15,7 @@ package blackfridayimport ("bytes"+ "strings""unicode")@@ -92,7 +93,7 @@ func (p *parser) block(out *bytes.Buffer, data []byte) {// fenced code block://- // ``` go+ // ``` go info string here// func fact(n int) int {// if n <= 1 {// return n@@ -562,7 +563,7 @@ func (*parser) isHRule(data []byte) bool {// and returns the end index if so, or 0 otherwise. It also returns the marker found.// If syntax is not nil, it gets set to the syntax specified in the fence line.// A final newline is mandatory to recognize the fence line, unless newlineOptional is true.-func isFenceLine(data []byte, syntax *string, oldmarker string, newlineOptional bool) (end int, marker string) {+func isFenceLine(data []byte, info *string, oldmarker string, newlineOptional bool) (end int, marker string) {i, size := 0, 0// skip up to three spaces@@ -598,9 +599,9 @@ func isFenceLine(data []byte, syntax *string, oldmarker string, newlineOptional}// TODO(shurcooL): It's probably a good idea to simplify the 2 code paths here- // into one, always get the syntax, and discard it if the caller doesn't care.- if syntax != nil {- syn := 0+ // into one, always get the info string, and discard it if the caller doesn't care.+ if info != nil {+ infoLength := 0i = skipChar(data, i, ' ')if i >= len(data) {@@ -610,14 +611,14 @@ func isFenceLine(data []byte, syntax *string, oldmarker string, newlineOptionalreturn 0, ""}- syntaxStart := i+ infoStart := iif data[i] == '{' {i++- syntaxStart+++ infoStart++for i < len(data) && data[i] != '}' && data[i] != '\n' {- syn+++ infoLength++i++}@@ -627,24 +628,24 @@ func isFenceLine(data []byte, syntax *string, oldmarker string, newlineOptional// strip all whitespace at the beginning and the end// of the {} block- for syn > 0 && isspace(data[syntaxStart]) {- syntaxStart++- syn--+ for infoLength > 0 && isspace(data[infoStart]) {+ infoStart+++ infoLength--}- for syn > 0 && isspace(data[syntaxStart+syn-1]) {- syn--+ for infoLength > 0 && isspace(data[infoStart+infoLength-1]) {+ infoLength--}i++} else {- for i < len(data) && !isspace(data[i]) {- syn+++ for i < len(data) && !isverticalspace(data[i]) {+ infoLength++i++}}- *syntax = string(data[syntaxStart : syntaxStart+syn])+ *info = strings.TrimSpace(string(data[infoStart : infoStart+infoLength]))}i = skipChar(data, i, ' ')@@ -662,8 +663,8 @@ func isFenceLine(data []byte, syntax *string, oldmarker string, newlineOptional// or 0 otherwise. It writes to out if doRender is true, otherwise it has no side effects.// If doRender is true, a final newline is mandatory to recognize the fenced code block.func (p *parser) fencedCodeBlock(out *bytes.Buffer, data []byte, doRender bool) int {- var syntax string- beg, marker := isFenceLine(data, &syntax, "", false)+ var infoString string+ beg, marker := isFenceLine(data, &infoString, "", false)if beg == 0 || beg >= len(data) {return 0}@@ -697,7 +698,7 @@ func (p *parser) fencedCodeBlock(out *bytes.Buffer, data []byte, doRender bool)}if doRender {- p.r.BlockCode(out, work.Bytes(), syntax)+ p.r.BlockCode(out, work.Bytes(), infoString)}return beg@@ -1142,6 +1143,7 @@ func (p *parser) listItem(out *bytes.Buffer, data []byte, flags *int) int {// process the following linescontainsBlankLine := falsesublist := 0+ codeBlockMarker := ""gatherlines:for line < len(data) {@@ -1169,6 +1171,28 @@ gatherlines:chunk := data[line+indent : i]+ if p.flags&EXTENSION_FENCED_CODE != 0 {+ // determine if in or out of codeblock+ // if in codeblock, ignore normal list processing+ _, marker := isFenceLine(chunk, nil, codeBlockMarker, false)+ if marker != "" {+ if codeBlockMarker == "" {+ // start of codeblock+ codeBlockMarker = marker+ } else {+ // end of codeblock.+ *flags |= LIST_ITEM_CONTAINS_BLOCK+ codeBlockMarker = ""+ }+ }+ // we are in a codeblock, write line, and continue+ if codeBlockMarker != "" || marker != "" {+ raw.Write(data[line+indent : i])+ line = i+ continue gatherlines+ }+ }+// evaluate how this line fits inswitch {// is this a nested list item?diff --git a/vendor/github.com/russross/blackfriday/go.mod b/vendor/github.com/russross/blackfriday/go.modnew file mode 100644index 000000000..b05561a06--- /dev/null+++ b/vendor/github.com/russross/blackfriday/go.mod@@ -0,0 +1 @@+module github.com/russross/blackfridaydiff --git a/vendor/github.com/russross/blackfriday/html.go b/vendor/github.com/russross/blackfriday/html.goindex c917c7d3f..e0a6c69c9 100644--- a/vendor/github.com/russross/blackfriday/html.go+++ b/vendor/github.com/russross/blackfriday/html.go@@ -255,33 +255,21 @@ func (options *Html) HRule(out *bytes.Buffer) {out.WriteByte('\n')}-func (options *Html) BlockCode(out *bytes.Buffer, text []byte, lang string) {+func (options *Html) BlockCode(out *bytes.Buffer, text []byte, info string) {doubleSpace(out)- // parse out the language names/classes- count := 0- for _, elt := range strings.Fields(lang) {- if elt[0] == '.' {- elt = elt[1:]- }- if len(elt) == 0 {- continue- }- if count == 0 {- out.WriteString("<pre><code class=\"language-")- } else {- out.WriteByte(' ')- }- attrEscape(out, []byte(elt))- count+++ endOfLang := strings.IndexAny(info, "\t ")+ if endOfLang < 0 {+ endOfLang = len(info)}-- if count == 0 {+ lang := info[:endOfLang]+ if len(lang) == 0 || lang == "." {out.WriteString("<pre><code>")} else {+ out.WriteString("<pre><code class=\"language-")+ attrEscape(out, []byte(lang))out.WriteString("\">")}-attrEscape(out, text)out.WriteString("</code></pre>\n")}diff --git a/vendor/github.com/russross/blackfriday/latex.go b/vendor/github.com/russross/blackfriday/latex.goindex 70705aa9c..3d30d0947 100644--- a/vendor/github.com/russross/blackfriday/latex.go+++ b/vendor/github.com/russross/blackfriday/latex.go@@ -17,6 +17,7 @@ package blackfridayimport ("bytes"+ "strings")// Latex is a type that implements the Renderer interface for LaTeX output.@@ -39,16 +40,17 @@ func (options *Latex) GetFlags() int {}// render code chunks using verbatim, or listings if we have a language-func (options *Latex) BlockCode(out *bytes.Buffer, text []byte, lang string) {- if lang == "" {+func (options *Latex) BlockCode(out *bytes.Buffer, text []byte, info string) {+ if info == "" {out.WriteString("\n\\begin{verbatim}\n")} else {+ lang := strings.Fields(info)[0]out.WriteString("\n\\begin{lstlisting}[language=")out.WriteString(lang)out.WriteString("]\n")}out.Write(text)- if lang == "" {+ if info == "" {out.WriteString("\n\\end{verbatim}\n")} else {out.WriteString("\n\\end{lstlisting}\n")diff --git a/vendor/github.com/russross/blackfriday/markdown.go b/vendor/github.com/russross/blackfriday/markdown.goindex 1722a7389..41595d62d 100644--- a/vendor/github.com/russross/blackfriday/markdown.go+++ b/vendor/github.com/russross/blackfriday/markdown.go@@ -159,7 +159,7 @@ var blockTags = map[string]struct{}{// Currently Html and Latex implementations are providedtype Renderer interface {// block-level callbacks- BlockCode(out *bytes.Buffer, text []byte, lang string)+ BlockCode(out *bytes.Buffer, text []byte, infoString string)BlockQuote(out *bytes.Buffer, text []byte)BlockHtml(out *bytes.Buffer, text []byte)Header(out *bytes.Buffer, text func() bool, level int, id string)@@ -804,7 +804,17 @@ func ispunct(c byte) bool {// Test if a character is a whitespace character.func isspace(c byte) bool {- return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f' || c == '\v'+ return ishorizontalspace(c) || isverticalspace(c)+}++// Test if a character is a horizontal whitespace character.+func ishorizontalspace(c byte) bool {+ return c == ' ' || c == '\t'+}++// Test if a character is a vertical whitespace character.+func isverticalspace(c byte) bool {+ return c == '\n' || c == '\r' || c == '\f' || c == '\v'}// Test if a character is letter.diff --git a/vendor/golang.org/x/crypto/acme/acme.go b/vendor/golang.org/x/crypto/acme/acme.goindex 1f4fb69ed..c6fd99896 100644--- a/vendor/golang.org/x/crypto/acme/acme.go+++ b/vendor/golang.org/x/crypto/acme/acme.go@@ -14,7 +14,6 @@package acmeimport (- "bytes""context""crypto""crypto/ecdsa"@@ -23,6 +22,8 @@ import ("crypto/sha256""crypto/tls""crypto/x509"+ "crypto/x509/pkix"+ "encoding/asn1""encoding/base64""encoding/hex""encoding/json"@@ -33,14 +34,26 @@ import ("io/ioutil""math/big""net/http"- "strconv""strings""sync""time")-// LetsEncryptURL is the Directory endpoint of Let's Encrypt CA.-const LetsEncryptURL = "https://acme-v01.api.letsencrypt.org/directory"+const (+ // LetsEncryptURL is the Directory endpoint of Let's Encrypt CA.+ LetsEncryptURL = "https://acme-v01.api.letsencrypt.org/directory"++ // ALPNProto is the ALPN protocol name used by a CA server when validating+ // tls-alpn-01 challenges.+ //+ // Package users must ensure their servers can negotiate the ACME ALPN in+ // order for tls-alpn-01 challenge verifications to succeed.+ // See the crypto/tls package's Config.NextProtos field.+ ALPNProto = "acme-tls/1"+)++// idPeACMEIdentifierV1 is the OID for the ACME extension for the TLS-ALPN challenge.+var idPeACMEIdentifierV1 = asn1.ObjectIdentifier{1, 3, 6, 1, 5, 5, 7, 1, 30, 1}const (maxChainLen = 5 // max depth and breadth of a certificate chain@@ -64,6 +77,10 @@ const (type Client struct {// Key is the account key used to register with a CA and sign requests.// Key.Public() must return a *rsa.PublicKey or *ecdsa.PublicKey.+ //+ // The following algorithms are supported:+ // RS256, ES256, ES384 and ES512.+ // See RFC7518 for more details about the algorithms.Key crypto.Signer// HTTPClient optionally specifies an HTTP client to use@@ -76,6 +93,22 @@ type Client struct {// will have no effect.DirectoryURL string+ // RetryBackoff computes the duration after which the nth retry of a failed request+ // should occur. The value of n for the first call on failure is 1.+ // The values of r and resp are the request and response of the last failed attempt.+ // If the returned value is negative or zero, no more retries are done and an error+ // is returned to the caller of the original method.+ //+ // Requests which result in a 4xx client error are not retried,+ // except for 400 Bad Request due to "bad nonce" errors and 429 Too Many Requests.+ //+ // If RetryBackoff is nil, a truncated exponential backoff algorithm+ // with the ceiling of 10 seconds is used, where each subsequent retry n+ // is done after either ("Retry-After" + jitter) or (2^n seconds + jitter),+ // preferring the former if "Retry-After" header is found in the resp.+ // The jitter is a random value up to 1 second.+ RetryBackoff func(n int, r *http.Request, resp *http.Response) time.Duration+dirMu sync.Mutex // guards writes to dirdir *Directory // cached result of Client's Discover method@@ -99,15 +132,12 @@ func (c *Client) Discover(ctx context.Context) (Directory, error) {if dirURL == "" {dirURL = LetsEncryptURL}- res, err := c.get(ctx, dirURL)+ res, err := c.get(ctx, dirURL, wantStatus(http.StatusOK))if err != nil {return Directory{}, err}defer res.Body.Close()c.addNonce(res.Header)- if res.StatusCode != http.StatusOK {- return Directory{}, responseError(res)- }var v struct {Reg string `json:"new-reg"`@@ -166,14 +196,11 @@ func (c *Client) CreateCert(ctx context.Context, csr []byte, exp time.Duration,req.NotAfter = now.Add(exp).Format(time.RFC3339)}- res, err := c.retryPostJWS(ctx, c.Key, c.dir.CertURL, req)+ res, err := c.post(ctx, c.Key, c.dir.CertURL, req, wantStatus(http.StatusCreated))if err != nil {return nil, "", err}defer res.Body.Close()- if res.StatusCode != http.StatusCreated {- return nil, "", responseError(res)- }curl := res.Header.Get("Location") // cert permanent URLif res.ContentLength == 0 {@@ -196,26 +223,11 @@ func (c *Client) CreateCert(ctx context.Context, csr []byte, exp time.Duration,// Callers are encouraged to parse the returned value to ensure the certificate is valid// and has expected features.func (c *Client) FetchCert(ctx context.Context, url string, bundle bool) ([][]byte, error) {- for {- res, err := c.get(ctx, url)- if err != nil {- return nil, err- }- defer res.Body.Close()- if res.StatusCode == http.StatusOK {- return c.responseCert(ctx, res, bundle)- }- if res.StatusCode > 299 {- return nil, responseError(res)- }- d := retryAfter(res.Header.Get("Retry-After"), 3*time.Second)- select {- case <-time.After(d):- // retry- case <-ctx.Done():- return nil, ctx.Err()- }+ res, err := c.get(ctx, url, wantStatus(http.StatusOK))+ if err != nil {+ return nil, err}+ return c.responseCert(ctx, res, bundle)}// RevokeCert revokes a previously issued certificate cert, provided in DER format.@@ -241,14 +253,11 @@ func (c *Client) RevokeCert(ctx context.Context, key crypto.Signer, cert []byte,if key == nil {key = c.Key}- res, err := c.retryPostJWS(ctx, key, c.dir.RevokeURL, body)+ res, err := c.post(ctx, key, c.dir.RevokeURL, body, wantStatus(http.StatusOK))if err != nil {return err}defer res.Body.Close()- if res.StatusCode != http.StatusOK {- return responseError(res)- }return nil}@@ -329,14 +338,11 @@ func (c *Client) Authorize(ctx context.Context, domain string) (*Authorization,Resource: "new-authz",Identifier: authzID{Type: "dns", Value: domain},}- res, err := c.retryPostJWS(ctx, c.Key, c.dir.AuthzURL, req)+ res, err := c.post(ctx, c.Key, c.dir.AuthzURL, req, wantStatus(http.StatusCreated))if err != nil {return nil, err}defer res.Body.Close()- if res.StatusCode != http.StatusCreated {- return nil, responseError(res)- }var v wireAuthzif err := json.NewDecoder(res.Body).Decode(&v); err != nil {@@ -353,14 +359,11 @@ func (c *Client) Authorize(ctx context.Context, domain string) (*Authorization,// If a caller needs to poll an authorization until its status is final,// see the WaitAuthorization method.func (c *Client) GetAuthorization(ctx context.Context, url string) (*Authorization, error) {- res, err := c.get(ctx, url)+ res, err := c.get(ctx, url, wantStatus(http.StatusOK, http.StatusAccepted))if err != nil {return nil, err}defer res.Body.Close()- if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusAccepted {- return nil, responseError(res)- }var v wireAuthzif err := json.NewDecoder(res.Body).Decode(&v); err != nil {return nil, fmt.Errorf("acme: invalid response: %v", err)@@ -387,14 +390,11 @@ func (c *Client) RevokeAuthorization(ctx context.Context, url string) error {Status: "deactivated",Delete: true,}- res, err := c.retryPostJWS(ctx, c.Key, url, req)+ res, err := c.post(ctx, c.Key, url, req, wantStatus(http.StatusOK))if err != nil {return err}defer res.Body.Close()- if res.StatusCode != http.StatusOK {- return responseError(res)- }return nil}@@ -406,44 +406,42 @@ func (c *Client) RevokeAuthorization(ctx context.Context, url string) error {// In all other cases WaitAuthorization returns an error.// If the Status is StatusInvalid, the returned error is of type *AuthorizationError.func (c *Client) WaitAuthorization(ctx context.Context, url string) (*Authorization, error) {- sleep := sleeper(ctx)for {- res, err := c.get(ctx, url)+ res, err := c.get(ctx, url, wantStatus(http.StatusOK, http.StatusAccepted))if err != nil {return nil, err}- if res.StatusCode >= 400 && res.StatusCode <= 499 {- // Non-retriable error. For instance, Let's Encrypt may return 404 Not Found- // when requesting an expired authorization.- defer res.Body.Close()- return nil, responseError(res)- }- retry := res.Header.Get("Retry-After")- if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusAccepted {- res.Body.Close()- if err := sleep(retry, 1); err != nil {- return nil, err- }- continue- }var raw wireAuthzerr = json.NewDecoder(res.Body).Decode(&raw)res.Body.Close()- if err != nil {- if err := sleep(retry, 0); err != nil {- return nil, err- }- continue- }- if raw.Status == StatusValid {+ switch {+ case err != nil:+ // Skip and retry.+ case raw.Status == StatusValid:return raw.authorization(url), nil- }- if raw.Status == StatusInvalid {+ case raw.Status == StatusInvalid:return nil, raw.error(url)}- if err := sleep(retry, 0); err != nil {- return nil, err++ // Exponential backoff is implemented in c.get above.+ // This is just to prevent continuously hitting the CA+ // while waiting for a final authorization status.+ d := retryAfter(res.Header.Get("Retry-After"))+ if d == 0 {+ // Given that the fastest challenges TLS-SNI and HTTP-01+ // require a CA to make at least 1 network round trip+ // and most likely persist a challenge state,+ // this default delay seems reasonable.+ d = time.Second+ }+ t := time.NewTimer(d)+ select {+ case <-ctx.Done():+ t.Stop()+ return nil, ctx.Err()+ case <-t.C:+ // Retry.}}}@@ -452,14 +450,11 @@ func (c *Client) WaitAuthorization(ctx context.Context, url string) (*Authorizat//// A client typically polls a challenge status using this method.func (c *Client) GetChallenge(ctx context.Context, url string) (*Challenge, error) {- res, err := c.get(ctx, url)+ res, err := c.get(ctx, url, wantStatus(http.StatusOK, http.StatusAccepted))if err != nil {return nil, err}defer res.Body.Close()- if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusAccepted {- return nil, responseError(res)- }v := wireChallenge{URI: url}if err := json.NewDecoder(res.Body).Decode(&v); err != nil {return nil, fmt.Errorf("acme: invalid response: %v", err)@@ -486,16 +481,14 @@ func (c *Client) Accept(ctx context.Context, chal *Challenge) (*Challenge, errorType: chal.Type,Auth: auth,}- res, err := c.retryPostJWS(ctx, c.Key, chal.URI, req)+ res, err := c.post(ctx, c.Key, chal.URI, req, wantStatus(+ http.StatusOK, // according to the spec+ http.StatusAccepted, // Let's Encrypt: see https://goo.gl/WsJ7VT (acme-divergences.md)+ ))if err != nil {return nil, err}defer res.Body.Close()- // Note: the protocol specifies 200 as the expected response code, but- // letsencrypt seems to be returning 202.- if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusAccepted {- return nil, responseError(res)- }var v wireChallengeif err := json.NewDecoder(res.Body).Decode(&v); err != nil {@@ -552,7 +545,7 @@ func (c *Client) HTTP01ChallengePath(token string) string {// If no WithKey option is provided, a new ECDSA key is generated using P-256 curve.//// The returned certificate is valid for the next 24 hours and must be presented only when-// the server name of the client hello matches exactly the returned name value.+// the server name of the TLS ClientHello matches exactly the returned name value.func (c *Client) TLSSNI01ChallengeCert(token string, opt ...CertOption) (cert tls.Certificate, name string, err error) {ka, err := keyAuth(c.Key.Public(), token)if err != nil {@@ -579,7 +572,7 @@ func (c *Client) TLSSNI01ChallengeCert(token string, opt ...CertOption) (cert tl// If no WithKey option is provided, a new ECDSA key is generated using P-256 curve.//// The returned certificate is valid for the next 24 hours and must be presented only when-// the server name in the client hello matches exactly the returned name value.+// the server name in the TLS ClientHello matches exactly the returned name value.func (c *Client) TLSSNI02ChallengeCert(token string, opt ...CertOption) (cert tls.Certificate, name string, err error) {b := sha256.Sum256([]byte(token))h := hex.EncodeToString(b[:])@@ -600,6 +593,52 @@ func (c *Client) TLSSNI02ChallengeCert(token string, opt ...CertOption) (cert tlreturn cert, sanA, nil}+// TLSALPN01ChallengeCert creates a certificate for TLS-ALPN-01 challenge response.+// Servers can present the certificate to validate the challenge and prove control+// over a domain name. For more details on TLS-ALPN-01 see+// https://tools.ietf.org/html/draft-shoemaker-acme-tls-alpn-00#section-3+//+// The token argument is a Challenge.Token value.+// If a WithKey option is provided, its private part signs the returned cert,+// and the public part is used to specify the signee.+// If no WithKey option is provided, a new ECDSA key is generated using P-256 curve.+//+// The returned certificate is valid for the next 24 hours and must be presented only when+// the server name in the TLS ClientHello matches the domain, and the special acme-tls/1 ALPN protocol+// has been specified.+func (c *Client) TLSALPN01ChallengeCert(token, domain string, opt ...CertOption) (cert tls.Certificate, err error) {+ ka, err := keyAuth(c.Key.Public(), token)+ if err != nil {+ return tls.Certificate{}, err+ }+ shasum := sha256.Sum256([]byte(ka))+ extValue, err := asn1.Marshal(shasum[:])+ if err != nil {+ return tls.Certificate{}, err+ }+ acmeExtension := pkix.Extension{+ Id: idPeACMEIdentifierV1,+ Critical: true,+ Value: extValue,+ }++ tmpl := defaultTLSChallengeCertTemplate()++ var newOpt []CertOption+ for _, o := range opt {+ switch o := o.(type) {+ case *certOptTemplate:+ t := *(*x509.Certificate)(o) // shallow copy is ok+ tmpl = &t+ default:+ newOpt = append(newOpt, o)+ }+ }+ tmpl.ExtraExtensions = append(tmpl.ExtraExtensions, acmeExtension)+ newOpt = append(newOpt, WithTemplate(tmpl))+ return tlsChallengeCert([]string{domain}, newOpt)+}+// doReg sends all types of registration requests.// The type of request is identified by typ argument, which is a "resource"// in the ACME spec terms.@@ -619,14 +658,15 @@ func (c *Client) doReg(ctx context.Context, url string, typ string, acct *Accounreq.Contact = acct.Contactreq.Agreement = acct.AgreedTerms}- res, err := c.retryPostJWS(ctx, c.Key, url, req)+ res, err := c.post(ctx, c.Key, url, req, wantStatus(+ http.StatusOK, // updates and deletes+ http.StatusCreated, // new account creation+ http.StatusAccepted, // Let's Encrypt divergent implementation+ ))if err != nil {return nil, err}defer res.Body.Close()- if res.StatusCode < 200 || res.StatusCode > 299 {- return nil, responseError(res)- }var v struct {Contact []string@@ -656,59 +696,6 @@ func (c *Client) doReg(ctx context.Context, url string, typ string, acct *Accoun}, nil}-// retryPostJWS will retry calls to postJWS if there is a badNonce error,-// clearing the stored nonces after each error.-// If the response was 4XX-5XX, then responseError is called on the body,-// the body is closed, and the error returned.-func (c *Client) retryPostJWS(ctx context.Context, key crypto.Signer, url string, body interface{}) (*http.Response, error) {- sleep := sleeper(ctx)- for {- res, err := c.postJWS(ctx, key, url, body)- if err != nil {- return nil, err- }- // handle errors 4XX-5XX with responseError- if res.StatusCode >= 400 && res.StatusCode <= 599 {- err := responseError(res)- res.Body.Close()- // according to spec badNonce is urn:ietf:params:acme:error:badNonce- // however, acme servers in the wild return their version of the error- // https://tools.ietf.org/html/draft-ietf-acme-acme-02#section-5.4- if ae, ok := err.(*Error); ok && strings.HasSuffix(strings.ToLower(ae.ProblemType), ":badnonce") {- // clear any nonces that we might've stored that might now be- // considered bad- c.clearNonces()- retry := res.Header.Get("Retry-After")- if err := sleep(retry, 1); err != nil {- return nil, err- }- continue- }- return nil, err- }- return res, nil- }-}--// postJWS signs the body with the given key and POSTs it to the provided url.-// The body argument must be JSON-serializable.-func (c *Client) postJWS(ctx context.Context, key crypto.Signer, url string, body interface{}) (*http.Response, error) {- nonce, err := c.popNonce(ctx, url)- if err != nil {- return nil, err- }- b, err := jwsEncodeJSON(body, key, nonce)- if err != nil {- return nil, err- }- res, err := c.post(ctx, url, "application/jose+json", bytes.NewReader(b))- if err != nil {- return nil, err- }- c.addNonce(res.Header)- return res, nil-}-// popNonce returns a nonce value previously stored with c.addNonce// or fetches a fresh one from the given URL.func (c *Client) popNonce(ctx context.Context, url string) (string, error) {@@ -749,58 +736,12 @@ func (c *Client) addNonce(h http.Header) {c.nonces[v] = struct{}{}}-func (c *Client) httpClient() *http.Client {- if c.HTTPClient != nil {- return c.HTTPClient- }- return http.DefaultClient-}--func (c *Client) get(ctx context.Context, urlStr string) (*http.Response, error) {- req, err := http.NewRequest("GET", urlStr, nil)- if err != nil {- return nil, err- }- return c.do(ctx, req)-}--func (c *Client) head(ctx context.Context, urlStr string) (*http.Response, error) {- req, err := http.NewRequest("HEAD", urlStr, nil)- if err != nil {- return nil, err- }- return c.do(ctx, req)-}--func (c *Client) post(ctx context.Context, urlStr, contentType string, body io.Reader) (*http.Response, error) {- req, err := http.NewRequest("POST", urlStr, body)- if err != nil {- return nil, err- }- req.Header.Set("Content-Type", contentType)- return c.do(ctx, req)-}--func (c *Client) do(ctx context.Context, req *http.Request) (*http.Response, error) {- res, err := c.httpClient().Do(req.WithContext(ctx))+func (c *Client) fetchNonce(ctx context.Context, url string) (string, error) {+ r, err := http.NewRequest("HEAD", url, nil)if err != nil {- select {- case <-ctx.Done():- // Prefer the unadorned context error.- // (The acme package had tests assuming this, previously from ctxhttp's- // behavior, predating net/http supporting contexts natively)- // TODO(bradfitz): reconsider this in the future. But for now this- // requires no test updates.- return nil, ctx.Err()- default:- return nil, err- }+ return "", err}- return res, nil-}--func (c *Client) fetchNonce(ctx context.Context, url string) (string, error) {- resp, err := c.head(ctx, url)+ resp, err := c.doNoRetry(ctx, r)if err != nil {return "", err}@@ -852,24 +793,6 @@ func (c *Client) responseCert(ctx context.Context, res *http.Response, bundle boreturn cert, nil}-// responseError creates an error of Error type from resp.-func responseError(resp *http.Response) error {- // don't care if ReadAll returns an error:- // json.Unmarshal will fail in that case anyway- b, _ := ioutil.ReadAll(resp.Body)- e := &wireError{Status: resp.StatusCode}- if err := json.Unmarshal(b, e); err != nil {- // this is not a regular error response:- // populate detail with anything we received,- // e.Status will already contain HTTP response code value- e.Detail = string(b)- if e.Detail == "" {- e.Detail = resp.Status- }- }- return e.error(resp.Header)-}-// chainCert fetches CA certificate chain recursively by following "up" links.// Each recursive call increments the depth by 1, resulting in an error// if the recursion level reaches maxChainLen.@@ -880,14 +803,11 @@ func (c *Client) chainCert(ctx context.Context, url string, depth int) ([][]bytereturn nil, errors.New("acme: certificate chain is too deep")}- res, err := c.get(ctx, url)+ res, err := c.get(ctx, url, wantStatus(http.StatusOK))if err != nil {return nil, err}defer res.Body.Close()- if res.StatusCode != http.StatusOK {- return nil, responseError(res)- }b, err := ioutil.ReadAll(io.LimitReader(res.Body, maxCertSize+1))if err != nil {return nil, err@@ -932,65 +852,6 @@ func linkHeader(h http.Header, rel string) []string {return links}-// sleeper returns a function that accepts the Retry-After HTTP header value-// and an increment that's used with backoff to increasingly sleep on-// consecutive calls until the context is done. If the Retry-After header-// cannot be parsed, then backoff is used with a maximum sleep time of 10-// seconds.-func sleeper(ctx context.Context) func(ra string, inc int) error {- var count int- return func(ra string, inc int) error {- count += inc- d := backoff(count, 10*time.Second)- d = retryAfter(ra, d)- wakeup := time.NewTimer(d)- defer wakeup.Stop()- select {- case <-ctx.Done():- return ctx.Err()- case <-wakeup.C:- return nil- }- }-}--// retryAfter parses a Retry-After HTTP header value,-// trying to convert v into an int (seconds) or use http.ParseTime otherwise.-// It returns d if v cannot be parsed.-func retryAfter(v string, d time.Duration) time.Duration {- if i, err := strconv.Atoi(v); err == nil {- return time.Duration(i) * time.Second- }- t, err := http.ParseTime(v)- if err != nil {- return d- }- return t.Sub(timeNow())-}--// backoff computes a duration after which an n+1 retry iteration should occur-// using truncated exponential backoff algorithm.-//-// The n argument is always bounded between 0 and 30.-// The max argument defines upper bound for the returned value.-func backoff(n int, max time.Duration) time.Duration {- if n < 0 {- n = 0- }- if n > 30 {- n = 30- }- var d time.Duration- if x, err := rand.Int(rand.Reader, big.NewInt(1000)); err == nil {- d = time.Duration(x.Int64()) * time.Millisecond- }- d += time.Duration(1<<uint(n)) * time.Second- if d > max {- return max- }- return d-}-// keyAuth generates a key authorization string for a given token.func keyAuth(pub crypto.PublicKey, token string) (string, error) {th, err := JWKThumbprint(pub)@@ -1000,15 +861,25 @@ func keyAuth(pub crypto.PublicKey, token string) (string, error) {return fmt.Sprintf("%s.%s", token, th), nil}+// defaultTLSChallengeCertTemplate is a template used to create challenge certs for TLS challenges.+func defaultTLSChallengeCertTemplate() *x509.Certificate {+ return &x509.Certificate{+ SerialNumber: big.NewInt(1),+ NotBefore: time.Now(),+ NotAfter: time.Now().Add(24 * time.Hour),+ BasicConstraintsValid: true,+ KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},+ }+}+// tlsChallengeCert creates a temporary certificate for TLS-SNI challenges// with the given SANs and auto-generated public/private key pair.// The Subject Common Name is set to the first SAN to aid debugging.// To create a cert with a custom key pair, specify WithKey option.func tlsChallengeCert(san []string, opt []CertOption) (tls.Certificate, error) {- var (- key crypto.Signer- tmpl *x509.Certificate- )+ var key crypto.Signer+ tmpl := defaultTLSChallengeCertTemplate()for _, o := range opt {switch o := o.(type) {case *certOptKey:@@ -1017,7 +888,7 @@ func tlsChallengeCert(san []string, opt []CertOption) (tls.Certificate, error) {}key = o.keycase *certOptTemplate:- var t = *(*x509.Certificate)(o) // shallow copy is ok+ t := *(*x509.Certificate)(o) // shallow copy is oktmpl = &tdefault:// package's fault, if we let this happen:@@ -1030,16 +901,6 @@ func tlsChallengeCert(san []string, opt []CertOption) (tls.Certificate, error) {return tls.Certificate{}, err}}- if tmpl == nil {- tmpl = &x509.Certificate{- SerialNumber: big.NewInt(1),- NotBefore: time.Now(),- NotAfter: time.Now().Add(24 * time.Hour),- BasicConstraintsValid: true,- KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,- ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},- }- }tmpl.DNSNames = sanif len(san) > 0 {tmpl.Subject.CommonName = san[0]diff --git a/vendor/golang.org/x/crypto/acme/autocert/autocert.go b/vendor/golang.org/x/crypto/acme/autocert/autocert.goindex 263b29133..a50d9bfc9 100644--- a/vendor/golang.org/x/crypto/acme/autocert/autocert.go+++ b/vendor/golang.org/x/crypto/acme/autocert/autocert.go@@ -44,7 +44,7 @@ var createCertRetryAfter = time.Minutevar pseudoRand *lockedMathRandfunc init() {- src := mathrand.NewSource(timeNow().UnixNano())+ src := mathrand.NewSource(time.Now().UnixNano())pseudoRand = &lockedMathRand{rnd: mathrand.New(src)}}@@ -69,7 +69,7 @@ func HostWhitelist(hosts ...string) HostPolicy {}return func(_ context.Context, host string) error {if !whitelist[host] {- return errors.New("acme/autocert: host not configured")+ return fmt.Errorf("acme/autocert: host %q not configured in HostWhitelist", host)}return nil}@@ -81,9 +81,9 @@ func defaultHostPolicy(context.Context, string) error {}// Manager is a stateful certificate manager built on top of acme.Client.-// It obtains and refreshes certificates automatically using "tls-sni-01",-// "tls-sni-02" and "http-01" challenge types, as well as providing them-// to a TLS server via tls.Config.+// It obtains and refreshes certificates automatically using "tls-alpn-01",+// "tls-sni-01", "tls-sni-02" and "http-01" challenge types,+// as well as providing them to a TLS server via tls.Config.//// You must specify a cache implementation, such as DirCache,// to reuse obtained certificates across program restarts.@@ -98,11 +98,11 @@ type Manager struct {// To always accept the terms, the callers can use AcceptTOS.Prompt func(tosURL string) bool- // Cache optionally stores and retrieves previously-obtained certificates.- // If nil, certs will only be cached for the lifetime of the Manager.+ // Cache optionally stores and retrieves previously-obtained certificates+ // and other state. If nil, certs will only be cached for the lifetime of+ // the Manager. Multiple Managers can share the same Cache.//- // Manager passes the Cache certificates data encoded in PEM, with private/public- // parts combined in a single Cache.Put call, private key first.+ // Using a persistent Cache, such as DirCache, is strongly recommended.Cache Cache// HostPolicy controls which domains the Manager will attempt@@ -127,8 +127,10 @@ type Manager struct {// Client is used to perform low-level operations, such as account registration// and requesting new certificates.+ //// If Client is nil, a zero-value acme.Client is used with acme.LetsEncryptURL- // directory endpoint and a newly-generated ECDSA P-256 key.+ // as directory endpoint. If the Client.Key is nil, a new ECDSA P-256 key is+ // generated and, if Cache is not nil, stored in cache.//// Mutating the field after the first call of GetCertificate method will have no effect.Client *acme.Client@@ -140,22 +142,30 @@ type Manager struct {// If the Client's account key is already registered, Email is not used.Email string- // ForceRSA makes the Manager generate certificates with 2048-bit RSA keys.+ // ForceRSA used to make the Manager generate RSA certificates. It is now ignored.//- // If false, a default is used. Currently the default- // is EC-based keys using the P-256 curve.+ // Deprecated: the Manager will request the correct type of certificate based+ // on what each client supports.ForceRSA bool+ // ExtraExtensions are used when generating a new CSR (Certificate Request),+ // thus allowing customization of the resulting certificate.+ // For instance, TLS Feature Extension (RFC 7633) can be used+ // to prevent an OCSP downgrade attack.+ //+ // The field value is passed to crypto/x509.CreateCertificateRequest+ // in the template's ExtraExtensions field as is.+ ExtraExtensions []pkix.Extension+clientMu sync.Mutexclient *acme.Client // initialized by acmeClient methodstateMu sync.Mutex- state map[string]*certState // keyed by domain name+ state map[certKey]*certState// renewal tracks the set of domains currently running renewal timers.- // It is keyed by domain name.renewalMu sync.Mutex- renewal map[string]*domainRenewal+ renewal map[certKey]*domainRenewal// tokensMu guards the rest of the fields: tryHTTP01, certTokens and httpTokens.tokensMu sync.RWMutex@@ -167,21 +177,60 @@ type Manager struct {// to be provisioned.// The entries are stored for the duration of the authorization flow.httpTokens map[string][]byte- // certTokens contains temporary certificates for tls-sni challenges+ // certTokens contains temporary certificates for tls-sni and tls-alpn challenges// and is keyed by token domain name, which matches server name of ClientHello.- // Keys always have ".acme.invalid" suffix.+ // Keys always have ".acme.invalid" suffix for tls-sni. Otherwise, they are domain names+ // for tls-alpn.// The entries are stored for the duration of the authorization flow.certTokens map[string]*tls.Certificate+ // nowFunc, if not nil, returns the current time. This may be set for+ // testing purposes.+ nowFunc func() time.Time+}++// certKey is the key by which certificates are tracked in state, renewal and cache.+type certKey struct {+ domain string // without trailing dot+ isRSA bool // RSA cert for legacy clients (as opposed to default ECDSA)+ isToken bool // tls-based challenge token cert; key type is undefined regardless of isRSA+}++func (c certKey) String() string {+ if c.isToken {+ return c.domain + "+token"+ }+ if c.isRSA {+ return c.domain + "+rsa"+ }+ return c.domain+}++// TLSConfig creates a new TLS config suitable for net/http.Server servers,+// supporting HTTP/2 and the tls-alpn-01 ACME challenge type.+func (m *Manager) TLSConfig() *tls.Config {+ return &tls.Config{+ GetCertificate: m.GetCertificate,+ NextProtos: []string{+ "h2", "http/1.1", // enable HTTP/2+ acme.ALPNProto, // enable tls-alpn ACME challenges+ },+ }}// GetCertificate implements the tls.Config.GetCertificate hook.// It provides a TLS certificate for hello.ServerName host, including answering-// *.acme.invalid (TLS-SNI) challenges. All other fields of hello are ignored.+// tls-alpn-01 and *.acme.invalid (tls-sni-01 and tls-sni-02) challenges.+// All other fields of hello are ignored.//// If m.HostPolicy is non-nil, GetCertificate calls the policy before requesting// a new cert. A non-nil error returned from m.HostPolicy halts TLS negotiation.// The error is propagated back to the caller of GetCertificate and is user-visible.// This does not affect cached certs. See HostPolicy field description for more details.+//+// If GetCertificate is used directly, instead of via Manager.TLSConfig, package users will+// also have to add acme.ALPNProto to NextProtos for tls-alpn-01, or use HTTPHandler+// for http-01. (The tls-sni-* challenges have been deprecated by popular ACME providers+// due to security issues in the ecosystem.)func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate, error) {if m.Prompt == nil {return nil, errors.New("acme/autocert: Manager.Prompt not set")@@ -194,7 +243,7 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,if !strings.Contains(strings.Trim(name, "."), ".") {return nil, errors.New("acme/autocert: server name component count invalid")}- if strings.ContainsAny(name, `/\`) {+ if strings.ContainsAny(name, `+/\`) {return nil, errors.New("acme/autocert: server name contains invalid character")}@@ -203,14 +252,17 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)defer cancel()- // check whether this is a token cert requested for TLS-SNI challenge- if strings.HasSuffix(name, ".acme.invalid") {+ // Check whether this is a token cert requested for TLS-SNI or TLS-ALPN challenge.+ if wantsTokenCert(hello) {m.tokensMu.RLock()defer m.tokensMu.RUnlock()+ // It's ok to use the same token cert key for both tls-sni and tls-alpn+ // because there's always at most 1 token cert per on-going domain authorization.+ // See m.verify for details.if cert := m.certTokens[name]; cert != nil {return cert, nil}- if cert, err := m.cacheGet(ctx, name); err == nil {+ if cert, err := m.cacheGet(ctx, certKey{domain: name, isToken: true}); err == nil {return cert, nil}// TODO: cache error results?@@ -218,8 +270,11 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,}// regular domain- name = strings.TrimSuffix(name, ".") // golang.org/issue/18114- cert, err := m.cert(ctx, name)+ ck := certKey{+ domain: strings.TrimSuffix(name, "."), // golang.org/issue/18114+ isRSA: !supportsECDSA(hello),+ }+ cert, err := m.cert(ctx, ck)if err == nil {return cert, nil}@@ -231,14 +286,71 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,if err := m.hostPolicy()(ctx, name); err != nil {return nil, err}- cert, err = m.createCert(ctx, name)+ cert, err = m.createCert(ctx, ck)if err != nil {return nil, err}- m.cachePut(ctx, name, cert)+ m.cachePut(ctx, ck, cert)return cert, nil}+// wantsTokenCert reports whether a TLS request with SNI is made by a CA server+// for a challenge verification.+func wantsTokenCert(hello *tls.ClientHelloInfo) bool {+ // tls-alpn-01+ if len(hello.SupportedProtos) == 1 && hello.SupportedProtos[0] == acme.ALPNProto {+ return true+ }+ // tls-sni-xx+ return strings.HasSuffix(hello.ServerName, ".acme.invalid")+}++func supportsECDSA(hello *tls.ClientHelloInfo) bool {+ // The "signature_algorithms" extension, if present, limits the key exchange+ // algorithms allowed by the cipher suites. See RFC 5246, section 7.4.1.4.1.+ if hello.SignatureSchemes != nil {+ ecdsaOK := false+ schemeLoop:+ for _, scheme := range hello.SignatureSchemes {+ const tlsECDSAWithSHA1 tls.SignatureScheme = 0x0203 // constant added in Go 1.10+ switch scheme {+ case tlsECDSAWithSHA1, tls.ECDSAWithP256AndSHA256,+ tls.ECDSAWithP384AndSHA384, tls.ECDSAWithP521AndSHA512:+ ecdsaOK = true+ break schemeLoop+ }+ }+ if !ecdsaOK {+ return false+ }+ }+ if hello.SupportedCurves != nil {+ ecdsaOK := false+ for _, curve := range hello.SupportedCurves {+ if curve == tls.CurveP256 {+ ecdsaOK = true+ break+ }+ }+ if !ecdsaOK {+ return false+ }+ }+ for _, suite := range hello.CipherSuites {+ switch suite {+ case tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,+ tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,+ tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,+ tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,+ tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305:+ return true+ }+ }+ return false+}+// HTTPHandler configures the Manager to provision ACME "http-01" challenge responses.// It returns an http.Handler that responds to the challenges and must be// running on port 80. If it receives a request that is not an ACME challenge,@@ -252,8 +364,8 @@ func (m *Manager) GetCertificate(hello *tls.ClientHelloInfo) (*tls.Certificate,// Because the fallback handler is run with unencrypted port 80 requests,// the fallback should not serve TLS-only requests.//-// If HTTPHandler is never called, the Manager will only use TLS SNI-// challenges for domain verification.+// If HTTPHandler is never called, the Manager will only use the "tls-alpn-01"+// challenge for domain verification.func (m *Manager) HTTPHandler(fallback http.Handler) http.Handler {m.tokensMu.Lock()defer m.tokensMu.Unlock()@@ -304,16 +416,16 @@ func stripPort(hostport string) string {// cert returns an existing certificate either from m.state or cache.// If a certificate is found in cache but not in m.state, the latter will be filled// with the cached value.-func (m *Manager) cert(ctx context.Context, name string) (*tls.Certificate, error) {+func (m *Manager) cert(ctx context.Context, ck certKey) (*tls.Certificate, error) {m.stateMu.Lock()- if s, ok := m.state[name]; ok {+ if s, ok := m.state[ck]; ok {m.stateMu.Unlock()s.RLock()defer s.RUnlock()return s.tlscert()}defer m.stateMu.Unlock()- cert, err := m.cacheGet(ctx, name)+ cert, err := m.cacheGet(ctx, ck)if err != nil {return nil, err}@@ -322,25 +434,25 @@ func (m *Manager) cert(ctx context.Context, name string) (*tls.Certificate, erroreturn nil, errors.New("acme/autocert: private key cannot sign")}if m.state == nil {- m.state = make(map[string]*certState)+ m.state = make(map[certKey]*certState)}s := &certState{key: signer,cert: cert.Certificate,leaf: cert.Leaf,}- m.state[name] = s- go m.renew(name, s.key, s.leaf.NotAfter)+ m.state[ck] = s+ go m.renew(ck, s.key, s.leaf.NotAfter)return cert, nil}// cacheGet always returns a valid certificate, or an error otherwise.-// If a cached certficate exists but is not valid, ErrCacheMiss is returned.-func (m *Manager) cacheGet(ctx context.Context, domain string) (*tls.Certificate, error) {+// If a cached certificate exists but is not valid, ErrCacheMiss is returned.+func (m *Manager) cacheGet(ctx context.Context, ck certKey) (*tls.Certificate, error) {if m.Cache == nil {return nil, ErrCacheMiss}- data, err := m.Cache.Get(ctx, domain)+ data, err := m.Cache.Get(ctx, ck.String())if err != nil {return nil, err}@@ -371,7 +483,7 @@ func (m *Manager) cacheGet(ctx context.Context, domain string) (*tls.Certificate}// verify and create TLS cert- leaf, err := validCert(domain, pubDER, privKey)+ leaf, err := validCert(ck, pubDER, privKey, m.now())if err != nil {return nil, ErrCacheMiss}@@ -383,7 +495,7 @@ func (m *Manager) cacheGet(ctx context.Context, domain string) (*tls.Certificatereturn tlscert, nil}-func (m *Manager) cachePut(ctx context.Context, domain string, tlscert *tls.Certificate) error {+func (m *Manager) cachePut(ctx context.Context, ck certKey, tlscert *tls.Certificate) error {if m.Cache == nil {return nil}@@ -415,7 +527,7 @@ func (m *Manager) cachePut(ctx context.Context, domain string, tlscert *tls.Cert}}- return m.Cache.Put(ctx, domain, buf.Bytes())+ return m.Cache.Put(ctx, ck.String(), buf.Bytes())}func encodeECDSAKey(w io.Writer, key *ecdsa.PrivateKey) error {@@ -432,9 +544,9 @@ func encodeECDSAKey(w io.Writer, key *ecdsa.PrivateKey) error {//// If the domain is already being verified, it waits for the existing verification to complete.// Either way, createCert blocks for the duration of the whole process.-func (m *Manager) createCert(ctx context.Context, domain string) (*tls.Certificate, error) {+func (m *Manager) createCert(ctx context.Context, ck certKey) (*tls.Certificate, error) {// TODO: maybe rewrite this whole piece using sync.Once- state, err := m.certState(domain)+ state, err := m.certState(ck)if err != nil {return nil, err}@@ -452,44 +564,44 @@ func (m *Manager) createCert(ctx context.Context, domain string) (*tls.Certificadefer state.Unlock()state.locked = false- der, leaf, err := m.authorizedCert(ctx, state.key, domain)+ der, leaf, err := m.authorizedCert(ctx, state.key, ck)if err != nil {// Remove the failed state after some time,// making the manager call createCert again on the following TLS hello.time.AfterFunc(createCertRetryAfter, func() {- defer testDidRemoveState(domain)+ defer testDidRemoveState(ck)m.stateMu.Lock()defer m.stateMu.Unlock()// Verify the state hasn't changed and it's still invalid// before deleting.- s, ok := m.state[domain]+ s, ok := m.state[ck]if !ok {return}- if _, err := validCert(domain, s.cert, s.key); err == nil {+ if _, err := validCert(ck, s.cert, s.key, m.now()); err == nil {return}- delete(m.state, domain)+ delete(m.state, ck)})return nil, err}state.cert = derstate.leaf = leaf- go m.renew(domain, state.key, state.leaf.NotAfter)+ go m.renew(ck, state.key, state.leaf.NotAfter)return state.tlscert()}// certState returns a new or existing certState.// If a new certState is returned, state.exist is false and the state is locked.// The returned error is non-nil only in the case where a new state could not be created.-func (m *Manager) certState(domain string) (*certState, error) {+func (m *Manager) certState(ck certKey) (*certState, error) {m.stateMu.Lock()defer m.stateMu.Unlock()if m.state == nil {- m.state = make(map[string]*certState)+ m.state = make(map[certKey]*certState)}// existing state- if state, ok := m.state[domain]; ok {+ if state, ok := m.state[ck]; ok {return state, nil}@@ -498,7 +610,7 @@ func (m *Manager) certState(domain string) (*certState, error) {err errorkey crypto.Signer)- if m.ForceRSA {+ if ck.isRSA {key, err = rsa.GenerateKey(rand.Reader, 2048)} else {key, err = ecdsa.GenerateKey(elliptic.P256(), rand.Reader)@@ -512,22 +624,22 @@ func (m *Manager) certState(domain string) (*certState, error) {locked: true,}state.Lock() // will be unlocked by m.certState caller- m.state[domain] = state+ m.state[ck] = statereturn state, nil}// authorizedCert starts the domain ownership verification process and requests a new cert upon success.// The key argument is the certificate private key.-func (m *Manager) authorizedCert(ctx context.Context, key crypto.Signer, domain string) (der [][]byte, leaf *x509.Certificate, err error) {+func (m *Manager) authorizedCert(ctx context.Context, key crypto.Signer, ck certKey) (der [][]byte, leaf *x509.Certificate, err error) {client, err := m.acmeClient(ctx)if err != nil {return nil, nil, err}- if err := m.verify(ctx, client, domain); err != nil {+ if err := m.verify(ctx, client, ck.domain); err != nil {return nil, nil, err}- csr, err := certRequest(key, domain)+ csr, err := certRequest(key, ck.domain, m.ExtraExtensions)if err != nil {return nil, nil, err}@@ -535,25 +647,55 @@ func (m *Manager) authorizedCert(ctx context.Context, key crypto.Signer, domainif err != nil {return nil, nil, err}- leaf, err = validCert(domain, der, key)+ leaf, err = validCert(ck, der, key, m.now())if err != nil {return nil, nil, err}return der, leaf, nil}+// revokePendingAuthz revokes all authorizations idenfied by the elements of uri slice.+// It ignores revocation errors.+func (m *Manager) revokePendingAuthz(ctx context.Context, uri []string) {+ client, err := m.acmeClient(ctx)+ if err != nil {+ return+ }+ for _, u := range uri {+ client.RevokeAuthorization(ctx, u)+ }+}+// verify runs the identifier (domain) authorization flow// using each applicable ACME challenge type.func (m *Manager) verify(ctx context.Context, client *acme.Client, domain string) error {// The list of challenge types we'll try to fulfill// in this specific order.- challengeTypes := []string{"tls-sni-02", "tls-sni-01"}+ challengeTypes := []string{"tls-alpn-01", "tls-sni-02", "tls-sni-01"}m.tokensMu.RLock()if m.tryHTTP01 {challengeTypes = append(challengeTypes, "http-01")}m.tokensMu.RUnlock()+ // Keep track of pending authzs and revoke the ones that did not validate.+ pendingAuthzs := make(map[string]bool)+ defer func() {+ var uri []string+ for k, pending := range pendingAuthzs {+ if pending {+ uri = append(uri, k)+ }+ }+ if len(uri) > 0 {+ // Use "detached" background context.+ // The revocations need not happen in the current verification flow.+ go m.revokePendingAuthz(context.Background(), uri)+ }+ }()++ // errs accumulates challenge failure errors, printed if all fail+ errs := make(map[*acme.Challenge]error)var nextTyp int // challengeType index of the next challenge type to tryfor {// Start domain authorization and get the challenge.@@ -570,6 +712,8 @@ func (m *Manager) verify(ctx context.Context, client *acme.Client, domain stringreturn fmt.Errorf("acme/autocert: invalid authorization %q", authz.URI)}+ pendingAuthzs[authz.URI] = true+// Pick the next preferred challenge.var chal *acme.Challengefor chal == nil && nextTyp < len(challengeTypes) {@@ -577,28 +721,44 @@ func (m *Manager) verify(ctx context.Context, client *acme.Client, domain stringnextTyp++}if chal == nil {- return fmt.Errorf("acme/autocert: unable to authorize %q; tried %q", domain, challengeTypes)+ errorMsg := fmt.Sprintf("acme/autocert: unable to authorize %q", domain)+ for chal, err := range errs {+ errorMsg += fmt.Sprintf("; challenge %q failed with error: %v", chal.Type, err)+ }+ return errors.New(errorMsg)}- cleanup, err := m.fulfill(ctx, client, chal)+ cleanup, err := m.fulfill(ctx, client, chal, domain)if err != nil {+ errs[chal] = errcontinue}defer cleanup()if _, err := client.Accept(ctx, chal); err != nil {+ errs[chal] = errcontinue}// A challenge is fulfilled and accepted: wait for the CA to validate.- if _, err := client.WaitAuthorization(ctx, authz.URI); err == nil {- return nil+ if _, err := client.WaitAuthorization(ctx, authz.URI); err != nil {+ errs[chal] = err+ continue}+ delete(pendingAuthzs, authz.URI)+ return nil}}// fulfill provisions a response to the challenge chal.// The cleanup is non-nil only if provisioning succeeded.-func (m *Manager) fulfill(ctx context.Context, client *acme.Client, chal *acme.Challenge) (cleanup func(), err error) {+func (m *Manager) fulfill(ctx context.Context, client *acme.Client, chal *acme.Challenge, domain string) (cleanup func(), err error) {switch chal.Type {+ case "tls-alpn-01":+ cert, err := client.TLSALPN01ChallengeCert(chal.Token, domain)+ if err != nil {+ return nil, err+ }+ m.putCertToken(ctx, domain, &cert)+ return func() { go m.deleteCertToken(domain) }, nilcase "tls-sni-01":cert, name, err := client.TLSSNI01ChallengeCert(chal.Token)if err != nil {@@ -634,8 +794,8 @@ func pickChallenge(typ string, chal []*acme.Challenge) *acme.Challenge {return nil}-// putCertToken stores the cert under the named key in both m.certTokens map-// and m.Cache.+// putCertToken stores the token certificate with the specified name+// in both m.certTokens map and m.Cache.func (m *Manager) putCertToken(ctx context.Context, name string, cert *tls.Certificate) {m.tokensMu.Lock()defer m.tokensMu.Unlock()@@ -643,17 +803,18 @@ func (m *Manager) putCertToken(ctx context.Context, name string, cert *tls.Certim.certTokens = make(map[string]*tls.Certificate)}m.certTokens[name] = cert- m.cachePut(ctx, name, cert)+ m.cachePut(ctx, certKey{domain: name, isToken: true}, cert)}-// deleteCertToken removes the token certificate for the specified domain name+// deleteCertToken removes the token certificate with the specified name// from both m.certTokens map and m.Cache.func (m *Manager) deleteCertToken(name string) {m.tokensMu.Lock()defer m.tokensMu.Unlock()delete(m.certTokens, name)if m.Cache != nil {- m.Cache.Delete(context.Background(), name)+ ck := certKey{domain: name, isToken: true}+ m.Cache.Delete(context.Background(), ck.String())}}@@ -704,7 +865,7 @@ func (m *Manager) deleteHTTPToken(tokenPath string) {// httpTokenCacheKey returns a key at which an http-01 token value may be stored// in the Manager's optional Cache.func httpTokenCacheKey(tokenPath string) string {- return "http-01-" + path.Base(tokenPath)+ return path.Base(tokenPath) + "+http-01"}// renew starts a cert renewal timer loop, one per domain.@@ -715,18 +876,18 @@ func httpTokenCacheKey(tokenPath string) string {//// The key argument is a certificate private key.// The exp argument is the cert expiration time (NotAfter).-func (m *Manager) renew(domain string, key crypto.Signer, exp time.Time) {+func (m *Manager) renew(ck certKey, key crypto.Signer, exp time.Time) {m.renewalMu.Lock()defer m.renewalMu.Unlock()- if m.renewal[domain] != nil {+ if m.renewal[ck] != nil {// another goroutine is already on itreturn}if m.renewal == nil {- m.renewal = make(map[string]*domainRenewal)+ m.renewal = make(map[certKey]*domainRenewal)}- dr := &domainRenewal{m: m, domain: domain, key: key}- m.renewal[domain] = dr+ dr := &domainRenewal{m: m, ck: ck, key: key}+ m.renewal[ck] = drdr.start(exp)}@@ -742,7 +903,10 @@ func (m *Manager) stopRenew() {}func (m *Manager) accountKey(ctx context.Context) (crypto.Signer, error) {- const keyName = "acme_account.key"+ const keyName = "acme_account+key"++ // Previous versions of autocert stored the value under a different key.+ const legacyKeyName = "acme_account.key"genKey := func() (*ecdsa.PrivateKey, error) {return ecdsa.GenerateKey(elliptic.P256(), rand.Reader)@@ -753,6 +917,9 @@ func (m *Manager) accountKey(ctx context.Context) (crypto.Signer, error) {}data, err := m.Cache.Get(ctx, keyName)+ if err == ErrCacheMiss {+ data, err = m.Cache.Get(ctx, legacyKeyName)+ }if err == ErrCacheMiss {key, err := genKey()if err != nil {@@ -824,6 +991,13 @@ func (m *Manager) renewBefore() time.Duration {return 720 * time.Hour // 30 days}+func (m *Manager) now() time.Time {+ if m.nowFunc != nil {+ return m.nowFunc()+ }+ return time.Now()+}+// certState is ready when its mutex is unlocked for reading.type certState struct {sync.RWMutex@@ -849,12 +1023,12 @@ func (s *certState) tlscert() (*tls.Certificate, error) {}, nil}-// certRequest creates a certificate request for the given common name cn-// and optional SANs.-func certRequest(key crypto.Signer, cn string, san ...string) ([]byte, error) {+// certRequest generates a CSR for the given common name cn and optional SANs.+func certRequest(key crypto.Signer, cn string, ext []pkix.Extension, san ...string) ([]byte, error) {req := &x509.CertificateRequest{- Subject: pkix.Name{CommonName: cn},- DNSNames: san,+ Subject: pkix.Name{CommonName: cn},+ DNSNames: san,+ ExtraExtensions: ext,}return x509.CreateCertificateRequest(rand.Reader, req, key)}@@ -885,12 +1059,12 @@ func parsePrivateKey(der []byte) (crypto.Signer, error) {return nil, errors.New("acme/autocert: failed to parse private key")}-// validCert parses a cert chain provided as der argument and verifies the leaf, der[0],-// corresponds to the private key, as well as the domain match and expiration dates.-// It doesn't do any revocation checking.+// validCert parses a cert chain provided as der argument and verifies the leaf and der[0]+// correspond to the private key, the domain and key type match, and expiration dates+// are valid. It doesn't do any revocation checking.//// The returned value is the verified leaf cert.-func validCert(domain string, der [][]byte, key crypto.Signer) (leaf *x509.Certificate, err error) {+func validCert(ck certKey, der [][]byte, key crypto.Signer, now time.Time) (leaf *x509.Certificate, err error) {// parse public part(s)var n intfor _, b := range der {@@ -902,22 +1076,21 @@ func validCert(domain string, der [][]byte, key crypto.Signer) (leaf *x509.Certin += copy(pub[n:], b)}x509Cert, err := x509.ParseCertificates(pub)- if len(x509Cert) == 0 {+ if err != nil || len(x509Cert) == 0 {return nil, errors.New("acme/autocert: no public key found")}// verify the leaf is not expired and matches the domain nameleaf = x509Cert[0]- now := timeNow()if now.Before(leaf.NotBefore) {return nil, errors.New("acme/autocert: certificate is not valid yet")}if now.After(leaf.NotAfter) {return nil, errors.New("acme/autocert: expired certificate")}- if err := leaf.VerifyHostname(domain); err != nil {+ if err := leaf.VerifyHostname(ck.domain); err != nil {return nil, err}- // ensure the leaf corresponds to the private key+ // ensure the leaf corresponds to the private key and matches the certKey typeswitch pub := leaf.PublicKey.(type) {case *rsa.PublicKey:prv, ok := key.(*rsa.PrivateKey)@@ -927,6 +1100,9 @@ func validCert(domain string, der [][]byte, key crypto.Signer) (leaf *x509.Certiif pub.N.Cmp(prv.N) != 0 {return nil, errors.New("acme/autocert: private key does not match public key")}+ if !ck.isRSA && !ck.isToken {+ return nil, errors.New("acme/autocert: key type does not match expected value")+ }case *ecdsa.PublicKey:prv, ok := key.(*ecdsa.PrivateKey)if !ok {@@ -935,6 +1111,9 @@ func validCert(domain string, der [][]byte, key crypto.Signer) (leaf *x509.Certiif pub.X.Cmp(prv.X) != 0 || pub.Y.Cmp(prv.Y) != 0 {return nil, errors.New("acme/autocert: private key does not match public key")}+ if ck.isRSA && !ck.isToken {+ return nil, errors.New("acme/autocert: key type does not match expected value")+ }default:return nil, errors.New("acme/autocert: unknown public key algorithm")}@@ -955,8 +1134,6 @@ func (r *lockedMathRand) int63n(max int64) int64 {// For easier testing.var (- timeNow = time.Now-// Called when a state is removed.- testDidRemoveState = func(domain string) {}+ testDidRemoveState = func(certKey) {})diff --git a/vendor/golang.org/x/crypto/acme/autocert/cache.go b/vendor/golang.org/x/crypto/acme/autocert/cache.goindex 61a5fd239..aa9aa845c 100644--- a/vendor/golang.org/x/crypto/acme/autocert/cache.go+++ b/vendor/golang.org/x/crypto/acme/autocert/cache.go@@ -16,10 +16,10 @@ import (var ErrCacheMiss = errors.New("acme/autocert: certificate cache miss")// Cache is used by Manager to store and retrieve previously obtained certificates-// as opaque data.+// and other account data as opaque blobs.//-// The key argument of the methods refers to a domain name but need not be an FQDN.-// Cache implementations should not rely on the key naming pattern.+// Cache implementations should not rely on the key naming pattern. Keys can+// include any printable ASCII characters, except the following: \/:*?"<>|type Cache interface {// Get returns a certificate data for the specified key.// If there's no such key, Get returns ErrCacheMiss.diff --git a/vendor/golang.org/x/crypto/acme/autocert/listener.go b/vendor/golang.org/x/crypto/acme/autocert/listener.goindex d744df0ed..1e069818a 100644--- a/vendor/golang.org/x/crypto/acme/autocert/listener.go+++ b/vendor/golang.org/x/crypto/acme/autocert/listener.go@@ -72,11 +72,8 @@ func NewListener(domains ...string) net.Listener {// the Manager m's Prompt, Cache, HostPolicy, and other desired options.func (m *Manager) Listener() net.Listener {ln := &listener{- m: m,- conf: &tls.Config{- GetCertificate: m.GetCertificate, // bonus: panic on nil m- NextProtos: []string{"h2", "http/1.1"}, // Enable HTTP/2- },+ m: m,+ conf: m.TLSConfig(),}ln.tcpListener, ln.tcpListenErr = net.Listen("tcp", ":443")return lndiff --git a/vendor/golang.org/x/crypto/acme/autocert/renewal.go b/vendor/golang.org/x/crypto/acme/autocert/renewal.goindex 3fa4d61a2..665f870dc 100644--- a/vendor/golang.org/x/crypto/acme/autocert/renewal.go+++ b/vendor/golang.org/x/crypto/acme/autocert/renewal.go@@ -17,9 +17,9 @@ const renewJitter = time.Hour// domainRenewal tracks the state used by the periodic timers// renewing a single domain's cert.type domainRenewal struct {- m *Manager- domain string- key crypto.Signer+ m *Manager+ ck certKey+ key crypto.SignertimerMu sync.Mutextimer *time.Timer@@ -77,7 +77,7 @@ func (dr *domainRenewal) updateState(state *certState) {dr.m.stateMu.Lock()defer dr.m.stateMu.Unlock()dr.key = state.key- dr.m.state[dr.domain] = state+ dr.m.state[dr.ck] = state}// do is similar to Manager.createCert but it doesn't lock a Manager.state item.@@ -91,7 +91,7 @@ func (dr *domainRenewal) updateState(state *certState) {func (dr *domainRenewal) do(ctx context.Context) (time.Duration, error) {// a race is likely unavoidable in a distributed environment// but we try nonetheless- if tlscert, err := dr.m.cacheGet(ctx, dr.domain); err == nil {+ if tlscert, err := dr.m.cacheGet(ctx, dr.ck); err == nil {next := dr.next(tlscert.Leaf.NotAfter)if next > dr.m.renewBefore()+renewJitter {signer, ok := tlscert.PrivateKey.(crypto.Signer)@@ -107,7 +107,7 @@ func (dr *domainRenewal) do(ctx context.Context) (time.Duration, error) {}}- der, leaf, err := dr.m.authorizedCert(ctx, dr.key, dr.domain)+ der, leaf, err := dr.m.authorizedCert(ctx, dr.key, dr.ck)if err != nil {return 0, err}@@ -120,7 +120,7 @@ func (dr *domainRenewal) do(ctx context.Context) (time.Duration, error) {if err != nil {return 0, err}- if err := dr.m.cachePut(ctx, dr.domain, tlscert); err != nil {+ if err := dr.m.cachePut(ctx, dr.ck, tlscert); err != nil {return 0, err}dr.updateState(state)@@ -128,7 +128,7 @@ func (dr *domainRenewal) do(ctx context.Context) (time.Duration, error) {}func (dr *domainRenewal) next(expiry time.Time) time.Duration {- d := expiry.Sub(timeNow()) - dr.m.renewBefore()+ d := expiry.Sub(dr.m.now()) - dr.m.renewBefore()// add a bit of randomness to renew deadlinen := pseudoRand.int63n(int64(renewJitter))d -= time.Duration(n)diff --git a/vendor/golang.org/x/crypto/acme/http.go b/vendor/golang.org/x/crypto/acme/http.gonew file mode 100644index 000000000..a43ce6a5f--- /dev/null+++ b/vendor/golang.org/x/crypto/acme/http.go@@ -0,0 +1,281 @@+// Copyright 2018 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.++package acme++import (+ "bytes"+ "context"+ "crypto"+ "crypto/rand"+ "encoding/json"+ "fmt"+ "io/ioutil"+ "math/big"+ "net/http"+ "strconv"+ "strings"+ "time"+)++// retryTimer encapsulates common logic for retrying unsuccessful requests.+// It is not safe for concurrent use.+type retryTimer struct {+ // backoffFn provides backoff delay sequence for retries.+ // See Client.RetryBackoff doc comment.+ backoffFn func(n int, r *http.Request, res *http.Response) time.Duration+ // n is the current retry attempt.+ n int+}++func (t *retryTimer) inc() {+ t.n+++}++// backoff pauses the current goroutine as described in Client.RetryBackoff.+func (t *retryTimer) backoff(ctx context.Context, r *http.Request, res *http.Response) error {+ d := t.backoffFn(t.n, r, res)+ if d <= 0 {+ return fmt.Errorf("acme: no more retries for %s; tried %d time(s)", r.URL, t.n)+ }+ wakeup := time.NewTimer(d)+ defer wakeup.Stop()+ select {+ case <-ctx.Done():+ return ctx.Err()+ case <-wakeup.C:+ return nil+ }+}++func (c *Client) retryTimer() *retryTimer {+ f := c.RetryBackoff+ if f == nil {+ f = defaultBackoff+ }+ return &retryTimer{backoffFn: f}+}++// defaultBackoff provides default Client.RetryBackoff implementation+// using a truncated exponential backoff algorithm,+// as described in Client.RetryBackoff.+//+// The n argument is always bounded between 1 and 30.+// The returned value is always greater than 0.+func defaultBackoff(n int, r *http.Request, res *http.Response) time.Duration {+ const max = 10 * time.Second+ var jitter time.Duration+ if x, err := rand.Int(rand.Reader, big.NewInt(1000)); err == nil {+ // Set the minimum to 1ms to avoid a case where+ // an invalid Retry-After value is parsed into 0 below,+ // resulting in the 0 returned value which would unintentionally+ // stop the retries.+ jitter = (1 + time.Duration(x.Int64())) * time.Millisecond+ }+ if v, ok := res.Header["Retry-After"]; ok {+ return retryAfter(v[0]) + jitter+ }++ if n < 1 {+ n = 1+ }+ if n > 30 {+ n = 30+ }+ d := time.Duration(1<<uint(n-1))*time.Second + jitter+ if d > max {+ return max+ }+ return d+}++// retryAfter parses a Retry-After HTTP header value,+// trying to convert v into an int (seconds) or use http.ParseTime otherwise.+// It returns zero value if v cannot be parsed.+func retryAfter(v string) time.Duration {+ if i, err := strconv.Atoi(v); err == nil {+ return time.Duration(i) * time.Second+ }+ t, err := http.ParseTime(v)+ if err != nil {+ return 0+ }+ return t.Sub(timeNow())+}++// resOkay is a function that reports whether the provided response is okay.+// It is expected to keep the response body unread.+type resOkay func(*http.Response) bool++// wantStatus returns a function which reports whether the code+// matches the status code of a response.+func wantStatus(codes ...int) resOkay {+ return func(res *http.Response) bool {+ for _, code := range codes {+ if code == res.StatusCode {+ return true+ }+ }+ return false+ }+}++// get issues an unsigned GET request to the specified URL.+// It returns a non-error value only when ok reports true.+//+// get retries unsuccessful attempts according to c.RetryBackoff+// until the context is done or a non-retriable error is received.+func (c *Client) get(ctx context.Context, url string, ok resOkay) (*http.Response, error) {+ retry := c.retryTimer()+ for {+ req, err := http.NewRequest("GET", url, nil)+ if err != nil {+ return nil, err+ }+ res, err := c.doNoRetry(ctx, req)+ switch {+ case err != nil:+ return nil, err+ case ok(res):+ return res, nil+ case isRetriable(res.StatusCode):+ retry.inc()+ resErr := responseError(res)+ res.Body.Close()+ // Ignore the error value from retry.backoff+ // and return the one from last retry, as received from the CA.+ if retry.backoff(ctx, req, res) != nil {+ return nil, resErr+ }+ default:+ defer res.Body.Close()+ return nil, responseError(res)+ }+ }+}++// post issues a signed POST request in JWS format using the provided key+// to the specified URL.+// It returns a non-error value only when ok reports true.+//+// post retries unsuccessful attempts according to c.RetryBackoff+// until the context is done or a non-retriable error is received.+// It uses postNoRetry to make individual requests.+func (c *Client) post(ctx context.Context, key crypto.Signer, url string, body interface{}, ok resOkay) (*http.Response, error) {+ retry := c.retryTimer()+ for {+ res, req, err := c.postNoRetry(ctx, key, url, body)+ if err != nil {+ return nil, err+ }+ if ok(res) {+ return res, nil+ }+ resErr := responseError(res)+ res.Body.Close()+ switch {+ // Check for bad nonce before isRetriable because it may have been returned+ // with an unretriable response code such as 400 Bad Request.+ case isBadNonce(resErr):+ // Consider any previously stored nonce values to be invalid.+ c.clearNonces()+ case !isRetriable(res.StatusCode):+ return nil, resErr+ }+ retry.inc()+ // Ignore the error value from retry.backoff+ // and return the one from last retry, as received from the CA.+ if err := retry.backoff(ctx, req, res); err != nil {+ return nil, resErr+ }+ }+}++// postNoRetry signs the body with the given key and POSTs it to the provided url.+// The body argument must be JSON-serializable.+// It is used by c.post to retry unsuccessful attempts.+func (c *Client) postNoRetry(ctx context.Context, key crypto.Signer, url string, body interface{}) (*http.Response, *http.Request, error) {+ nonce, err := c.popNonce(ctx, url)+ if err != nil {+ return nil, nil, err+ }+ b, err := jwsEncodeJSON(body, key, nonce)+ if err != nil {+ return nil, nil, err+ }+ req, err := http.NewRequest("POST", url, bytes.NewReader(b))+ if err != nil {+ return nil, nil, err+ }+ req.Header.Set("Content-Type", "application/jose+json")+ res, err := c.doNoRetry(ctx, req)+ if err != nil {+ return nil, nil, err+ }+ c.addNonce(res.Header)+ return res, req, nil+}++// doNoRetry issues a request req, replacing its context (if any) with ctx.+func (c *Client) doNoRetry(ctx context.Context, req *http.Request) (*http.Response, error) {+ res, err := c.httpClient().Do(req.WithContext(ctx))+ if err != nil {+ select {+ case <-ctx.Done():+ // Prefer the unadorned context error.+ // (The acme package had tests assuming this, previously from ctxhttp's+ // behavior, predating net/http supporting contexts natively)+ // TODO(bradfitz): reconsider this in the future. But for now this+ // requires no test updates.+ return nil, ctx.Err()+ default:+ return nil, err+ }+ }+ return res, nil+}++func (c *Client) httpClient() *http.Client {+ if c.HTTPClient != nil {+ return c.HTTPClient+ }+ return http.DefaultClient+}++// isBadNonce reports whether err is an ACME "badnonce" error.+func isBadNonce(err error) bool {+ // According to the spec badNonce is urn:ietf:params:acme:error:badNonce.+ // However, ACME servers in the wild return their versions of the error.+ // See https://tools.ietf.org/html/draft-ietf-acme-acme-02#section-5.4+ // and https://github.com/letsencrypt/boulder/blob/0e07eacb/docs/acme-divergences.md#section-66.+ ae, ok := err.(*Error)+ return ok && strings.HasSuffix(strings.ToLower(ae.ProblemType), ":badnonce")+}++// isRetriable reports whether a request can be retried+// based on the response status code.+//+// Note that a "bad nonce" error is returned with a non-retriable 400 Bad Request code.+// Callers should parse the response and check with isBadNonce.+func isRetriable(code int) bool {+ return code <= 399 || code >= 500 || code == http.StatusTooManyRequests+}++// responseError creates an error of Error type from resp.+func responseError(resp *http.Response) error {+ // don't care if ReadAll returns an error:+ // json.Unmarshal will fail in that case anyway+ b, _ := ioutil.ReadAll(resp.Body)+ e := &wireError{Status: resp.StatusCode}+ if err := json.Unmarshal(b, e); err != nil {+ // this is not a regular error response:+ // populate detail with anything we received,+ // e.Status will already contain HTTP response code value+ e.Detail = string(b)+ if e.Detail == "" {+ e.Detail = resp.Status+ }+ }+ return e.error(resp.Header)+}diff --git a/vendor/golang.org/x/crypto/acme/jws.go b/vendor/golang.org/x/crypto/acme/jws.goindex 6cbca25de..1093b5039 100644--- a/vendor/golang.org/x/crypto/acme/jws.go+++ b/vendor/golang.org/x/crypto/acme/jws.go@@ -25,7 +25,7 @@ func jwsEncodeJSON(claimset interface{}, key crypto.Signer, nonce string) ([]bytif err != nil {return nil, err}- alg, sha := jwsHasher(key)+ alg, sha := jwsHasher(key.Public())if alg == "" || !sha.Available() {return nil, ErrUnsupportedKey}@@ -97,13 +97,16 @@ func jwkEncode(pub crypto.PublicKey) (string, error) {}// jwsSign signs the digest using the given key.-// It returns ErrUnsupportedKey if the key type is unknown.-// The hash is used only for RSA keys.+// The hash is unused for ECDSA keys.+//+// Note: non-stdlib crypto.Signer implementations are expected to return+// the signature in the format as specified in RFC7518.+// See https://tools.ietf.org/html/rfc7518 for more details.func jwsSign(key crypto.Signer, hash crypto.Hash, digest []byte) ([]byte, error) {- switch key := key.(type) {- case *rsa.PrivateKey:- return key.Sign(rand.Reader, digest, hash)- case *ecdsa.PrivateKey:+ if key, ok := key.(*ecdsa.PrivateKey); ok {+ // The key.Sign method of ecdsa returns ASN1-encoded signature.+ // So, we use the package Sign function instead+ // to get R and S values directly and format the result accordingly.r, s, err := ecdsa.Sign(rand.Reader, key, digest)if err != nil {return nil, err@@ -118,18 +121,18 @@ func jwsSign(key crypto.Signer, hash crypto.Hash, digest []byte) ([]byte, error)copy(sig[size*2-len(sb):], sb)return sig, nil}- return nil, ErrUnsupportedKey+ return key.Sign(rand.Reader, digest, hash)}// jwsHasher indicates suitable JWS algorithm name and a hash function// to use for signing a digest with the provided key.// It returns ("", 0) if the key is not supported.-func jwsHasher(key crypto.Signer) (string, crypto.Hash) {- switch key := key.(type) {- case *rsa.PrivateKey:+func jwsHasher(pub crypto.PublicKey) (string, crypto.Hash) {+ switch pub := pub.(type) {+ case *rsa.PublicKey:return "RS256", crypto.SHA256- case *ecdsa.PrivateKey:- switch key.Params().Name {+ case *ecdsa.PublicKey:+ switch pub.Params().Name {case "P-256":return "ES256", crypto.SHA256case "P-384":diff --git a/vendor/golang.org/x/crypto/acme/types.go b/vendor/golang.org/x/crypto/acme/types.goindex 3e199749e..54792c065 100644--- a/vendor/golang.org/x/crypto/acme/types.go+++ b/vendor/golang.org/x/crypto/acme/types.go@@ -104,7 +104,7 @@ func RateLimit(err error) (time.Duration, bool) {if e.Header == nil {return 0, true}- return retryAfter(e.Header.Get("Retry-After"), 0), true+ return retryAfter(e.Header.Get("Retry-After")), true}// Account is a user account. It is associated with a private key.@@ -296,8 +296,8 @@ func (e *wireError) error(h http.Header) *Error {}}-// CertOption is an optional argument type for the TLSSNIxChallengeCert methods for-// customizing a temporary certificate for TLS-SNI challenges.+// CertOption is an optional argument type for the TLS ChallengeCert methods for+// customizing a temporary certificate for TLS-based challenges.type CertOption interface {privateCertOpt()}@@ -317,7 +317,7 @@ func (*certOptKey) privateCertOpt() {}// WithTemplate creates an option for specifying a certificate template.// See x509.CreateCertificate for template usage details.//-// In TLSSNIxChallengeCert methods, the template is also used as parent,+// In TLS ChallengeCert methods, the template is also used as parent,// resulting in a self-signed certificate.// The DNSNames field of t is always overwritten for tls-sni challenge certs.func WithTemplate(t *x509.Certificate) CertOption {diff --git a/vendor/golang.org/x/image/bmp/reader.go b/vendor/golang.org/x/image/bmp/reader.goindex a0f2715cd..c10a022f6 100644--- a/vendor/golang.org/x/image/bmp/reader.go+++ b/vendor/golang.org/x/image/bmp/reader.go@@ -137,20 +137,26 @@ func decodeConfig(r io.Reader) (config image.Config, bitsPerPixel int, topDown b// We only support those BMP images that are a BITMAPFILEHEADER// immediately followed by a BITMAPINFOHEADER.const (- fileHeaderLen = 14- infoHeaderLen = 40+ fileHeaderLen = 14+ infoHeaderLen = 40+ v4InfoHeaderLen = 108+ v5InfoHeaderLen = 124)var b [1024]byte- if _, err := io.ReadFull(r, b[:fileHeaderLen+infoHeaderLen]); err != nil {+ if _, err := io.ReadFull(r, b[:fileHeaderLen+4]); err != nil {return image.Config{}, 0, false, err}if string(b[:2]) != "BM" {return image.Config{}, 0, false, errors.New("bmp: invalid format")}offset := readUint32(b[10:14])- if readUint32(b[14:18]) != infoHeaderLen {+ infoLen := readUint32(b[14:18])+ if infoLen != infoHeaderLen && infoLen != v4InfoHeaderLen && infoLen != v5InfoHeaderLen {return image.Config{}, 0, false, ErrUnsupported}+ if _, err := io.ReadFull(r, b[fileHeaderLen+4:fileHeaderLen+infoLen]); err != nil {+ return image.Config{}, 0, false, err+ }width := int(int32(readUint32(b[18:22])))height := int(int32(readUint32(b[22:26])))if height < 0 {@@ -159,14 +165,22 @@ func decodeConfig(r io.Reader) (config image.Config, bitsPerPixel int, topDown bif width < 0 || height < 0 {return image.Config{}, 0, false, ErrUnsupported}- // We only support 1 plane, 8 or 24 bits per pixel and no compression.+ // We only support 1 plane and 8, 24 or 32 bits per pixel and no+ // compression.planes, bpp, compression := readUint16(b[26:28]), readUint16(b[28:30]), readUint32(b[30:34])+ // if compression is set to BITFIELDS, but the bitmask is set to the default bitmask+ // that would be used if compression was set to 0, we can continue as if compression was 0+ if compression == 3 && infoLen > infoHeaderLen &&+ readUint32(b[54:58]) == 0xff0000 && readUint32(b[58:62]) == 0xff00 &&+ readUint32(b[62:66]) == 0xff && readUint32(b[66:70]) == 0xff000000 {+ compression = 0+ }if planes != 1 || compression != 0 {return image.Config{}, 0, false, ErrUnsupported}switch bpp {case 8:- if offset != fileHeaderLen+infoHeaderLen+256*4 {+ if offset != fileHeaderLen+infoLen+256*4 {return image.Config{}, 0, false, ErrUnsupported}_, err = io.ReadFull(r, b[:256*4])@@ -181,12 +195,12 @@ func decodeConfig(r io.Reader) (config image.Config, bitsPerPixel int, topDown b}return image.Config{ColorModel: pcm, Width: width, Height: height}, 8, topDown, nilcase 24:- if offset != fileHeaderLen+infoHeaderLen {+ if offset != fileHeaderLen+infoLen {return image.Config{}, 0, false, ErrUnsupported}return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 24, topDown, nilcase 32:- if offset != fileHeaderLen+infoHeaderLen {+ if offset != fileHeaderLen+infoLen {return image.Config{}, 0, false, ErrUnsupported}return image.Config{ColorModel: color.RGBAModel, Width: width, Height: height}, 32, topDown, nildiff --git a/vendor/golang.org/x/image/bmp/writer.go b/vendor/golang.org/x/image/bmp/writer.goindex 6947968a4..f07b39dba 100644--- a/vendor/golang.org/x/image/bmp/writer.go+++ b/vendor/golang.org/x/image/bmp/writer.go@@ -49,20 +49,91 @@ func encodePaletted(w io.Writer, pix []uint8, dx, dy, stride, step int) error {return nil}-func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride, step int) error {+func encodeRGBA(w io.Writer, pix []uint8, dx, dy, stride, step int, opaque bool) error {buf := make([]byte, step)- for y := dy - 1; y >= 0; y-- {- min := y*stride + 0- max := y*stride + dx*4- off := 0- for i := min; i < max; i += 4 {- buf[off+2] = pix[i+0]- buf[off+1] = pix[i+1]- buf[off+0] = pix[i+2]- off += 3+ if opaque {+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ for i := min; i < max; i += 4 {+ buf[off+2] = pix[i+0]+ buf[off+1] = pix[i+1]+ buf[off+0] = pix[i+2]+ off += 3+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }}- if _, err := w.Write(buf); err != nil {- return err+ } else {+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ for i := min; i < max; i += 4 {+ a := uint32(pix[i+3])+ if a == 0 {+ buf[off+2] = 0+ buf[off+1] = 0+ buf[off+0] = 0+ buf[off+3] = 0+ off += 4+ continue+ } else if a == 0xff {+ buf[off+2] = pix[i+0]+ buf[off+1] = pix[i+1]+ buf[off+0] = pix[i+2]+ buf[off+3] = 0xff+ off += 4+ continue+ }+ buf[off+2] = uint8(((uint32(pix[i+0]) * 0xffff) / a) >> 8)+ buf[off+1] = uint8(((uint32(pix[i+1]) * 0xffff) / a) >> 8)+ buf[off+0] = uint8(((uint32(pix[i+2]) * 0xffff) / a) >> 8)+ buf[off+3] = uint8(a)+ off += 4+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ }+ return nil+}++func encodeNRGBA(w io.Writer, pix []uint8, dx, dy, stride, step int, opaque bool) error {+ buf := make([]byte, step)+ if opaque {+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ for i := min; i < max; i += 4 {+ buf[off+2] = pix[i+0]+ buf[off+1] = pix[i+1]+ buf[off+0] = pix[i+2]+ off += 3+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }+ }+ } else {+ for y := dy - 1; y >= 0; y-- {+ min := y*stride + 0+ max := y*stride + dx*4+ off := 0+ for i := min; i < max; i += 4 {+ buf[off+2] = pix[i+0]+ buf[off+1] = pix[i+1]+ buf[off+0] = pix[i+2]+ buf[off+3] = pix[i+3]+ off += 4+ }+ if _, err := w.Write(buf); err != nil {+ return err+ }}}return nil@@ -105,6 +176,7 @@ func Encode(w io.Writer, m image.Image) error {var step intvar palette []byte+ var opaque boolswitch m := m.(type) {case *image.Gray:step = (d.X + 3) &^ 3@@ -134,6 +206,28 @@ func Encode(w io.Writer, m image.Image) error {h.fileSize += uint32(len(palette)) + h.imageSizeh.pixOffset += uint32(len(palette))h.bpp = 8+ case *image.RGBA:+ opaque = m.Opaque()+ if opaque {+ step = (3*d.X + 3) &^ 3+ h.bpp = 24+ } else {+ step = 4 * d.X+ h.bpp = 32+ }+ h.imageSize = uint32(d.Y * step)+ h.fileSize += h.imageSize+ case *image.NRGBA:+ opaque = m.Opaque()+ if opaque {+ step = (3*d.X + 3) &^ 3+ h.bpp = 24+ } else {+ step = 4 * d.X+ h.bpp = 32+ }+ h.imageSize = uint32(d.Y * step)+ h.fileSize += h.imageSizedefault:step = (3*d.X + 3) &^ 3h.imageSize = uint32(d.Y * step)@@ -160,7 +254,9 @@ func Encode(w io.Writer, m image.Image) error {case *image.Paletted:return encodePaletted(w, m.Pix, d.X, d.Y, m.Stride, step)case *image.RGBA:- return encodeRGBA(w, m.Pix, d.X, d.Y, m.Stride, step)+ return encodeRGBA(w, m.Pix, d.X, d.Y, m.Stride, step, opaque)+ case *image.NRGBA:+ return encodeNRGBA(w, m.Pix, d.X, d.Y, m.Stride, step, opaque)}return encode(w, m, step)}diff --git a/vendor/golang.org/x/image/draw/draw.go b/vendor/golang.org/x/image/draw/draw.goindex dfaa7fc55..cd5aaba64 100644--- a/vendor/golang.org/x/image/draw/draw.go+++ b/vendor/golang.org/x/image/draw/draw.go@@ -11,9 +11,8 @@// package in the standard library.package draw-// This file, and the go1_*.go files, just contains the API exported by the-// image/draw package in the standard library. Other files in this package-// provide additional features.+// This file just contains the API exported by the image/draw package in the+// standard library. Other files in this package provide additional features.import ("image"@@ -32,6 +31,9 @@ func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, masdraw.DrawMask(dst, r, src, sp, mask, mp, draw.Op(op))}+// Drawer contains the Draw method.+type Drawer = draw.Drawer+// FloydSteinberg is a Drawer that is the Src Op with Floyd-Steinberg error// diffusion.var FloydSteinberg Drawer = floydSteinberg{}@@ -41,3 +43,19 @@ type floydSteinberg struct{}func (floydSteinberg) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) {draw.FloydSteinberg.Draw(dst, r, src, sp)}++// Image is an image.Image with a Set method to change a single pixel.+type Image = draw.Image++// Op is a Porter-Duff compositing operator.+type Op = draw.Op++const (+ // Over specifies ``(src in mask) over dst''.+ Over Op = draw.Over+ // Src specifies ``src in mask''.+ Src Op = draw.Src+)++// Quantizer produces a palette for an image.+type Quantizer = draw.Quantizerdiff --git a/vendor/golang.org/x/image/draw/gen.go b/vendor/golang.org/x/image/draw/gen.goindex 65a712350..822bb6a50 100644--- a/vendor/golang.org/x/image/draw/gen.go+++ b/vendor/golang.org/x/image/draw/gen.go@@ -877,8 +877,9 @@ func relName(s string) string {const (codeRoot = `func (z $receiver) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {- // Try to simplify a Scale to a Copy.- if dr.Size() == sr.Size() {+ // Try to simplify a Scale to a Copy when DstMask is not specified.+ // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow.+ if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) {Copy(dst, dr.Min, src, sr, op, opts)return}diff --git a/vendor/golang.org/x/image/draw/go1_8.go b/vendor/golang.org/x/image/draw/go1_8.godeleted file mode 100644index ec192b717..000000000--- a/vendor/golang.org/x/image/draw/go1_8.go+++ /dev/null@@ -1,49 +0,0 @@-// Copyright 2015 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 !go1.9,!go1.8.typealias--package draw--import (- "image"- "image/color"- "image/draw"-)--// Drawer contains the Draw method.-type Drawer interface {- // Draw aligns r.Min in dst with sp in src and then replaces the- // rectangle r in dst with the result of drawing src on dst.- Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point)-}--// Image is an image.Image with a Set method to change a single pixel.-type Image interface {- image.Image- Set(x, y int, c color.Color)-}--// Op is a Porter-Duff compositing operator.-type Op int--const (- // Over specifies ``(src in mask) over dst''.- Over Op = Op(draw.Over)- // Src specifies ``src in mask''.- Src Op = Op(draw.Src)-)--// Draw implements the Drawer interface by calling the Draw function with-// this Op.-func (op Op) Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) {- (draw.Op(op)).Draw(dst, r, src, sp)-}--// Quantizer produces a palette for an image.-type Quantizer interface {- // Quantize appends up to cap(p) - len(p) colors to p and returns the- // updated palette suitable for converting m to a paletted image.- Quantize(p color.Palette, m image.Image) color.Palette-}diff --git a/vendor/golang.org/x/image/draw/go1_9.go b/vendor/golang.org/x/image/draw/go1_9.godeleted file mode 100644index fc548e947..000000000--- a/vendor/golang.org/x/image/draw/go1_9.go+++ /dev/null@@ -1,57 +0,0 @@-// Copyright 2016 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 go1.9 go1.8.typealias--package draw--import (- "image/draw"-)--// We use type aliases (new in Go 1.9) for the exported names from the standard-// library's image/draw package. This is not merely syntactic sugar for-//-// type Drawer draw.Drawer-//-// as aliasing means that the types in this package, such as draw.Image and-// draw.Op, are identical to the corresponding draw.Image and draw.Op types in-// the standard library. In comparison, prior to Go 1.9, the code in go1_8.go-// defines new types that mimic the old but are different types.-//-// The package documentation, in draw.go, explicitly gives the intent of this-// package:-//-// This package is a superset of and a drop-in replacement for the-// image/draw package in the standard library.-//-// Drop-in replacement means that I can replace all of my "image/draw" imports-// with "golang.org/x/image/draw", to access additional features in this-// package, and no further changes are required. That's mostly true, but not-// completely true unless we use type aliases.-//-// Without type aliases, users might need to import both "image/draw" and-// "golang.org/x/image/draw" in order to convert from two conceptually-// equivalent but different (from the compiler's point of view) types, such as-// from one draw.Op type to another draw.Op type, to satisfy some other-// interface or function signature.--// Drawer contains the Draw method.-type Drawer = draw.Drawer--// Image is an image.Image with a Set method to change a single pixel.-type Image = draw.Image--// Op is a Porter-Duff compositing operator.-type Op = draw.Op--const (- // Over specifies ``(src in mask) over dst''.- Over Op = draw.Over- // Src specifies ``src in mask''.- Src Op = draw.Src-)--// Quantizer produces a palette for an image.-type Quantizer = draw.Quantizerdiff --git a/vendor/golang.org/x/image/draw/impl.go b/vendor/golang.org/x/image/draw/impl.goindex 637887be6..75498adbd 100644--- a/vendor/golang.org/x/image/draw/impl.go+++ b/vendor/golang.org/x/image/draw/impl.go@@ -11,8 +11,9 @@ import ()func (z nnInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {- // Try to simplify a Scale to a Copy.- if dr.Size() == sr.Size() {+ // Try to simplify a Scale to a Copy when DstMask is not specified.+ // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow.+ if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) {Copy(dst, dr.Min, src, sr, op, opts)return}@@ -1048,8 +1049,9 @@ func (nnInterpolator) transform_Image_Image_Src(dst Image, dr, adr image.Rectang}func (z ablInterpolator) Scale(dst Image, dr image.Rectangle, src image.Image, sr image.Rectangle, op Op, opts *Options) {- // Try to simplify a Scale to a Copy.- if dr.Size() == sr.Size() {+ // Try to simplify a Scale to a Copy when DstMask is not specified.+ // If DstMask is not nil, Copy will call Scale back with same dr and sr, and cause stack overflow.+ if dr.Size() == sr.Size() && (opts == nil || opts.DstMask == nil) {Copy(dst, dr.Min, src, sr, op, opts)return}diff --git a/vendor/golang.org/x/image/draw/scale.go b/vendor/golang.org/x/image/draw/scale.goindex 98ab404eb..00121a129 100644--- a/vendor/golang.org/x/image/draw/scale.go+++ b/vendor/golang.org/x/image/draw/scale.go@@ -46,8 +46,8 @@ type Scaler interface {//// For example, if m is the matrix//-// m00 m01 m02-// m10 m11 m12+// m00 m01 m02+// m10 m11 m12//// then the src-space point (sx, sy) maps to the dst-space point// (m00*sx + m01*sy + m02, m10*sx + m11*sy + m12).@@ -65,7 +65,7 @@ type Options struct {// the src image are drawn from.//// A dst or src mask image having a zero alpha (transparent) pixel value in- // the respective coordinate space means that that dst pixel is entirely+ // the respective coordinate space means that dst pixel is entirely// unaffected or that src pixel is considered transparent black. A full// alpha (opaque) value means that the dst pixel is maximally affected or// the src pixel contributes maximally. The default values, nil, are@@ -408,11 +408,9 @@ func clipAffectedDestRect(adr image.Rectangle, dstMask image.Image, dstMaskP imaif dstMask == nil {return adr, nil}- // TODO: enable this fast path once Go 1.5 is released, where an- // image.Rectangle implements image.Image.- // if r, ok := dstMask.(image.Rectangle); ok {- // return adr.Intersect(r.Sub(dstMaskP)), nil- // }+ if r, ok := dstMask.(image.Rectangle); ok {+ return adr.Intersect(r.Sub(dstMaskP)), nil+ }// TODO: clip to dstMask.Bounds() if the color model implies that out-of-bounds means 0 alpha?return adr, dstMask}diff --git a/vendor/golang.org/x/image/font/font.go b/vendor/golang.org/x/image/font/font.goindex 05f4357c7..4d9d63c24 100644--- a/vendor/golang.org/x/image/font/font.go+++ b/vendor/golang.org/x/image/font/font.go@@ -86,6 +86,18 @@ type Metrics struct {// value is typically positive, even though a descender goes below the// baseline.Descent fixed.Int26_6++ // XHeight is the distance from the top of non-ascending lowercase letters+ // to the baseline.+ XHeight fixed.Int26_6++ // CapHeight is the distance from the top of uppercase letters to the+ // baseline.+ CapHeight fixed.Int26_6++ // CaretSlope is the slope of a caret as a vector with the Y axis pointing up.+ // The slope {0, 1} is the vertical caret.+ CaretSlope image.Point}// Drawer draws text on a destination image.diff --git a/vendor/golang.org/x/image/tiff/reader.go b/vendor/golang.org/x/image/tiff/reader.goindex 0e3d3325f..ce2ef718c 100644--- a/vendor/golang.org/x/image/tiff/reader.go+++ b/vendor/golang.org/x/image/tiff/reader.go@@ -110,7 +110,7 @@ func (d *decoder) ifdUint(p []byte) (u []uint, err error) {return u, nil}-// parseIFD decides whether the the IFD entry in p is "interesting" and+// parseIFD decides whether the IFD entry in p is "interesting" and// stows away the data in the decoder. It returns the tag number of the// entry and an error, if any.func (d *decoder) parseIFD(p []byte) (int, error) {@@ -264,6 +264,9 @@ func (d *decoder) decode(dst image.Image, xmin, ymin, xmax, ymax int) error {}img.SetGray16(x, y, color.Gray16{v})}+ if rMaxX == img.Bounds().Max.X {+ d.off += 2 * (xmax - img.Bounds().Max.X)+ }}} else {img := dst.(*image.Gray)diff --git a/vendor/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.goindex d3681ab42..a3c021d3f 100644--- a/vendor/golang.org/x/net/context/context.go+++ b/vendor/golang.org/x/net/context/context.go@@ -5,6 +5,8 @@// Package context defines the Context type, which carries deadlines,// cancelation signals, and other request-scoped values across API boundaries// and between processes.+// As of Go 1.7 this package is available in the standard library under the+// name context. https://golang.org/pkg/context.//// Incoming requests to a server should create a Context, and outgoing calls to// servers should accept a Context. The chain of function calls between mustdiff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.goindex 606cf1f97..37dc0cfdb 100644--- a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go+++ b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp.go@@ -2,18 +2,15 @@// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.-// +build go1.7-// Package ctxhttp provides helper functions for performing context-aware HTTP requests.package ctxhttp // import "golang.org/x/net/context/ctxhttp"import (+ "context""io""net/http""net/url""strings"-- "golang.org/x/net/context")// Do sends an HTTP request with the provided http.Client and returnsdiff --git a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go b/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.godeleted file mode 100644index 926870cc2..000000000--- a/vendor/golang.org/x/net/context/ctxhttp/ctxhttp_pre17.go+++ /dev/null@@ -1,147 +0,0 @@-// Copyright 2015 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 !go1.7--package ctxhttp // import "golang.org/x/net/context/ctxhttp"--import (- "io"- "net/http"- "net/url"- "strings"-- "golang.org/x/net/context"-)--func nop() {}--var (- testHookContextDoneBeforeHeaders = nop- testHookDoReturned = nop- testHookDidBodyClose = nop-)--// Do sends an HTTP request with the provided http.Client and returns an HTTP response.-// If the client is nil, http.DefaultClient is used.-// If the context is canceled or times out, ctx.Err() will be returned.-func Do(ctx context.Context, client *http.Client, req *http.Request) (*http.Response, error) {- if client == nil {- client = http.DefaultClient- }-- // TODO(djd): Respect any existing value of req.Cancel.- cancel := make(chan struct{})- req.Cancel = cancel-- type responseAndError struct {- resp *http.Response- err error- }- result := make(chan responseAndError, 1)-- // Make local copies of test hooks closed over by goroutines below.- // Prevents data races in tests.- testHookDoReturned := testHookDoReturned- testHookDidBodyClose := testHookDidBodyClose-- go func() {- resp, err := client.Do(req)- testHookDoReturned()- result <- responseAndError{resp, err}- }()-- var resp *http.Response-- select {- case <-ctx.Done():- testHookContextDoneBeforeHeaders()- close(cancel)- // Clean up after the goroutine calling client.Do:- go func() {- if r := <-result; r.resp != nil {- testHookDidBodyClose()- r.resp.Body.Close()- }- }()- return nil, ctx.Err()- case r := <-result:- var err error- resp, err = r.resp, r.err- if err != nil {- return resp, err- }- }-- c := make(chan struct{})- go func() {- select {- case <-ctx.Done():- close(cancel)- case <-c:- // The response's Body is closed.- }- }()- resp.Body = ¬ifyingReader{resp.Body, c}-- return resp, nil-}--// Get issues a GET request via the Do function.-func Get(ctx context.Context, client *http.Client, url string) (*http.Response, error) {- req, err := http.NewRequest("GET", url, nil)- if err != nil {- return nil, err- }- return Do(ctx, client, req)-}--// Head issues a HEAD request via the Do function.-func Head(ctx context.Context, client *http.Client, url string) (*http.Response, error) {- req, err := http.NewRequest("HEAD", url, nil)- if err != nil {- return nil, err- }- return Do(ctx, client, req)-}--// Post issues a POST request via the Do function.-func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {- req, err := http.NewRequest("POST", url, body)- if err != nil {- return nil, err- }- req.Header.Set("Content-Type", bodyType)- return Do(ctx, client, req)-}--// PostForm issues a POST request via the Do function.-func PostForm(ctx context.Context, client *http.Client, url string, data url.Values) (*http.Response, error) {- return Post(ctx, client, url, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))-}--// notifyingReader is an io.ReadCloser that closes the notify channel after-// Close is called or a Read fails on the underlying ReadCloser.-type notifyingReader struct {- io.ReadCloser- notify chan<- struct{}-}--func (r *notifyingReader) Read(p []byte) (int, error) {- n, err := r.ReadCloser.Read(p)- if err != nil && r.notify != nil {- close(r.notify)- r.notify = nil- }- return n, err-}--func (r *notifyingReader) Close() error {- err := r.ReadCloser.Close()- if r.notify != nil {- close(r.notify)- r.notify = nil- }- return err-}diff --git a/vendor/golang.org/x/oauth2/README.md b/vendor/golang.org/x/oauth2/README.mdindex eb8dcee17..68f436ed9 100644--- a/vendor/golang.org/x/oauth2/README.md+++ b/vendor/golang.org/x/oauth2/README.md@@ -24,7 +24,9 @@ See godoc for further documentation and examples.In change 96e89be (March 2015), we removed the `oauth2.Context2` type in favorof the [`context.Context`](https://golang.org/x/net/context#Context) type from-the `golang.org/x/net/context` package+the `golang.org/x/net/context` package. Later replaced by the standard `context` package+of the [`context.Context`](https://golang.org/pkg/context#Context) type.+This means it's no longer possible to use the "Classic App Engine"`appengine.Context` type with the `oauth2` package. (You're using@@ -44,7 +46,7 @@ with the `oauth2` package.```goimport (- "golang.org/x/net/context"+ "context""golang.org/x/oauth2""golang.org/x/oauth2/google"newappengine "google.golang.org/appengine"@@ -68,6 +70,13 @@ func handler(w http.ResponseWriter, r *http.Request) {}```+## Policy for new packages++We no longer accept new provider-specific packages in this repo. For+defining provider endpoints and provider-specific OAuth2 behavior, we+encourage you to create packages elsewhere. We'll keep the existing+packages for compatibility.+## Report Issues / Send PatchesThis repository uses Gerrit for code changes. To learn how to submit changes todiff --git a/vendor/golang.org/x/oauth2/facebook/facebook.go b/vendor/golang.org/x/oauth2/facebook/facebook.goindex 14c801a2a..21c49e7f2 100644--- a/vendor/golang.org/x/oauth2/facebook/facebook.go+++ b/vendor/golang.org/x/oauth2/facebook/facebook.go@@ -11,6 +11,6 @@ import (// Endpoint is Facebook's OAuth 2.0 endpoint.var Endpoint = oauth2.Endpoint{- AuthURL: "https://www.facebook.com/dialog/oauth",- TokenURL: "https://graph.facebook.com/oauth/access_token",+ AuthURL: "https://www.facebook.com/v3.1/dialog/oauth",+ TokenURL: "https://graph.facebook.com/v3.1/oauth/access_token",}diff --git a/vendor/golang.org/x/oauth2/google/appengine.go b/vendor/golang.org/x/oauth2/google/appengine.godeleted file mode 100644index 50d918b87..000000000--- a/vendor/golang.org/x/oauth2/google/appengine.go+++ /dev/null@@ -1,89 +0,0 @@-// Copyright 2014 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.--package google--import (- "sort"- "strings"- "sync"- "time"-- "golang.org/x/net/context"- "golang.org/x/oauth2"-)--// appengineFlex is set at init time by appengineflex_hook.go. If true, we are on App Engine Flex.-var appengineFlex bool--// Set at init time by appengine_hook.go. If nil, we're not on App Engine.-var appengineTokenFunc func(c context.Context, scopes ...string) (token string, expiry time.Time, err error)--// Set at init time by appengine_hook.go. If nil, we're not on App Engine.-var appengineAppIDFunc func(c context.Context) string--// AppEngineTokenSource returns a token source that fetches tokens-// issued to the current App Engine application's service account.-// If you are implementing a 3-legged OAuth 2.0 flow on App Engine-// that involves user accounts, see oauth2.Config instead.-//-// The provided context must have come from appengine.NewContext.-func AppEngineTokenSource(ctx context.Context, scope ...string) oauth2.TokenSource {- if appengineTokenFunc == nil {- panic("google: AppEngineTokenSource can only be used on App Engine.")- }- scopes := append([]string{}, scope...)- sort.Strings(scopes)- return &appEngineTokenSource{- ctx: ctx,- scopes: scopes,- key: strings.Join(scopes, " "),- }-}--// aeTokens helps the fetched tokens to be reused until their expiration.-var (- aeTokensMu sync.Mutex- aeTokens = make(map[string]*tokenLock) // key is space-separated scopes-)--type tokenLock struct {- mu sync.Mutex // guards t; held while fetching or updating t- t *oauth2.Token-}--type appEngineTokenSource struct {- ctx context.Context- scopes []string- key string // to aeTokens map; space-separated scopes-}--func (ts *appEngineTokenSource) Token() (*oauth2.Token, error) {- if appengineTokenFunc == nil {- panic("google: AppEngineTokenSource can only be used on App Engine.")- }-- aeTokensMu.Lock()- tok, ok := aeTokens[ts.key]- if !ok {- tok = &tokenLock{}- aeTokens[ts.key] = tok- }- aeTokensMu.Unlock()-- tok.mu.Lock()- defer tok.mu.Unlock()- if tok.t.Valid() {- return tok.t, nil- }- access, exp, err := appengineTokenFunc(ts.ctx, ts.scopes...)- if err != nil {- return nil, err- }- tok.t = &oauth2.Token{- AccessToken: access,- Expiry: exp,- }- return tok.t, nil-}diff --git a/vendor/golang.org/x/oauth2/google/appengine_hook.go b/vendor/golang.org/x/oauth2/google/appengine_hook.godeleted file mode 100644index 56669eaa9..000000000--- a/vendor/golang.org/x/oauth2/google/appengine_hook.go+++ /dev/null@@ -1,14 +0,0 @@-// Copyright 2015 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 appengine appenginevm--package google--import "google.golang.org/appengine"--func init() {- appengineTokenFunc = appengine.AccessToken- appengineAppIDFunc = appengine.AppID-}diff --git a/vendor/golang.org/x/oauth2/google/appengineflex_hook.go b/vendor/golang.org/x/oauth2/google/appengineflex_hook.godeleted file mode 100644index 5d0231af2..000000000--- a/vendor/golang.org/x/oauth2/google/appengineflex_hook.go+++ /dev/null@@ -1,11 +0,0 @@-// Copyright 2015 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 appenginevm--package google--func init() {- appengineFlex = true // Flex doesn't support appengine.AccessToken; depend on metadata server.-}diff --git a/vendor/golang.org/x/oauth2/google/default.go b/vendor/golang.org/x/oauth2/google/default.godeleted file mode 100644index a31607437..000000000--- a/vendor/golang.org/x/oauth2/google/default.go+++ /dev/null@@ -1,115 +0,0 @@-// Copyright 2015 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.--package google--import (- "encoding/json"- "fmt"- "io/ioutil"- "net/http"- "os"- "path/filepath"- "runtime"-- "cloud.google.com/go/compute/metadata"- "golang.org/x/net/context"- "golang.org/x/oauth2"-)--// DefaultClient returns an HTTP Client that uses the-// DefaultTokenSource to obtain authentication credentials.-func DefaultClient(ctx context.Context, scope ...string) (*http.Client, error) {- ts, err := DefaultTokenSource(ctx, scope...)- if err != nil {- return nil, err- }- return oauth2.NewClient(ctx, ts), nil-}--// DefaultTokenSource returns the token source for-// "Application Default Credentials".-// It is a shortcut for FindDefaultCredentials(ctx, scope).TokenSource.-func DefaultTokenSource(ctx context.Context, scope ...string) (oauth2.TokenSource, error) {- creds, err := FindDefaultCredentials(ctx, scope...)- if err != nil {- return nil, err- }- return creds.TokenSource, nil-}--// Common implementation for FindDefaultCredentials.-func findDefaultCredentials(ctx context.Context, scopes []string) (*DefaultCredentials, error) {- // First, try the environment variable.- const envVar = "GOOGLE_APPLICATION_CREDENTIALS"- if filename := os.Getenv(envVar); filename != "" {- creds, err := readCredentialsFile(ctx, filename, scopes)- if err != nil {- return nil, fmt.Errorf("google: error getting credentials using %v environment variable: %v", envVar, err)- }- return creds, nil- }-- // Second, try a well-known file.- filename := wellKnownFile()- if creds, err := readCredentialsFile(ctx, filename, scopes); err == nil {- return creds, nil- } else if !os.IsNotExist(err) {- return nil, fmt.Errorf("google: error getting credentials using well-known file (%v): %v", filename, err)- }-- // Third, if we're on Google App Engine use those credentials.- if appengineTokenFunc != nil && !appengineFlex {- return &DefaultCredentials{- ProjectID: appengineAppIDFunc(ctx),- TokenSource: AppEngineTokenSource(ctx, scopes...),- }, nil- }-- // Fourth, if we're on Google Compute Engine use the metadata server.- if metadata.OnGCE() {- id, _ := metadata.ProjectID()- return &DefaultCredentials{- ProjectID: id,- TokenSource: ComputeTokenSource(""),- }, nil- }-- // None are found; return helpful error.- const url = "https://developers.google.com/accounts/docs/application-default-credentials"- return nil, fmt.Errorf("google: could not find default credentials. See %v for more information.", url)-}--// Common implementation for CredentialsFromJSON.-func credentialsFromJSON(ctx context.Context, jsonData []byte, scopes []string) (*DefaultCredentials, error) {- var f credentialsFile- if err := json.Unmarshal(jsonData, &f); err != nil {- return nil, err- }- ts, err := f.tokenSource(ctx, append([]string(nil), scopes...))- if err != nil {- return nil, err- }- return &DefaultCredentials{- ProjectID: f.ProjectID,- TokenSource: ts,- JSON: jsonData,- }, nil-}--func wellKnownFile() string {- const f = "application_default_credentials.json"- if runtime.GOOS == "windows" {- return filepath.Join(os.Getenv("APPDATA"), "gcloud", f)- }- return filepath.Join(guessUnixHomeDir(), ".config", "gcloud", f)-}--func readCredentialsFile(ctx context.Context, filename string, scopes []string) (*DefaultCredentials, error) {- b, err := ioutil.ReadFile(filename)- if err != nil {- return nil, err- }- return CredentialsFromJSON(ctx, b, scopes...)-}diff --git a/vendor/golang.org/x/oauth2/google/doc_go19.go b/vendor/golang.org/x/oauth2/google/doc_go19.godeleted file mode 100644index 2a86325fe..000000000--- a/vendor/golang.org/x/oauth2/google/doc_go19.go+++ /dev/null@@ -1,42 +0,0 @@-// Copyright 2018 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 go1.9--// Package google provides support for making OAuth2 authorized and authenticated-// HTTP requests to Google APIs. It supports the Web server flow, client-side-// credentials, service accounts, Google Compute Engine service accounts, and Google-// App Engine service accounts.-//-// A brief overview of the package follows. For more information, please read-// https://developers.google.com/accounts/docs/OAuth2-// and-// https://developers.google.com/accounts/docs/application-default-credentials.-//-// OAuth2 Configs-//-// Two functions in this package return golang.org/x/oauth2.Config values from Google credential-// data. Google supports two JSON formats for OAuth2 credentials: one is handled by ConfigFromJSON,-// the other by JWTConfigFromJSON. The returned Config can be used to obtain a TokenSource or-// create an http.Client.-//-//-// Credentials-//-// The Credentials type represents Google credentials, including Application Default-// Credentials.-//-// Use FindDefaultCredentials to obtain Application Default Credentials.-// FindDefaultCredentials looks in some well-known places for a credentials file, and-// will call AppEngineTokenSource or ComputeTokenSource as needed.-//-// DefaultClient and DefaultTokenSource are convenience methods. They first call FindDefaultCredentials,-// then use the credentials to construct an http.Client or an oauth2.TokenSource.-//-// Use CredentialsFromJSON to obtain credentials from either of the two JSON formats-// described in OAuth2 Configs, above. The TokenSource in the returned value is the-// same as the one obtained from the oauth2.Config returned from ConfigFromJSON or-// JWTConfigFromJSON, but the Credentials may contain additional information-// that is useful is some circumstances.-package google // import "golang.org/x/oauth2/google"diff --git a/vendor/golang.org/x/oauth2/google/doc_not_go19.go b/vendor/golang.org/x/oauth2/google/doc_not_go19.godeleted file mode 100644index 5c3c6e148..000000000--- a/vendor/golang.org/x/oauth2/google/doc_not_go19.go+++ /dev/null@@ -1,43 +0,0 @@-// Copyright 2018 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 !go1.9--// Package google provides support for making OAuth2 authorized and authenticated-// HTTP requests to Google APIs. It supports the Web server flow, client-side-// credentials, service accounts, Google Compute Engine service accounts, and Google-// App Engine service accounts.-//-// A brief overview of the package follows. For more information, please read-// https://developers.google.com/accounts/docs/OAuth2-// and-// https://developers.google.com/accounts/docs/application-default-credentials.-//-// OAuth2 Configs-//-// Two functions in this package return golang.org/x/oauth2.Config values from Google credential-// data. Google supports two JSON formats for OAuth2 credentials: one is handled by ConfigFromJSON,-// the other by JWTConfigFromJSON. The returned Config can be used to obtain a TokenSource or-// create an http.Client.-//-//-// Credentials-//-// The DefaultCredentials type represents Google Application Default Credentials, as-// well as other forms of credential.-//-// Use FindDefaultCredentials to obtain Application Default Credentials.-// FindDefaultCredentials looks in some well-known places for a credentials file, and-// will call AppEngineTokenSource or ComputeTokenSource as needed.-//-// DefaultClient and DefaultTokenSource are convenience methods. They first call FindDefaultCredentials,-// then use the credentials to construct an http.Client or an oauth2.TokenSource.-//-// Use CredentialsFromJSON to obtain credentials from either of the two JSON-// formats described in OAuth2 Configs, above. (The DefaultCredentials returned may-// not be "Application Default Credentials".) The TokenSource in the returned value-// is the same as the one obtained from the oauth2.Config returned from-// ConfigFromJSON or JWTConfigFromJSON, but the DefaultCredentials may contain-// additional information that is useful is some circumstances.-package google // import "golang.org/x/oauth2/google"diff --git a/vendor/golang.org/x/oauth2/google/go19.go b/vendor/golang.org/x/oauth2/google/go19.godeleted file mode 100644index 4d0318b1e..000000000--- a/vendor/golang.org/x/oauth2/google/go19.go+++ /dev/null@@ -1,57 +0,0 @@-// Copyright 2018 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 go1.9--package google--import (- "golang.org/x/net/context"- "golang.org/x/oauth2"-)--// Credentials holds Google credentials, including "Application Default Credentials".-// For more details, see:-// https://developers.google.com/accounts/docs/application-default-credentials-type Credentials struct {- ProjectID string // may be empty- TokenSource oauth2.TokenSource-- // JSON contains the raw bytes from a JSON credentials file.- // This field may be nil if authentication is provided by the- // environment and not with a credentials file, e.g. when code is- // running on Google Cloud Platform.- JSON []byte-}--// DefaultCredentials is the old name of Credentials.-//-// Deprecated: use Credentials instead.-type DefaultCredentials = Credentials--// FindDefaultCredentials searches for "Application Default Credentials".-//-// It looks for credentials in the following places,-// preferring the first location found:-//-// 1. A JSON file whose path is specified by the-// GOOGLE_APPLICATION_CREDENTIALS environment variable.-// 2. A JSON file in a location known to the gcloud command-line tool.-// On Windows, this is %APPDATA%/gcloud/application_default_credentials.json.-// On other systems, $HOME/.config/gcloud/application_default_credentials.json.-// 3. On Google App Engine it uses the appengine.AccessToken function.-// 4. On Google Compute Engine and Google App Engine Managed VMs, it fetches-// credentials from the metadata server.-// (In this final case any provided scopes are ignored.)-func FindDefaultCredentials(ctx context.Context, scopes ...string) (*Credentials, error) {- return findDefaultCredentials(ctx, scopes)-}--// CredentialsFromJSON obtains Google credentials from a JSON value. The JSON can-// represent either a Google Developers Console client_credentials.json file (as in-// ConfigFromJSON) or a Google Developers service account key file (as in-// JWTConfigFromJSON).-func CredentialsFromJSON(ctx context.Context, jsonData []byte, scopes ...string) (*Credentials, error) {- return credentialsFromJSON(ctx, jsonData, scopes)-}diff --git a/vendor/golang.org/x/oauth2/google/google.go b/vendor/golang.org/x/oauth2/google/google.godeleted file mode 100644index f7481fbcc..000000000--- a/vendor/golang.org/x/oauth2/google/google.go+++ /dev/null@@ -1,192 +0,0 @@-// Copyright 2014 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.--package google--import (- "encoding/json"- "errors"- "fmt"- "strings"- "time"-- "cloud.google.com/go/compute/metadata"- "golang.org/x/net/context"- "golang.org/x/oauth2"- "golang.org/x/oauth2/jwt"-)--// Endpoint is Google's OAuth 2.0 endpoint.-var Endpoint = oauth2.Endpoint{- AuthURL: "https://accounts.google.com/o/oauth2/auth",- TokenURL: "https://accounts.google.com/o/oauth2/token",-}--// JWTTokenURL is Google's OAuth 2.0 token URL to use with the JWT flow.-const JWTTokenURL = "https://accounts.google.com/o/oauth2/token"--// ConfigFromJSON uses a Google Developers Console client_credentials.json-// file to construct a config.-// client_credentials.json can be downloaded from-// https://console.developers.google.com, under "Credentials". Download the Web-// application credentials in the JSON format and provide the contents of the-// file as jsonKey.-func ConfigFromJSON(jsonKey []byte, scope ...string) (*oauth2.Config, error) {- type cred struct {- ClientID string `json:"client_id"`- ClientSecret string `json:"client_secret"`- RedirectURIs []string `json:"redirect_uris"`- AuthURI string `json:"auth_uri"`- TokenURI string `json:"token_uri"`- }- var j struct {- Web *cred `json:"web"`- Installed *cred `json:"installed"`- }- if err := json.Unmarshal(jsonKey, &j); err != nil {- return nil, err- }- var c *cred- switch {- case j.Web != nil:- c = j.Web- case j.Installed != nil:- c = j.Installed- default:- return nil, fmt.Errorf("oauth2/google: no credentials found")- }- if len(c.RedirectURIs) < 1 {- return nil, errors.New("oauth2/google: missing redirect URL in the client_credentials.json")- }- return &oauth2.Config{- ClientID: c.ClientID,- ClientSecret: c.ClientSecret,- RedirectURL: c.RedirectURIs[0],- Scopes: scope,- Endpoint: oauth2.Endpoint{- AuthURL: c.AuthURI,- TokenURL: c.TokenURI,- },- }, nil-}--// JWTConfigFromJSON uses a Google Developers service account JSON key file to read-// the credentials that authorize and authenticate the requests.-// Create a service account on "Credentials" for your project at-// https://console.developers.google.com to download a JSON key file.-func JWTConfigFromJSON(jsonKey []byte, scope ...string) (*jwt.Config, error) {- var f credentialsFile- if err := json.Unmarshal(jsonKey, &f); err != nil {- return nil, err- }- if f.Type != serviceAccountKey {- return nil, fmt.Errorf("google: read JWT from JSON credentials: 'type' field is %q (expected %q)", f.Type, serviceAccountKey)- }- scope = append([]string(nil), scope...) // copy- return f.jwtConfig(scope), nil-}--// JSON key file types.-const (- serviceAccountKey = "service_account"- userCredentialsKey = "authorized_user"-)--// credentialsFile is the unmarshalled representation of a credentials file.-type credentialsFile struct {- Type string `json:"type"` // serviceAccountKey or userCredentialsKey-- // Service Account fields- ClientEmail string `json:"client_email"`- PrivateKeyID string `json:"private_key_id"`- PrivateKey string `json:"private_key"`- TokenURL string `json:"token_uri"`- ProjectID string `json:"project_id"`-- // User Credential fields- // (These typically come from gcloud auth.)- ClientSecret string `json:"client_secret"`- ClientID string `json:"client_id"`- RefreshToken string `json:"refresh_token"`-}--func (f *credentialsFile) jwtConfig(scopes []string) *jwt.Config {- cfg := &jwt.Config{- Email: f.ClientEmail,- PrivateKey: []byte(f.PrivateKey),- PrivateKeyID: f.PrivateKeyID,- Scopes: scopes,- TokenURL: f.TokenURL,- }- if cfg.TokenURL == "" {- cfg.TokenURL = JWTTokenURL- }- return cfg-}--func (f *credentialsFile) tokenSource(ctx context.Context, scopes []string) (oauth2.TokenSource, error) {- switch f.Type {- case serviceAccountKey:- cfg := f.jwtConfig(scopes)- return cfg.TokenSource(ctx), nil- case userCredentialsKey:- cfg := &oauth2.Config{- ClientID: f.ClientID,- ClientSecret: f.ClientSecret,- Scopes: scopes,- Endpoint: Endpoint,- }- tok := &oauth2.Token{RefreshToken: f.RefreshToken}- return cfg.TokenSource(ctx, tok), nil- case "":- return nil, errors.New("missing 'type' field in credentials")- default:- return nil, fmt.Errorf("unknown credential type: %q", f.Type)- }-}--// ComputeTokenSource returns a token source that fetches access tokens-// from Google Compute Engine (GCE)'s metadata server. It's only valid to use-// this token source if your program is running on a GCE instance.-// If no account is specified, "default" is used.-// Further information about retrieving access tokens from the GCE metadata-// server can be found at https://cloud.google.com/compute/docs/authentication.-func ComputeTokenSource(account string) oauth2.TokenSource {- return oauth2.ReuseTokenSource(nil, computeSource{account: account})-}--type computeSource struct {- account string-}--func (cs computeSource) Token() (*oauth2.Token, error) {- if !metadata.OnGCE() {- return nil, errors.New("oauth2/google: can't get a token from the metadata service; not running on GCE")- }- acct := cs.account- if acct == "" {- acct = "default"- }- tokenJSON, err := metadata.Get("instance/service-accounts/" + acct + "/token")- if err != nil {- return nil, err- }- var res struct {- AccessToken string `json:"access_token"`- ExpiresInSec int `json:"expires_in"`- TokenType string `json:"token_type"`- }- err = json.NewDecoder(strings.NewReader(tokenJSON)).Decode(&res)- if err != nil {- return nil, fmt.Errorf("oauth2/google: invalid token JSON from metadata: %v", err)- }- if res.ExpiresInSec == 0 || res.AccessToken == "" {- return nil, fmt.Errorf("oauth2/google: incomplete token received from metadata")- }- return &oauth2.Token{- AccessToken: res.AccessToken,- TokenType: res.TokenType,- Expiry: time.Now().Add(time.Duration(res.ExpiresInSec) * time.Second),- }, nil-}diff --git a/vendor/golang.org/x/oauth2/google/jwt.go b/vendor/golang.org/x/oauth2/google/jwt.godeleted file mode 100644index b0fdb3a88..000000000--- a/vendor/golang.org/x/oauth2/google/jwt.go+++ /dev/null@@ -1,74 +0,0 @@-// Copyright 2015 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.--package google--import (- "crypto/rsa"- "fmt"- "time"-- "golang.org/x/oauth2"- "golang.org/x/oauth2/internal"- "golang.org/x/oauth2/jws"-)--// JWTAccessTokenSourceFromJSON uses a Google Developers service account JSON-// key file to read the credentials that authorize and authenticate the-// requests, and returns a TokenSource that does not use any OAuth2 flow but-// instead creates a JWT and sends that as the access token.-// The audience is typically a URL that specifies the scope of the credentials.-//-// Note that this is not a standard OAuth flow, but rather an-// optimization supported by a few Google services.-// Unless you know otherwise, you should use JWTConfigFromJSON instead.-func JWTAccessTokenSourceFromJSON(jsonKey []byte, audience string) (oauth2.TokenSource, error) {- cfg, err := JWTConfigFromJSON(jsonKey)- if err != nil {- return nil, fmt.Errorf("google: could not parse JSON key: %v", err)- }- pk, err := internal.ParseKey(cfg.PrivateKey)- if err != nil {- return nil, fmt.Errorf("google: could not parse key: %v", err)- }- ts := &jwtAccessTokenSource{- email: cfg.Email,- audience: audience,- pk: pk,- pkID: cfg.PrivateKeyID,- }- tok, err := ts.Token()- if err != nil {- return nil, err- }- return oauth2.ReuseTokenSource(tok, ts), nil-}--type jwtAccessTokenSource struct {- email, audience string- pk *rsa.PrivateKey- pkID string-}--func (ts *jwtAccessTokenSource) Token() (*oauth2.Token, error) {- iat := time.Now()- exp := iat.Add(time.Hour)- cs := &jws.ClaimSet{- Iss: ts.email,- Sub: ts.email,- Aud: ts.audience,- Iat: iat.Unix(),- Exp: exp.Unix(),- }- hdr := &jws.Header{- Algorithm: "RS256",- Typ: "JWT",- KeyID: string(ts.pkID),- }- msg, err := jws.Encode(hdr, cs, ts.pk)- if err != nil {- return nil, fmt.Errorf("google: could not encode JWT: %v", err)- }- return &oauth2.Token{AccessToken: msg, TokenType: "Bearer", Expiry: exp}, nil-}diff --git a/vendor/golang.org/x/oauth2/google/not_go19.go b/vendor/golang.org/x/oauth2/google/not_go19.godeleted file mode 100644index 544e40624..000000000--- a/vendor/golang.org/x/oauth2/google/not_go19.go+++ /dev/null@@ -1,54 +0,0 @@-// Copyright 2018 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 !go1.9--package google--import (- "golang.org/x/net/context"- "golang.org/x/oauth2"-)--// DefaultCredentials holds Google credentials, including "Application Default Credentials".-// For more details, see:-// https://developers.google.com/accounts/docs/application-default-credentials-type DefaultCredentials struct {- ProjectID string // may be empty- TokenSource oauth2.TokenSource-- // JSON contains the raw bytes from a JSON credentials file.- // This field may be nil if authentication is provided by the- // environment and not with a credentials file, e.g. when code is- // running on Google Cloud Platform.- JSON []byte-}--// FindDefaultCredentials searches for "Application Default Credentials".-//-// It looks for credentials in the following places,-// preferring the first location found:-//-// 1. A JSON file whose path is specified by the-// GOOGLE_APPLICATION_CREDENTIALS environment variable.-// 2. A JSON file in a location known to the gcloud command-line tool.-// On Windows, this is %APPDATA%/gcloud/application_default_credentials.json.-// On other systems, $HOME/.config/gcloud/application_default_credentials.json.-// 3. On Google App Engine it uses the appengine.AccessToken function.-// 4. On Google Compute Engine and Google App Engine Managed VMs, it fetches-// credentials from the metadata server.-// (In this final case any provided scopes are ignored.)-func FindDefaultCredentials(ctx context.Context, scopes ...string) (*DefaultCredentials, error) {- return findDefaultCredentials(ctx, scopes)-}--// CredentialsFromJSON obtains Google credentials from a JSON value. The JSON can-// represent either a Google Developers Console client_credentials.json file (as in-// ConfigFromJSON) or a Google Developers service account key file (as in-// JWTConfigFromJSON).-//-// Note: despite the name, the returned credentials may not be Application Default Credentials.-func CredentialsFromJSON(ctx context.Context, jsonData []byte, scopes ...string) (*DefaultCredentials, error) {- return credentialsFromJSON(ctx, jsonData, scopes)-}diff --git a/vendor/golang.org/x/oauth2/google/sdk.go b/vendor/golang.org/x/oauth2/google/sdk.godeleted file mode 100644index b9660cadd..000000000--- a/vendor/golang.org/x/oauth2/google/sdk.go+++ /dev/null@@ -1,201 +0,0 @@-// Copyright 2015 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.--package google--import (- "bufio"- "encoding/json"- "errors"- "fmt"- "io"- "net/http"- "os"- "os/user"- "path/filepath"- "runtime"- "strings"- "time"-- "golang.org/x/net/context"- "golang.org/x/oauth2"-)--type sdkCredentials struct {- Data []struct {- Credential struct {- ClientID string `json:"client_id"`- ClientSecret string `json:"client_secret"`- AccessToken string `json:"access_token"`- RefreshToken string `json:"refresh_token"`- TokenExpiry *time.Time `json:"token_expiry"`- } `json:"credential"`- Key struct {- Account string `json:"account"`- Scope string `json:"scope"`- } `json:"key"`- }-}--// An SDKConfig provides access to tokens from an account already-// authorized via the Google Cloud SDK.-type SDKConfig struct {- conf oauth2.Config- initialToken *oauth2.Token-}--// NewSDKConfig creates an SDKConfig for the given Google Cloud SDK-// account. If account is empty, the account currently active in-// Google Cloud SDK properties is used.-// Google Cloud SDK credentials must be created by running `gcloud auth`-// before using this function.-// The Google Cloud SDK is available at https://cloud.google.com/sdk/.-func NewSDKConfig(account string) (*SDKConfig, error) {- configPath, err := sdkConfigPath()- if err != nil {- return nil, fmt.Errorf("oauth2/google: error getting SDK config path: %v", err)- }- credentialsPath := filepath.Join(configPath, "credentials")- f, err := os.Open(credentialsPath)- if err != nil {- return nil, fmt.Errorf("oauth2/google: failed to load SDK credentials: %v", err)- }- defer f.Close()-- var c sdkCredentials- if err := json.NewDecoder(f).Decode(&c); err != nil {- return nil, fmt.Errorf("oauth2/google: failed to decode SDK credentials from %q: %v", credentialsPath, err)- }- if len(c.Data) == 0 {- return nil, fmt.Errorf("oauth2/google: no credentials found in %q, run `gcloud auth login` to create one", credentialsPath)- }- if account == "" {- propertiesPath := filepath.Join(configPath, "properties")- f, err := os.Open(propertiesPath)- if err != nil {- return nil, fmt.Errorf("oauth2/google: failed to load SDK properties: %v", err)- }- defer f.Close()- ini, err := parseINI(f)- if err != nil {- return nil, fmt.Errorf("oauth2/google: failed to parse SDK properties %q: %v", propertiesPath, err)- }- core, ok := ini["core"]- if !ok {- return nil, fmt.Errorf("oauth2/google: failed to find [core] section in %v", ini)- }- active, ok := core["account"]- if !ok {- return nil, fmt.Errorf("oauth2/google: failed to find %q attribute in %v", "account", core)- }- account = active- }-- for _, d := range c.Data {- if account == "" || d.Key.Account == account {- if d.Credential.AccessToken == "" && d.Credential.RefreshToken == "" {- return nil, fmt.Errorf("oauth2/google: no token available for account %q", account)- }- var expiry time.Time- if d.Credential.TokenExpiry != nil {- expiry = *d.Credential.TokenExpiry- }- return &SDKConfig{- conf: oauth2.Config{- ClientID: d.Credential.ClientID,- ClientSecret: d.Credential.ClientSecret,- Scopes: strings.Split(d.Key.Scope, " "),- Endpoint: Endpoint,- RedirectURL: "oob",- },- initialToken: &oauth2.Token{- AccessToken: d.Credential.AccessToken,- RefreshToken: d.Credential.RefreshToken,- Expiry: expiry,- },- }, nil- }- }- return nil, fmt.Errorf("oauth2/google: no such credentials for account %q", account)-}--// Client returns an HTTP client using Google Cloud SDK credentials to-// authorize requests. The token will auto-refresh as necessary. The-// underlying http.RoundTripper will be obtained using the provided-// context. The returned client and its Transport should not be-// modified.-func (c *SDKConfig) Client(ctx context.Context) *http.Client {- return &http.Client{- Transport: &oauth2.Transport{- Source: c.TokenSource(ctx),- },- }-}--// TokenSource returns an oauth2.TokenSource that retrieve tokens from-// Google Cloud SDK credentials using the provided context.-// It will returns the current access token stored in the credentials,-// and refresh it when it expires, but it won't update the credentials-// with the new access token.-func (c *SDKConfig) TokenSource(ctx context.Context) oauth2.TokenSource {- return c.conf.TokenSource(ctx, c.initialToken)-}--// Scopes are the OAuth 2.0 scopes the current account is authorized for.-func (c *SDKConfig) Scopes() []string {- return c.conf.Scopes-}--func parseINI(ini io.Reader) (map[string]map[string]string, error) {- result := map[string]map[string]string{- "": {}, // root section- }- scanner := bufio.NewScanner(ini)- currentSection := ""- for scanner.Scan() {- line := strings.TrimSpace(scanner.Text())- if strings.HasPrefix(line, ";") {- // comment.- continue- }- if strings.HasPrefix(line, "[") && strings.HasSuffix(line, "]") {- currentSection = strings.TrimSpace(line[1 : len(line)-1])- result[currentSection] = map[string]string{}- continue- }- parts := strings.SplitN(line, "=", 2)- if len(parts) == 2 && parts[0] != "" {- result[currentSection][strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])- }- }- if err := scanner.Err(); err != nil {- return nil, fmt.Errorf("error scanning ini: %v", err)- }- return result, nil-}--// sdkConfigPath tries to guess where the gcloud config is located.-// It can be overridden during tests.-var sdkConfigPath = func() (string, error) {- if runtime.GOOS == "windows" {- return filepath.Join(os.Getenv("APPDATA"), "gcloud"), nil- }- homeDir := guessUnixHomeDir()- if homeDir == "" {- return "", errors.New("unable to get current user home directory: os/user lookup failed; $HOME is empty")- }- return filepath.Join(homeDir, ".config", "gcloud"), nil-}--func guessUnixHomeDir() string {- // Prefer $HOME over user.Current due to glibc bug: golang.org/issue/13470- if v := os.Getenv("HOME"); v != "" {- return v- }- // Else, fall back to user.Current:- if u, err := user.Current(); err == nil {- return u.HomeDir- }- return ""-}diff --git a/vendor/golang.org/x/oauth2/internal/oauth2.go b/vendor/golang.org/x/oauth2/internal/oauth2.goindex fc63fcab3..c0ab196cf 100644--- a/vendor/golang.org/x/oauth2/internal/oauth2.go+++ b/vendor/golang.org/x/oauth2/internal/oauth2.go@@ -26,7 +26,7 @@ func ParseKey(key []byte) (*rsa.PrivateKey, error) {if err != nil {parsedKey, err = x509.ParsePKCS1PrivateKey(key)if err != nil {- return nil, fmt.Errorf("private key should be a PEM or plain PKSC1 or PKCS8; parse error: %v", err)+ return nil, fmt.Errorf("private key should be a PEM or plain PKCS1 or PKCS8; parse error: %v", err)}}parsed, ok := parsedKey.(*rsa.PrivateKey)diff --git a/vendor/golang.org/x/oauth2/internal/token.go b/vendor/golang.org/x/oauth2/internal/token.goindex 999e668e6..a831b7746 100644--- a/vendor/golang.org/x/oauth2/internal/token.go+++ b/vendor/golang.org/x/oauth2/internal/token.go@@ -5,6 +5,7 @@package internalimport (+ "context""encoding/json""errors""fmt"@@ -17,7 +18,6 @@ import ("strings""time"- "golang.org/x/net/context""golang.org/x/net/context/ctxhttp")@@ -103,12 +103,14 @@ var brokenAuthHeaderProviders = []string{"https://api.twitch.tv/","https://id.twitch.tv/","https://app.box.com/",+ "https://api.box.com/","https://connect.stripe.com/","https://login.mailchimp.com/","https://login.microsoftonline.com/","https://login.salesforce.com/","https://login.windows.net","https://login.live.com/",+ "https://login.live-int.com/","https://oauth.sandbox.trainingpeaks.com/","https://oauth.trainingpeaks.com/","https://oauth.vk.com/",@@ -130,6 +132,11 @@ var brokenAuthHeaderProviders = []string{"https://multisport.todaysplan.com.au/rest/oauth/access_token","https://whats.todaysplan.com.au/rest/oauth/access_token","https://stackoverflow.com/oauth/access_token",+ "https://account.health.nokia.com",+ "https://accounts.zoho.com",+ "https://gitter.im/login/oauth/token",+ "https://openid-connect.onelogin.com/oidc",+ "https://api.dailymotion.com/oauth/token",}// brokenAuthHeaderDomains lists broken providers that issue dynamic endpoints.diff --git a/vendor/golang.org/x/oauth2/internal/transport.go b/vendor/golang.org/x/oauth2/internal/transport.goindex d16f9ae1f..572074a63 100644--- a/vendor/golang.org/x/oauth2/internal/transport.go+++ b/vendor/golang.org/x/oauth2/internal/transport.go@@ -5,9 +5,8 @@package internalimport (+ "context""net/http"-- "golang.org/x/net/context")// HTTPClient is the context key to use with golang.org/x/net/context'sdiff --git a/vendor/golang.org/x/oauth2/jws/jws.go b/vendor/golang.org/x/oauth2/jws/jws.godeleted file mode 100644index 683d2d271..000000000--- a/vendor/golang.org/x/oauth2/jws/jws.go+++ /dev/null@@ -1,182 +0,0 @@-// Copyright 2014 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.--// Package jws provides a partial implementation-// of JSON Web Signature encoding and decoding.-// It exists to support the golang.org/x/oauth2 package.-//-// See RFC 7515.-//-// Deprecated: this package is not intended for public use and might be-// removed in the future. It exists for internal use only.-// Please switch to another JWS package or copy this package into your own-// source tree.-package jws // import "golang.org/x/oauth2/jws"--import (- "bytes"- "crypto"- "crypto/rand"- "crypto/rsa"- "crypto/sha256"- "encoding/base64"- "encoding/json"- "errors"- "fmt"- "strings"- "time"-)--// ClaimSet contains information about the JWT signature including the-// permissions being requested (scopes), the target of the token, the issuer,-// the time the token was issued, and the lifetime of the token.-type ClaimSet struct {- Iss string `json:"iss"` // email address of the client_id of the application making the access token request- Scope string `json:"scope,omitempty"` // space-delimited list of the permissions the application requests- Aud string `json:"aud"` // descriptor of the intended target of the assertion (Optional).- Exp int64 `json:"exp"` // the expiration time of the assertion (seconds since Unix epoch)- Iat int64 `json:"iat"` // the time the assertion was issued (seconds since Unix epoch)- Typ string `json:"typ,omitempty"` // token type (Optional).-- // Email for which the application is requesting delegated access (Optional).- Sub string `json:"sub,omitempty"`-- // The old name of Sub. Client keeps setting Prn to be- // complaint with legacy OAuth 2.0 providers. (Optional)- Prn string `json:"prn,omitempty"`-- // See http://tools.ietf.org/html/draft-jones-json-web-token-10#section-4.3- // This array is marshalled using custom code (see (c *ClaimSet) encode()).- PrivateClaims map[string]interface{} `json:"-"`-}--func (c *ClaimSet) encode() (string, error) {- // Reverting time back for machines whose time is not perfectly in sync.- // If client machine's time is in the future according- // to Google servers, an access token will not be issued.- now := time.Now().Add(-10 * time.Second)- if c.Iat == 0 {- c.Iat = now.Unix()- }- if c.Exp == 0 {- c.Exp = now.Add(time.Hour).Unix()- }- if c.Exp < c.Iat {- return "", fmt.Errorf("jws: invalid Exp = %v; must be later than Iat = %v", c.Exp, c.Iat)- }-- b, err := json.Marshal(c)- if err != nil {- return "", err- }-- if len(c.PrivateClaims) == 0 {- return base64.RawURLEncoding.EncodeToString(b), nil- }-- // Marshal private claim set and then append it to b.- prv, err := json.Marshal(c.PrivateClaims)- if err != nil {- return "", fmt.Errorf("jws: invalid map of private claims %v", c.PrivateClaims)- }-- // Concatenate public and private claim JSON objects.- if !bytes.HasSuffix(b, []byte{'}'}) {- return "", fmt.Errorf("jws: invalid JSON %s", b)- }- if !bytes.HasPrefix(prv, []byte{'{'}) {- return "", fmt.Errorf("jws: invalid JSON %s", prv)- }- b[len(b)-1] = ',' // Replace closing curly brace with a comma.- b = append(b, prv[1:]...) // Append private claims.- return base64.RawURLEncoding.EncodeToString(b), nil-}--// Header represents the header for the signed JWS payloads.-type Header struct {- // The algorithm used for signature.- Algorithm string `json:"alg"`-- // Represents the token type.- Typ string `json:"typ"`-- // The optional hint of which key is being used.- KeyID string `json:"kid,omitempty"`-}--func (h *Header) encode() (string, error) {- b, err := json.Marshal(h)- if err != nil {- return "", err- }- return base64.RawURLEncoding.EncodeToString(b), nil-}--// Decode decodes a claim set from a JWS payload.-func Decode(payload string) (*ClaimSet, error) {- // decode returned id token to get expiry- s := strings.Split(payload, ".")- if len(s) < 2 {- // TODO(jbd): Provide more context about the error.- return nil, errors.New("jws: invalid token received")- }- decoded, err := base64.RawURLEncoding.DecodeString(s[1])- if err != nil {- return nil, err- }- c := &ClaimSet{}- err = json.NewDecoder(bytes.NewBuffer(decoded)).Decode(c)- return c, err-}--// Signer returns a signature for the given data.-type Signer func(data []byte) (sig []byte, err error)--// EncodeWithSigner encodes a header and claim set with the provided signer.-func EncodeWithSigner(header *Header, c *ClaimSet, sg Signer) (string, error) {- head, err := header.encode()- if err != nil {- return "", err- }- cs, err := c.encode()- if err != nil {- return "", err- }- ss := fmt.Sprintf("%s.%s", head, cs)- sig, err := sg([]byte(ss))- if err != nil {- return "", err- }- return fmt.Sprintf("%s.%s", ss, base64.RawURLEncoding.EncodeToString(sig)), nil-}--// Encode encodes a signed JWS with provided header and claim set.-// This invokes EncodeWithSigner using crypto/rsa.SignPKCS1v15 with the given RSA private key.-func Encode(header *Header, c *ClaimSet, key *rsa.PrivateKey) (string, error) {- sg := func(data []byte) (sig []byte, err error) {- h := sha256.New()- h.Write(data)- return rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, h.Sum(nil))- }- return EncodeWithSigner(header, c, sg)-}--// Verify tests whether the provided JWT token's signature was produced by the private key-// associated with the supplied public key.-func Verify(token string, key *rsa.PublicKey) error {- parts := strings.Split(token, ".")- if len(parts) != 3 {- return errors.New("jws: invalid token received, token must have 3 parts")- }-- signedContent := parts[0] + "." + parts[1]- signatureString, err := base64.RawURLEncoding.DecodeString(parts[2])- if err != nil {- return err- }-- h := sha256.New()- h.Write([]byte(signedContent))- return rsa.VerifyPKCS1v15(key, crypto.SHA256, h.Sum(nil), []byte(signatureString))-}diff --git a/vendor/golang.org/x/oauth2/jwt/jwt.go b/vendor/golang.org/x/oauth2/jwt/jwt.godeleted file mode 100644index e08f31595..000000000--- a/vendor/golang.org/x/oauth2/jwt/jwt.go+++ /dev/null@@ -1,162 +0,0 @@-// Copyright 2014 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.--// Package jwt implements the OAuth 2.0 JSON Web Token flow, commonly-// known as "two-legged OAuth 2.0".-//-// See: https://tools.ietf.org/html/draft-ietf-oauth-jwt-bearer-12-package jwt--import (- "encoding/json"- "fmt"- "io"- "io/ioutil"- "net/http"- "net/url"- "strings"- "time"-- "golang.org/x/net/context"- "golang.org/x/oauth2"- "golang.org/x/oauth2/internal"- "golang.org/x/oauth2/jws"-)--var (- defaultGrantType = "urn:ietf:params:oauth:grant-type:jwt-bearer"- defaultHeader = &jws.Header{Algorithm: "RS256", Typ: "JWT"}-)--// Config is the configuration for using JWT to fetch tokens,-// commonly known as "two-legged OAuth 2.0".-type Config struct {- // Email is the OAuth client identifier used when communicating with- // the configured OAuth provider.- Email string-- // PrivateKey contains the contents of an RSA private key or the- // contents of a PEM file that contains a private key. The provided- // private key is used to sign JWT payloads.- // PEM containers with a passphrase are not supported.- // Use the following command to convert a PKCS 12 file into a PEM.- //- // $ openssl pkcs12 -in key.p12 -out key.pem -nodes- //- PrivateKey []byte-- // PrivateKeyID contains an optional hint indicating which key is being- // used.- PrivateKeyID string-- // Subject is the optional user to impersonate.- Subject string-- // Scopes optionally specifies a list of requested permission scopes.- Scopes []string-- // TokenURL is the endpoint required to complete the 2-legged JWT flow.- TokenURL string-- // Expires optionally specifies how long the token is valid for.- Expires time.Duration-}--// TokenSource returns a JWT TokenSource using the configuration-// in c and the HTTP client from the provided context.-func (c *Config) TokenSource(ctx context.Context) oauth2.TokenSource {- return oauth2.ReuseTokenSource(nil, jwtSource{ctx, c})-}--// Client returns an HTTP client wrapping the context's-// HTTP transport and adding Authorization headers with tokens-// obtained from c.-//-// The returned client and its Transport should not be modified.-func (c *Config) Client(ctx context.Context) *http.Client {- return oauth2.NewClient(ctx, c.TokenSource(ctx))-}--// jwtSource is a source that always does a signed JWT request for a token.-// It should typically be wrapped with a reuseTokenSource.-type jwtSource struct {- ctx context.Context- conf *Config-}--func (js jwtSource) Token() (*oauth2.Token, error) {- pk, err := internal.ParseKey(js.conf.PrivateKey)- if err != nil {- return nil, err- }- hc := oauth2.NewClient(js.ctx, nil)- claimSet := &jws.ClaimSet{- Iss: js.conf.Email,- Scope: strings.Join(js.conf.Scopes, " "),- Aud: js.conf.TokenURL,- }- if subject := js.conf.Subject; subject != "" {- claimSet.Sub = subject- // prn is the old name of sub. Keep setting it- // to be compatible with legacy OAuth 2.0 providers.- claimSet.Prn = subject- }- if t := js.conf.Expires; t > 0 {- claimSet.Exp = time.Now().Add(t).Unix()- }- h := *defaultHeader- h.KeyID = js.conf.PrivateKeyID- payload, err := jws.Encode(&h, claimSet, pk)- if err != nil {- return nil, err- }- v := url.Values{}- v.Set("grant_type", defaultGrantType)- v.Set("assertion", payload)- resp, err := hc.PostForm(js.conf.TokenURL, v)- if err != nil {- return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)- }- defer resp.Body.Close()- body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1<<20))- if err != nil {- return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)- }- if c := resp.StatusCode; c < 200 || c > 299 {- return nil, &oauth2.RetrieveError{- Response: resp,- Body: body,- }- }- // tokenRes is the JSON response body.- var tokenRes struct {- AccessToken string `json:"access_token"`- TokenType string `json:"token_type"`- IDToken string `json:"id_token"`- ExpiresIn int64 `json:"expires_in"` // relative seconds from now- }- if err := json.Unmarshal(body, &tokenRes); err != nil {- return nil, fmt.Errorf("oauth2: cannot fetch token: %v", err)- }- token := &oauth2.Token{- AccessToken: tokenRes.AccessToken,- TokenType: tokenRes.TokenType,- }- raw := make(map[string]interface{})- json.Unmarshal(body, &raw) // no error checks for optional fields- token = token.WithExtra(raw)-- if secs := tokenRes.ExpiresIn; secs > 0 {- token.Expiry = time.Now().Add(time.Duration(secs) * time.Second)- }- if v := tokenRes.IDToken; v != "" {- // decode returned id token to get expiry- claimSet, err := jws.Decode(v)- if err != nil {- return nil, fmt.Errorf("oauth2: error decoding JWT token: %v", err)- }- token.Expiry = time.Unix(claimSet.Exp, 0)- }- return token, nil-}diff --git a/vendor/golang.org/x/oauth2/oauth2.go b/vendor/golang.org/x/oauth2/oauth2.goindex 16775d081..1e8e1b741 100644--- a/vendor/golang.org/x/oauth2/oauth2.go+++ b/vendor/golang.org/x/oauth2/oauth2.go@@ -10,13 +10,13 @@ package oauth2 // import "golang.org/x/oauth2"import ("bytes"+ "context""errors""net/http""net/url""strings""sync"- "golang.org/x/net/context""golang.org/x/oauth2/internal")@@ -164,8 +164,7 @@ func (c *Config) AuthCodeURL(state string, opts ...AuthCodeOption) string {// and when other authorization grant types are not available."// See https://tools.ietf.org/html/rfc6749#section-4.3 for more info.//-// The HTTP client to use is derived from the context.-// If nil, http.DefaultClient is used.+// The provided context optionally controls which HTTP client is used. See the HTTPClient variable.func (c *Config) PasswordCredentialsToken(ctx context.Context, username, password string) (*Token, error) {v := url.Values{"grant_type": {"password"},@@ -183,8 +182,7 @@ func (c *Config) PasswordCredentialsToken(ctx context.Context, username, passwor// It is used after a resource provider redirects the user back// to the Redirect URI (the URL obtained from AuthCodeURL).//-// The HTTP client to use is derived from the context.-// If a client is not provided via the context, http.DefaultClient is used.+// The provided context optionally controls which HTTP client is used. See the HTTPClient variable.//// The code will be in the *http.Request.FormValue("code"). Before// calling Exchange, be sure to validate FormValue("state").diff --git a/vendor/golang.org/x/oauth2/token.go b/vendor/golang.org/x/oauth2/token.goindex 34db8cdc8..9be1ae537 100644--- a/vendor/golang.org/x/oauth2/token.go+++ b/vendor/golang.org/x/oauth2/token.go@@ -5,6 +5,7 @@package oauth2import (+ "context""fmt""net/http""net/url"@@ -12,7 +13,6 @@ import ("strings""time"- "golang.org/x/net/context""golang.org/x/oauth2/internal")diff --git a/vendor/google.golang.org/appengine/.travis.yml b/vendor/google.golang.org/appengine/.travis.ymldeleted file mode 100644index 0762cb91b..000000000--- a/vendor/google.golang.org/appengine/.travis.yml+++ /dev/null@@ -1,18 +0,0 @@-language: go--go:- - 1.6.3- - 1.7.1--install:- - go get -v -t -d google.golang.org/appengine/...- - mkdir sdk- - curl -o sdk.zip "https://storage.googleapis.com/appengine-sdks/featured/go_appengine_sdk_linux_amd64-1.9.40.zip"- - unzip -q sdk.zip -d sdk- - export APPENGINE_DEV_APPSERVER=$(pwd)/sdk/go_appengine/dev_appserver.py--script:- - go version- - go test -v google.golang.org/appengine/...- - go test -v -race google.golang.org/appengine/...- - sdk/go_appengine/goapp test -v google.golang.org/appengine/...diff --git a/vendor/google.golang.org/appengine/README.md b/vendor/google.golang.org/appengine/README.mddeleted file mode 100644index b6b11d958..000000000--- a/vendor/google.golang.org/appengine/README.md+++ /dev/null@@ -1,73 +0,0 @@-# Go App Engine packages--[](https://travis-ci.org/golang/appengine)--This repository supports the Go runtime on App Engine,-including both the standard App Engine and the-"App Engine flexible environment" (formerly known as "Managed VMs").-It provides APIs for interacting with App Engine services.-Its canonical import path is `google.golang.org/appengine`.--See https://cloud.google.com/appengine/docs/go/-for more information.--File issue reports and feature requests on the [Google App Engine issue-tracker](https://code.google.com/p/googleappengine/issues/entry?template=Go%20defect).--## Directory structure-The top level directory of this repository is the `appengine` package. It-contains the-basic APIs (e.g. `appengine.NewContext`) that apply across APIs. Specific API-packages are in subdirectories (e.g. `datastore`).--There is an `internal` subdirectory that contains service protocol buffers,-plus packages required for connectivity to make API calls. App Engine apps-should not directly import any package under `internal`.--## Updating a Go App Engine app--This section describes how to update an older Go App Engine app to use-these packages. A provided tool, `aefix`, can help automate steps 2 and 3-(run `go get google.golang.org/appengine/cmd/aefix` to install it), but-read the details below since `aefix` can't perform all the changes.--### 1. Update YAML files (App Engine flexible environment / Managed VMs only)--The `app.yaml` file (and YAML files for modules) should have these new lines added:-```-vm: true-```-See https://cloud.google.com/appengine/docs/go/modules/#Go_Instance_scaling_and_class for details.--### 2. Update import paths--The import paths for App Engine packages are now fully qualified, based at `google.golang.org/appengine`.-You will need to update your code to use import paths starting with that; for instance,-code importing `appengine/datastore` will now need to import `google.golang.org/appengine/datastore`.--### 3. Update code using deprecated, removed or modified APIs--Most App Engine services are available with exactly the same API.-A few APIs were cleaned up, and some are not available yet.-This list summarises the differences:--* `appengine.Context` has been replaced with the `Context` type from `golang.org/x/net/context`.-* Logging methods that were on `appengine.Context` are now functions in `google.golang.org/appengine/log`.-* `appengine.Timeout` has been removed. Use `context.WithTimeout` instead.-* `appengine.Datacenter` now takes a `context.Context` argument.-* `datastore.PropertyLoadSaver` has been simplified to use slices in place of channels.-* `delay.Call` now returns an error.-* `search.FieldLoadSaver` now handles document metadata.-* `urlfetch.Transport` no longer has a Deadline field; set a deadline on the- `context.Context` instead.-* `aetest` no longer declares its own Context type, and uses the standard one instead.-* `taskqueue.QueueStats` no longer takes a maxTasks argument. That argument has been- deprecated and unused for a long time.-* `appengine.BackendHostname` and `appengine.BackendInstance` were for the deprecated backends feature.- Use `appengine.ModuleHostname`and `appengine.ModuleName` instead.-* Most of `appengine/file` and parts of `appengine/blobstore` are deprecated.- Use [Google Cloud Storage](https://godoc.org/cloud.google.com/go/storage) if the- feature you require is not present in the new- [blobstore package](https://google.golang.org/appengine/blobstore).-* `appengine/socket` is not required on App Engine flexible environment / Managed VMs.- Use the standard `net` package instead.diff --git a/vendor/google.golang.org/appengine/appengine.go b/vendor/google.golang.org/appengine/appengine.godeleted file mode 100644index 475cf2e32..000000000--- a/vendor/google.golang.org/appengine/appengine.go+++ /dev/null@@ -1,112 +0,0 @@-// Copyright 2011 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--// Package appengine provides basic functionality for Google App Engine.-//-// For more information on how to write Go apps for Google App Engine, see:-// https://cloud.google.com/appengine/docs/go/-package appengine // import "google.golang.org/appengine"--import (- "net/http"-- "github.com/golang/protobuf/proto"- "golang.org/x/net/context"-- "google.golang.org/appengine/internal"-)--// The gophers party all night; the rabbits provide the beats.--// Main is the principal entry point for an app running in App Engine.-//-// On App Engine Flexible it installs a trivial health checker if one isn't-// already registered, and starts listening on port 8080 (overridden by the-// $PORT environment variable).-//-// See https://cloud.google.com/appengine/docs/flexible/custom-runtimes#health_check_requests-// for details on how to do your own health checking.-//-// Main is not yet supported on App Engine Standard.-//-// Main never returns.-//-// Main is designed so that the app's main package looks like this:-//-// package main-//-// import (-// "google.golang.org/appengine"-//-// _ "myapp/package0"-// _ "myapp/package1"-// )-//-// func main() {-// appengine.Main()-// }-//-// The "myapp/packageX" packages are expected to register HTTP handlers-// in their init functions.-func Main() {- internal.Main()-}--// IsDevAppServer reports whether the App Engine app is running in the-// development App Server.-func IsDevAppServer() bool {- return internal.IsDevAppServer()-}--// NewContext returns a context for an in-flight HTTP request.-// This function is cheap.-func NewContext(req *http.Request) context.Context {- return WithContext(context.Background(), req)-}--// WithContext returns a copy of the parent context-// and associates it with an in-flight HTTP request.-// This function is cheap.-func WithContext(parent context.Context, req *http.Request) context.Context {- return internal.WithContext(parent, req)-}--// TODO(dsymonds): Add a Call function here? Otherwise other packages can't access internal.Call.--// BlobKey is a key for a blobstore blob.-//-// Conceptually, this type belongs in the blobstore package, but it lives in-// the appengine package to avoid a circular dependency: blobstore depends on-// datastore, and datastore needs to refer to the BlobKey type.-type BlobKey string--// GeoPoint represents a location as latitude/longitude in degrees.-type GeoPoint struct {- Lat, Lng float64-}--// Valid returns whether a GeoPoint is within [-90, 90] latitude and [-180, 180] longitude.-func (g GeoPoint) Valid() bool {- return -90 <= g.Lat && g.Lat <= 90 && -180 <= g.Lng && g.Lng <= 180-}--// APICallFunc defines a function type for handling an API call.-// See WithCallOverride.-type APICallFunc func(ctx context.Context, service, method string, in, out proto.Message) error--// WithAPICallFunc returns a copy of the parent context-// that will cause API calls to invoke f instead of their normal operation.-//-// This is intended for advanced users only.-func WithAPICallFunc(ctx context.Context, f APICallFunc) context.Context {- return internal.WithCallOverride(ctx, internal.CallOverrideFunc(f))-}--// APICall performs an API call.-//-// This is not intended for general use; it is exported for use in conjunction-// with WithAPICallFunc.-func APICall(ctx context.Context, service, method string, in, out proto.Message) error {- return internal.Call(ctx, service, method, in, out)-}diff --git a/vendor/google.golang.org/appengine/appengine_vm.go b/vendor/google.golang.org/appengine/appengine_vm.godeleted file mode 100644index f4b645aad..000000000--- a/vendor/google.golang.org/appengine/appengine_vm.go+++ /dev/null@@ -1,20 +0,0 @@-// Copyright 2015 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--// +build !appengine--package appengine--import (- "golang.org/x/net/context"-- "google.golang.org/appengine/internal"-)--// BackgroundContext returns a context not associated with a request.-// This should only be used when not servicing a request.-// This only works in App Engine "flexible environment".-func BackgroundContext() context.Context {- return internal.BackgroundContext()-}diff --git a/vendor/google.golang.org/appengine/errors.go b/vendor/google.golang.org/appengine/errors.godeleted file mode 100644index 16d0772e2..000000000--- a/vendor/google.golang.org/appengine/errors.go+++ /dev/null@@ -1,46 +0,0 @@-// Copyright 2011 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--// This file provides error functions for common API failure modes.--package appengine--import (- "fmt"-- "google.golang.org/appengine/internal"-)--// IsOverQuota reports whether err represents an API call failure-// due to insufficient available quota.-func IsOverQuota(err error) bool {- callErr, ok := err.(*internal.CallError)- return ok && callErr.Code == 4-}--// MultiError is returned by batch operations when there are errors with-// particular elements. Errors will be in a one-to-one correspondence with-// the input elements; successful elements will have a nil entry.-type MultiError []error--func (m MultiError) Error() string {- s, n := "", 0- for _, e := range m {- if e != nil {- if n == 0 {- s = e.Error()- }- n++- }- }- switch n {- case 0:- return "(0 errors)"- case 1:- return s- case 2:- return s + " (and 1 other error)"- }- return fmt.Sprintf("%s (and %d other errors)", s, n-1)-}diff --git a/vendor/google.golang.org/appengine/identity.go b/vendor/google.golang.org/appengine/identity.godeleted file mode 100644index b8dcf8f36..000000000--- a/vendor/google.golang.org/appengine/identity.go+++ /dev/null@@ -1,142 +0,0 @@-// Copyright 2011 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--package appengine--import (- "time"-- "golang.org/x/net/context"-- "google.golang.org/appengine/internal"- pb "google.golang.org/appengine/internal/app_identity"- modpb "google.golang.org/appengine/internal/modules"-)--// AppID returns the application ID for the current application.-// The string will be a plain application ID (e.g. "appid"), with a-// domain prefix for custom domain deployments (e.g. "example.com:appid").-func AppID(c context.Context) string { return internal.AppID(c) }--// DefaultVersionHostname returns the standard hostname of the default version-// of the current application (e.g. "my-app.appspot.com"). This is suitable for-// use in constructing URLs.-func DefaultVersionHostname(c context.Context) string {- return internal.DefaultVersionHostname(c)-}--// ModuleName returns the module name of the current instance.-func ModuleName(c context.Context) string {- return internal.ModuleName(c)-}--// ModuleHostname returns a hostname of a module instance.-// If module is the empty string, it refers to the module of the current instance.-// If version is empty, it refers to the version of the current instance if valid,-// or the default version of the module of the current instance.-// If instance is empty, ModuleHostname returns the load-balancing hostname.-func ModuleHostname(c context.Context, module, version, instance string) (string, error) {- req := &modpb.GetHostnameRequest{}- if module != "" {- req.Module = &module- }- if version != "" {- req.Version = &version- }- if instance != "" {- req.Instance = &instance- }- res := &modpb.GetHostnameResponse{}- if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {- return "", err- }- return *res.Hostname, nil-}--// VersionID returns the version ID for the current application.-// It will be of the form "X.Y", where X is specified in app.yaml,-// and Y is a number generated when each version of the app is uploaded.-// It does not include a module name.-func VersionID(c context.Context) string { return internal.VersionID(c) }--// InstanceID returns a mostly-unique identifier for this instance.-func InstanceID() string { return internal.InstanceID() }--// Datacenter returns an identifier for the datacenter that the instance is running in.-func Datacenter(c context.Context) string { return internal.Datacenter(c) }--// ServerSoftware returns the App Engine release version.-// In production, it looks like "Google App Engine/X.Y.Z".-// In the development appserver, it looks like "Development/X.Y".-func ServerSoftware() string { return internal.ServerSoftware() }--// RequestID returns a string that uniquely identifies the request.-func RequestID(c context.Context) string { return internal.RequestID(c) }--// AccessToken generates an OAuth2 access token for the specified scopes on-// behalf of service account of this application. This token will expire after-// the returned time.-func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) {- req := &pb.GetAccessTokenRequest{Scope: scopes}- res := &pb.GetAccessTokenResponse{}-- err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res)- if err != nil {- return "", time.Time{}, err- }- return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil-}--// Certificate represents a public certificate for the app.-type Certificate struct {- KeyName string- Data []byte // PEM-encoded X.509 certificate-}--// PublicCertificates retrieves the public certificates for the app.-// They can be used to verify a signature returned by SignBytes.-func PublicCertificates(c context.Context) ([]Certificate, error) {- req := &pb.GetPublicCertificateForAppRequest{}- res := &pb.GetPublicCertificateForAppResponse{}- if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil {- return nil, err- }- var cs []Certificate- for _, pc := range res.PublicCertificateList {- cs = append(cs, Certificate{- KeyName: pc.GetKeyName(),- Data: []byte(pc.GetX509CertificatePem()),- })- }- return cs, nil-}--// ServiceAccount returns a string representing the service account name, in-// the form of an email address (typically [email protected]).-func ServiceAccount(c context.Context) (string, error) {- req := &pb.GetServiceAccountNameRequest{}- res := &pb.GetServiceAccountNameResponse{}-- err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)- if err != nil {- return "", err- }- return res.GetServiceAccountName(), err-}--// SignBytes signs bytes using a private key unique to your application.-func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) {- req := &pb.SignForAppRequest{BytesToSign: bytes}- res := &pb.SignForAppResponse{}-- if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {- return "", nil, err- }- return res.GetKeyName(), res.GetSignatureBytes(), nil-}--func init() {- internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name)- internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name)-}diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.godeleted file mode 100644index 87d9701b8..000000000--- a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go+++ /dev/null@@ -1,296 +0,0 @@-// Code generated by protoc-gen-go.-// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto-// DO NOT EDIT!--/*-Package app_identity is a generated protocol buffer package.--It is generated from these files:- google.golang.org/appengine/internal/app_identity/app_identity_service.proto--It has these top-level messages:- AppIdentityServiceError- SignForAppRequest- SignForAppResponse- GetPublicCertificateForAppRequest- PublicCertificate- GetPublicCertificateForAppResponse- GetServiceAccountNameRequest- GetServiceAccountNameResponse- GetAccessTokenRequest- GetAccessTokenResponse- GetDefaultGcsBucketNameRequest- GetDefaultGcsBucketNameResponse-*/-package app_identity--import proto "github.com/golang/protobuf/proto"-import fmt "fmt"-import math "math"--// Reference imports to suppress errors if they are not otherwise used.-var _ = proto.Marshal-var _ = fmt.Errorf-var _ = math.Inf--type AppIdentityServiceError_ErrorCode int32--const (- AppIdentityServiceError_SUCCESS AppIdentityServiceError_ErrorCode = 0- AppIdentityServiceError_UNKNOWN_SCOPE AppIdentityServiceError_ErrorCode = 9- AppIdentityServiceError_BLOB_TOO_LARGE AppIdentityServiceError_ErrorCode = 1000- AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001- AppIdentityServiceError_NOT_A_VALID_APP AppIdentityServiceError_ErrorCode = 1002- AppIdentityServiceError_UNKNOWN_ERROR AppIdentityServiceError_ErrorCode = 1003- AppIdentityServiceError_NOT_ALLOWED AppIdentityServiceError_ErrorCode = 1005- AppIdentityServiceError_NOT_IMPLEMENTED AppIdentityServiceError_ErrorCode = 1006-)--var AppIdentityServiceError_ErrorCode_name = map[int32]string{- 0: "SUCCESS",- 9: "UNKNOWN_SCOPE",- 1000: "BLOB_TOO_LARGE",- 1001: "DEADLINE_EXCEEDED",- 1002: "NOT_A_VALID_APP",- 1003: "UNKNOWN_ERROR",- 1005: "NOT_ALLOWED",- 1006: "NOT_IMPLEMENTED",-}-var AppIdentityServiceError_ErrorCode_value = map[string]int32{- "SUCCESS": 0,- "UNKNOWN_SCOPE": 9,- "BLOB_TOO_LARGE": 1000,- "DEADLINE_EXCEEDED": 1001,- "NOT_A_VALID_APP": 1002,- "UNKNOWN_ERROR": 1003,- "NOT_ALLOWED": 1005,- "NOT_IMPLEMENTED": 1006,-}--func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode {- p := new(AppIdentityServiceError_ErrorCode)- *p = x- return p-}-func (x AppIdentityServiceError_ErrorCode) String() string {- return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x))-}-func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error {- value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode")- if err != nil {- return err- }- *x = AppIdentityServiceError_ErrorCode(value)- return nil-}--type AppIdentityServiceError struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *AppIdentityServiceError) Reset() { *m = AppIdentityServiceError{} }-func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) }-func (*AppIdentityServiceError) ProtoMessage() {}--type SignForAppRequest struct {- BytesToSign []byte `protobuf:"bytes,1,opt,name=bytes_to_sign" json:"bytes_to_sign,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *SignForAppRequest) Reset() { *m = SignForAppRequest{} }-func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) }-func (*SignForAppRequest) ProtoMessage() {}--func (m *SignForAppRequest) GetBytesToSign() []byte {- if m != nil {- return m.BytesToSign- }- return nil-}--type SignForAppResponse struct {- KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`- SignatureBytes []byte `protobuf:"bytes,2,opt,name=signature_bytes" json:"signature_bytes,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *SignForAppResponse) Reset() { *m = SignForAppResponse{} }-func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) }-func (*SignForAppResponse) ProtoMessage() {}--func (m *SignForAppResponse) GetKeyName() string {- if m != nil && m.KeyName != nil {- return *m.KeyName- }- return ""-}--func (m *SignForAppResponse) GetSignatureBytes() []byte {- if m != nil {- return m.SignatureBytes- }- return nil-}--type GetPublicCertificateForAppRequest struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *GetPublicCertificateForAppRequest) Reset() { *m = GetPublicCertificateForAppRequest{} }-func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) }-func (*GetPublicCertificateForAppRequest) ProtoMessage() {}--type PublicCertificate struct {- KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`- X509CertificatePem *string `protobuf:"bytes,2,opt,name=x509_certificate_pem" json:"x509_certificate_pem,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *PublicCertificate) Reset() { *m = PublicCertificate{} }-func (m *PublicCertificate) String() string { return proto.CompactTextString(m) }-func (*PublicCertificate) ProtoMessage() {}--func (m *PublicCertificate) GetKeyName() string {- if m != nil && m.KeyName != nil {- return *m.KeyName- }- return ""-}--func (m *PublicCertificate) GetX509CertificatePem() string {- if m != nil && m.X509CertificatePem != nil {- return *m.X509CertificatePem- }- return ""-}--type GetPublicCertificateForAppResponse struct {- PublicCertificateList []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list" json:"public_certificate_list,omitempty"`- MaxClientCacheTimeInSecond *int64 `protobuf:"varint,2,opt,name=max_client_cache_time_in_second" json:"max_client_cache_time_in_second,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetPublicCertificateForAppResponse) Reset() { *m = GetPublicCertificateForAppResponse{} }-func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) }-func (*GetPublicCertificateForAppResponse) ProtoMessage() {}--func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate {- if m != nil {- return m.PublicCertificateList- }- return nil-}--func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 {- if m != nil && m.MaxClientCacheTimeInSecond != nil {- return *m.MaxClientCacheTimeInSecond- }- return 0-}--type GetServiceAccountNameRequest struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *GetServiceAccountNameRequest) Reset() { *m = GetServiceAccountNameRequest{} }-func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) }-func (*GetServiceAccountNameRequest) ProtoMessage() {}--type GetServiceAccountNameResponse struct {- ServiceAccountName *string `protobuf:"bytes,1,opt,name=service_account_name" json:"service_account_name,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetServiceAccountNameResponse) Reset() { *m = GetServiceAccountNameResponse{} }-func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) }-func (*GetServiceAccountNameResponse) ProtoMessage() {}--func (m *GetServiceAccountNameResponse) GetServiceAccountName() string {- if m != nil && m.ServiceAccountName != nil {- return *m.ServiceAccountName- }- return ""-}--type GetAccessTokenRequest struct {- Scope []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"`- ServiceAccountId *int64 `protobuf:"varint,2,opt,name=service_account_id" json:"service_account_id,omitempty"`- ServiceAccountName *string `protobuf:"bytes,3,opt,name=service_account_name" json:"service_account_name,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetAccessTokenRequest) Reset() { *m = GetAccessTokenRequest{} }-func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) }-func (*GetAccessTokenRequest) ProtoMessage() {}--func (m *GetAccessTokenRequest) GetScope() []string {- if m != nil {- return m.Scope- }- return nil-}--func (m *GetAccessTokenRequest) GetServiceAccountId() int64 {- if m != nil && m.ServiceAccountId != nil {- return *m.ServiceAccountId- }- return 0-}--func (m *GetAccessTokenRequest) GetServiceAccountName() string {- if m != nil && m.ServiceAccountName != nil {- return *m.ServiceAccountName- }- return ""-}--type GetAccessTokenResponse struct {- AccessToken *string `protobuf:"bytes,1,opt,name=access_token" json:"access_token,omitempty"`- ExpirationTime *int64 `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetAccessTokenResponse) Reset() { *m = GetAccessTokenResponse{} }-func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) }-func (*GetAccessTokenResponse) ProtoMessage() {}--func (m *GetAccessTokenResponse) GetAccessToken() string {- if m != nil && m.AccessToken != nil {- return *m.AccessToken- }- return ""-}--func (m *GetAccessTokenResponse) GetExpirationTime() int64 {- if m != nil && m.ExpirationTime != nil {- return *m.ExpirationTime- }- return 0-}--type GetDefaultGcsBucketNameRequest struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *GetDefaultGcsBucketNameRequest) Reset() { *m = GetDefaultGcsBucketNameRequest{} }-func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) }-func (*GetDefaultGcsBucketNameRequest) ProtoMessage() {}--type GetDefaultGcsBucketNameResponse struct {- DefaultGcsBucketName *string `protobuf:"bytes,1,opt,name=default_gcs_bucket_name" json:"default_gcs_bucket_name,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetDefaultGcsBucketNameResponse) Reset() { *m = GetDefaultGcsBucketNameResponse{} }-func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) }-func (*GetDefaultGcsBucketNameResponse) ProtoMessage() {}--func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string {- if m != nil && m.DefaultGcsBucketName != nil {- return *m.DefaultGcsBucketName- }- return ""-}--func init() {-}diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.protodeleted file mode 100644index 19610ca5b..000000000--- a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto+++ /dev/null@@ -1,64 +0,0 @@-syntax = "proto2";-option go_package = "app_identity";--package appengine;--message AppIdentityServiceError {- enum ErrorCode {- SUCCESS = 0;- UNKNOWN_SCOPE = 9;- BLOB_TOO_LARGE = 1000;- DEADLINE_EXCEEDED = 1001;- NOT_A_VALID_APP = 1002;- UNKNOWN_ERROR = 1003;- NOT_ALLOWED = 1005;- NOT_IMPLEMENTED = 1006;- }-}--message SignForAppRequest {- optional bytes bytes_to_sign = 1;-}--message SignForAppResponse {- optional string key_name = 1;- optional bytes signature_bytes = 2;-}--message GetPublicCertificateForAppRequest {-}--message PublicCertificate {- optional string key_name = 1;- optional string x509_certificate_pem = 2;-}--message GetPublicCertificateForAppResponse {- repeated PublicCertificate public_certificate_list = 1;- optional int64 max_client_cache_time_in_second = 2;-}--message GetServiceAccountNameRequest {-}--message GetServiceAccountNameResponse {- optional string service_account_name = 1;-}--message GetAccessTokenRequest {- repeated string scope = 1;- optional int64 service_account_id = 2;- optional string service_account_name = 3;-}--message GetAccessTokenResponse {- optional string access_token = 1;- optional int64 expiration_time = 2;-}--message GetDefaultGcsBucketNameRequest {-}--message GetDefaultGcsBucketNameResponse {- optional string default_gcs_bucket_name = 1;-}diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.godeleted file mode 100644index a0145ed31..000000000--- a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go+++ /dev/null@@ -1,375 +0,0 @@-// Code generated by protoc-gen-go.-// source: google.golang.org/appengine/internal/modules/modules_service.proto-// DO NOT EDIT!--/*-Package modules is a generated protocol buffer package.--It is generated from these files:- google.golang.org/appengine/internal/modules/modules_service.proto--It has these top-level messages:- ModulesServiceError- GetModulesRequest- GetModulesResponse- GetVersionsRequest- GetVersionsResponse- GetDefaultVersionRequest- GetDefaultVersionResponse- GetNumInstancesRequest- GetNumInstancesResponse- SetNumInstancesRequest- SetNumInstancesResponse- StartModuleRequest- StartModuleResponse- StopModuleRequest- StopModuleResponse- GetHostnameRequest- GetHostnameResponse-*/-package modules--import proto "github.com/golang/protobuf/proto"-import fmt "fmt"-import math "math"--// Reference imports to suppress errors if they are not otherwise used.-var _ = proto.Marshal-var _ = fmt.Errorf-var _ = math.Inf--type ModulesServiceError_ErrorCode int32--const (- ModulesServiceError_OK ModulesServiceError_ErrorCode = 0- ModulesServiceError_INVALID_MODULE ModulesServiceError_ErrorCode = 1- ModulesServiceError_INVALID_VERSION ModulesServiceError_ErrorCode = 2- ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3- ModulesServiceError_TRANSIENT_ERROR ModulesServiceError_ErrorCode = 4- ModulesServiceError_UNEXPECTED_STATE ModulesServiceError_ErrorCode = 5-)--var ModulesServiceError_ErrorCode_name = map[int32]string{- 0: "OK",- 1: "INVALID_MODULE",- 2: "INVALID_VERSION",- 3: "INVALID_INSTANCES",- 4: "TRANSIENT_ERROR",- 5: "UNEXPECTED_STATE",-}-var ModulesServiceError_ErrorCode_value = map[string]int32{- "OK": 0,- "INVALID_MODULE": 1,- "INVALID_VERSION": 2,- "INVALID_INSTANCES": 3,- "TRANSIENT_ERROR": 4,- "UNEXPECTED_STATE": 5,-}--func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode {- p := new(ModulesServiceError_ErrorCode)- *p = x- return p-}-func (x ModulesServiceError_ErrorCode) String() string {- return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x))-}-func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {- value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode")- if err != nil {- return err- }- *x = ModulesServiceError_ErrorCode(value)- return nil-}--type ModulesServiceError struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *ModulesServiceError) Reset() { *m = ModulesServiceError{} }-func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) }-func (*ModulesServiceError) ProtoMessage() {}--type GetModulesRequest struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *GetModulesRequest) Reset() { *m = GetModulesRequest{} }-func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) }-func (*GetModulesRequest) ProtoMessage() {}--type GetModulesResponse struct {- Module []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetModulesResponse) Reset() { *m = GetModulesResponse{} }-func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) }-func (*GetModulesResponse) ProtoMessage() {}--func (m *GetModulesResponse) GetModule() []string {- if m != nil {- return m.Module- }- return nil-}--type GetVersionsRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetVersionsRequest) Reset() { *m = GetVersionsRequest{} }-func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) }-func (*GetVersionsRequest) ProtoMessage() {}--func (m *GetVersionsRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--type GetVersionsResponse struct {- Version []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetVersionsResponse) Reset() { *m = GetVersionsResponse{} }-func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) }-func (*GetVersionsResponse) ProtoMessage() {}--func (m *GetVersionsResponse) GetVersion() []string {- if m != nil {- return m.Version- }- return nil-}--type GetDefaultVersionRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetDefaultVersionRequest) Reset() { *m = GetDefaultVersionRequest{} }-func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }-func (*GetDefaultVersionRequest) ProtoMessage() {}--func (m *GetDefaultVersionRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--type GetDefaultVersionResponse struct {- Version *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetDefaultVersionResponse) Reset() { *m = GetDefaultVersionResponse{} }-func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) }-func (*GetDefaultVersionResponse) ProtoMessage() {}--func (m *GetDefaultVersionResponse) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--type GetNumInstancesRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetNumInstancesRequest) Reset() { *m = GetNumInstancesRequest{} }-func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) }-func (*GetNumInstancesRequest) ProtoMessage() {}--func (m *GetNumInstancesRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--func (m *GetNumInstancesRequest) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--type GetNumInstancesResponse struct {- Instances *int64 `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetNumInstancesResponse) Reset() { *m = GetNumInstancesResponse{} }-func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) }-func (*GetNumInstancesResponse) ProtoMessage() {}--func (m *GetNumInstancesResponse) GetInstances() int64 {- if m != nil && m.Instances != nil {- return *m.Instances- }- return 0-}--type SetNumInstancesRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`- Instances *int64 `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *SetNumInstancesRequest) Reset() { *m = SetNumInstancesRequest{} }-func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) }-func (*SetNumInstancesRequest) ProtoMessage() {}--func (m *SetNumInstancesRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--func (m *SetNumInstancesRequest) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--func (m *SetNumInstancesRequest) GetInstances() int64 {- if m != nil && m.Instances != nil {- return *m.Instances- }- return 0-}--type SetNumInstancesResponse struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *SetNumInstancesResponse) Reset() { *m = SetNumInstancesResponse{} }-func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) }-func (*SetNumInstancesResponse) ProtoMessage() {}--type StartModuleRequest struct {- Module *string `protobuf:"bytes,1,req,name=module" json:"module,omitempty"`- Version *string `protobuf:"bytes,2,req,name=version" json:"version,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *StartModuleRequest) Reset() { *m = StartModuleRequest{} }-func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) }-func (*StartModuleRequest) ProtoMessage() {}--func (m *StartModuleRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--func (m *StartModuleRequest) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--type StartModuleResponse struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *StartModuleResponse) Reset() { *m = StartModuleResponse{} }-func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) }-func (*StartModuleResponse) ProtoMessage() {}--type StopModuleRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *StopModuleRequest) Reset() { *m = StopModuleRequest{} }-func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) }-func (*StopModuleRequest) ProtoMessage() {}--func (m *StopModuleRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--func (m *StopModuleRequest) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--type StopModuleResponse struct {- XXX_unrecognized []byte `json:"-"`-}--func (m *StopModuleResponse) Reset() { *m = StopModuleResponse{} }-func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) }-func (*StopModuleResponse) ProtoMessage() {}--type GetHostnameRequest struct {- Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`- Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`- Instance *string `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetHostnameRequest) Reset() { *m = GetHostnameRequest{} }-func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) }-func (*GetHostnameRequest) ProtoMessage() {}--func (m *GetHostnameRequest) GetModule() string {- if m != nil && m.Module != nil {- return *m.Module- }- return ""-}--func (m *GetHostnameRequest) GetVersion() string {- if m != nil && m.Version != nil {- return *m.Version- }- return ""-}--func (m *GetHostnameRequest) GetInstance() string {- if m != nil && m.Instance != nil {- return *m.Instance- }- return ""-}--type GetHostnameResponse struct {- Hostname *string `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"`- XXX_unrecognized []byte `json:"-"`-}--func (m *GetHostnameResponse) Reset() { *m = GetHostnameResponse{} }-func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) }-func (*GetHostnameResponse) ProtoMessage() {}--func (m *GetHostnameResponse) GetHostname() string {- if m != nil && m.Hostname != nil {- return *m.Hostname- }- return ""-}--func init() {-}diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto b/vendor/google.golang.org/appengine/internal/modules/modules_service.protodeleted file mode 100644index d29f0065a..000000000--- a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto+++ /dev/null@@ -1,80 +0,0 @@-syntax = "proto2";-option go_package = "modules";--package appengine;--message ModulesServiceError {- enum ErrorCode {- OK = 0;- INVALID_MODULE = 1;- INVALID_VERSION = 2;- INVALID_INSTANCES = 3;- TRANSIENT_ERROR = 4;- UNEXPECTED_STATE = 5;- }-}--message GetModulesRequest {-}--message GetModulesResponse {- repeated string module = 1;-}--message GetVersionsRequest {- optional string module = 1;-}--message GetVersionsResponse {- repeated string version = 1;-}--message GetDefaultVersionRequest {- optional string module = 1;-}--message GetDefaultVersionResponse {- required string version = 1;-}--message GetNumInstancesRequest {- optional string module = 1;- optional string version = 2;-}--message GetNumInstancesResponse {- required int64 instances = 1;-}--message SetNumInstancesRequest {- optional string module = 1;- optional string version = 2;- required int64 instances = 3;-}--message SetNumInstancesResponse {}--message StartModuleRequest {- required string module = 1;- required string version = 2;-}--message StartModuleResponse {}--message StopModuleRequest {- optional string module = 1;- optional string version = 2;-}--message StopModuleResponse {}--message GetHostnameRequest {- optional string module = 1;- optional string version = 2;- optional string instance = 3;-}--message GetHostnameResponse {- required string hostname = 1;-}-diff --git a/vendor/google.golang.org/appengine/namespace.go b/vendor/google.golang.org/appengine/namespace.godeleted file mode 100644index 21860ca08..000000000--- a/vendor/google.golang.org/appengine/namespace.go+++ /dev/null@@ -1,25 +0,0 @@-// Copyright 2012 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--package appengine--import (- "fmt"- "regexp"-- "golang.org/x/net/context"-- "google.golang.org/appengine/internal"-)--// Namespace returns a replacement context that operates within the given namespace.-func Namespace(c context.Context, namespace string) (context.Context, error) {- if !validNamespace.MatchString(namespace) {- return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace)- }- return internal.NamespacedContext(c, namespace), nil-}--// validNamespace matches valid namespace names.-var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`)diff --git a/vendor/google.golang.org/appengine/timeout.go b/vendor/google.golang.org/appengine/timeout.godeleted file mode 100644index 05642a992..000000000--- a/vendor/google.golang.org/appengine/timeout.go+++ /dev/null@@ -1,20 +0,0 @@-// Copyright 2013 Google Inc. All rights reserved.-// Use of this source code is governed by the Apache 2.0-// license that can be found in the LICENSE file.--package appengine--import "golang.org/x/net/context"--// IsTimeoutError reports whether err is a timeout error.-func IsTimeoutError(err error) bool {- if err == context.DeadlineExceeded {- return true- }- if t, ok := err.(interface {- IsTimeout() bool- }); ok {- return t.IsTimeout()- }- return false-}