Update vendoring via vndr

gateway/glide.lock

@@ -1,95 +0,0 @@
-hash: 339150b194ecf3311e4cf3262b0cdb830f4d26065d91486108ae75c129d447a2
-updated: 2017-04-26T18:58:24.877329489+01:00
-imports:
-- name: github.com/beorn7/perks
-  version: 4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9
-  subpackages:
-  - quantile
-- name: github.com/docker/distribution
-  version: e85ef3c019a2809b3397771d385581ee09fc7649
-  subpackages:
-  - digestset
-  - reference
-- name: github.com/docker/docker
-  version: 4480e0417eb01caf29ae285880ec51a0180faf7f
-  subpackages:
-  - api
-  - api/types
-  - api/types/blkiodev
-  - api/types/container
-  - api/types/events
-  - api/types/filters
-  - api/types/image
-  - api/types/mount
-  - api/types/network
-  - api/types/registry
-  - api/types/strslice
-  - api/types/swarm
-  - api/types/time
-  - api/types/versions
-  - api/types/volume
-  - client
-  - pkg/ioutils
-  - pkg/longpath
-  - pkg/system
-  - pkg/tlsconfig
-- name: github.com/docker/go-connections
-  version: e15c02316c12de00874640cd76311849de2aeed5
-  subpackages:
-  - nat
-  - sockets
-  - tlsconfig
-- name: github.com/docker/go-units
-  version: 0dadbb0345b35ec7ef35e228dabb8de89a65bf52
-- name: github.com/docker/libtrust
-  version: aabc10ec26b754e797f9028f4589c5b7bd90dc20
-- name: github.com/golang/protobuf
-  version: 2bba0603135d7d7f5cb73b2125beeda19c09f4ef
-  subpackages:
-  - proto
-- name: github.com/gorilla/context
-  version: 08b5f424b9271eedf6f9f0ce86cb9396ed337a42
-- name: github.com/gorilla/mux
-  version: 599cba5e7b6137d46ddf58fb1765f5d928e69604
-- name: github.com/matttproud/golang_protobuf_extensions
-  version: c12348ce28de40eed0136aa2b644d0ee0650e56c
-  subpackages:
-  - pbutil
-- name: github.com/Microsoft/go-winio
-  version: f3b1913901892ada21d52d0cffe1d4c7080d36b7
-- name: github.com/opencontainers/go-digest
-  version: aa2ec055abd10d26d539eb630a92241b781ce4bc
-- name: github.com/pkg/errors
-  version: ff09b135c25aae272398c51a07235b90a75aa4f0
-- name: github.com/prometheus/client_golang
-  version: 7d9484283ebefa862b5b7727d4344cfdf9a0d138
-  subpackages:
-  - prometheus
-- name: github.com/prometheus/client_model
-  version: 6f3806018612930941127f2a7c6c453ba2c527d2
-  subpackages:
-  - go
-- name: github.com/prometheus/common
-  version: 9e0844febd9e2856f839c9cb974fbd676d1755a8
-  subpackages:
-  - expfmt
-  - internal/bitbucket.org/ww/goautoneg
-  - model
-- name: github.com/prometheus/procfs
-  version: 6ac8c5d890d415025dd5aae7595bcb2a6e7e2fad
-  subpackages:
-  - xfs
-- name: github.com/Sirupsen/logrus
-  version: 10f801ebc38b33738c9d17d50860f484a0988ff5
-- name: golang.org/x/net
-  version: da118f7b8e5954f39d0d2130ab35d4bf0e3cb344
-  subpackages:
-  - context
-  - context/ctxhttp
-  - proxy
-- name: golang.org/x/sys
-  version: 9f30dcbe5be197894515a338a9bda9253567ea8f
-  subpackages:
-  - unix
-  - windows
-testImports: []

gateway/glide.yaml

@@ -1,16 +0,0 @@
-package: github.com/alexellis/faas/gateway
-import:
-- package: github.com/Sirupsen/logrus
-- package: github.com/docker/docker
-  subpackages:
-  - api/types
-  - api/types/filters
-  - api/types/swarm
-  - client
-- package: github.com/gorilla/mux
-- package: github.com/prometheus/client_golang
-  subpackages:
-  - prometheus
-- package: github.com/prometheus/client_model
-  subpackages:
-  - go

gateway/vendor.conf

@@ -0,0 +1,25 @@
+github.com/docker/docker 89658bed64c2a8fe05a978e5b87dbec409d57a0f
+github.com/gogo/protobuf dda3e8acadcc9affc16faf33fbb229db78399245
+github.com/opencontainers/image-spec 9e2ed30b411505b510b4ab080c4035d71bd56b44
+github.com/opencontainers/go-digest 279bed98673dd5bef374d3b6e4b09e2af76183bf
+github.com/gorilla/mux ac112f7d75a0714af1bd86ab17749b31f7809640
+github.com/prometheus/client_golang 26b897001974f2b4ee6688377873e4d6f61d533c
+github.com/prometheus/client_model 6f3806018612930941127f2a7c6c453ba2c527d2
+github.com/golang/protobuf 0a4f71a498b7c4812f64969510bcb4eca251e33a
+github.com/beorn7/perks 4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9
+github.com/prometheus/common 3e6a7635bac6573d43f49f97b47eb9bda195dba8
+github.com/prometheus/procfs e645f4e5aaa8506fc71d6edbc5c4ff02c04c46f2
+github.com/matttproud/golang_protobuf_extensions c12348ce28de40eed0136aa2b644d0ee0650e56c
+github.com/gorilla/context 08b5f424b9271eedf6f9f0ce86cb9396ed337a42
+github.com/docker/distribution f86db6b22663a27ba4d278220b7e34be528b1e79
+github.com/spf13/pflag e57e3eeb33f795204c1ca35f56c44f83227c6e66
+github.com/Nvveen/Gotty cd527374f1e5bff4938207604a14f2e38a9cf512
+github.com/Azure/go-ansiterm 19f72df4d05d31cbe1c56bfc8045c96babff6c7e
+golang.org/x/sys abf9c25f54453410d0c6668e519582a9e1115027
+github.com/Sirupsen/logrus 10f801ebc38b33738c9d17d50860f484a0988ff5
+github.com/docker/libtrust aabc10ec26b754e797f9028f4589c5b7bd90dc20
+github.com/Microsoft/go-winio c4dc1301f1dc0307acd38e611aa375a64dfe0642
+github.com/docker/go-connections 3ede32e2033de7505e6500d6c868c2b9ed9f169d
+github.com/docker/go-units 0dadbb0345b35ec7ef35e228dabb8de89a65bf52
+github.com/pkg/errors c605e284fe17294bda444b34710735b29d1a9d90
+

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

@@ -7,3 +7,6 @@ For example the parser might receive "ESC, [, A" as a stream of three characters
 The parser (parser.go) is a partial implementation of this state machine (http://vt100.net/emu/vt500_parser.png).  There are also two event handler implementations, one for tests (test_event_handler.go) to validate that the expected events are being produced and called, the other is a Windows implementation (winterm/win_event_handler.go).
 
 See parser_test.go for examples exercising the state machine and generating appropriate function calls.
+
+-----
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

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

@@ -5,7 +5,7 @@ import (
 	"io/ioutil"
 	"os"
 
-	"github.com/Sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 )
 
 var logger *logrus.Logger

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

@@ -9,7 +9,7 @@ import (
 	"strconv"
 
 	"github.com/Azure/go-ansiterm"
-	"github.com/Sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 )
 
 var logger *logrus.Logger

gateway/vendor/github.com/Microsoft/go-winio/.gitignore

@@ -1 +0,0 @@
-*.exe

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/LICENSE

@@ -1,27 +0,0 @@
-Copyright (c) 2012 The Go Authors. All rights reserved.
-
-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.

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/common.go

@@ -1,344 +0,0 @@
-// Copyright 2009 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 tar implements access to tar archives.
-// It aims to cover most of the variations, including those produced
-// by GNU and BSD tars.
-//
-// References:
-//   http://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5
-//   http://www.gnu.org/software/tar/manual/html_node/Standard.html
-//   http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html
-package tar
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"os"
-	"path"
-	"time"
-)
-
-const (
-	blockSize = 512
-
-	// Types
-	TypeReg           = '0'    // regular file
-	TypeRegA          = '\x00' // regular file
-	TypeLink          = '1'    // hard link
-	TypeSymlink       = '2'    // symbolic link
-	TypeChar          = '3'    // character device node
-	TypeBlock         = '4'    // block device node
-	TypeDir           = '5'    // directory
-	TypeFifo          = '6'    // fifo node
-	TypeCont          = '7'    // reserved
-	TypeXHeader       = 'x'    // extended header
-	TypeXGlobalHeader = 'g'    // global extended header
-	TypeGNULongName   = 'L'    // Next file has a long name
-	TypeGNULongLink   = 'K'    // Next file symlinks to a file w/ a long name
-	TypeGNUSparse     = 'S'    // sparse file
-)
-
-// A Header represents a single header in a tar archive.
-// Some fields may not be populated.
-type Header struct {
-	Name         string    // name of header file entry
-	Mode         int64     // permission and mode bits
-	Uid          int       // user id of owner
-	Gid          int       // group id of owner
-	Size         int64     // length in bytes
-	ModTime      time.Time // modified time
-	Typeflag     byte      // type of header entry
-	Linkname     string    // target name of link
-	Uname        string    // user name of owner
-	Gname        string    // group name of owner
-	Devmajor     int64     // major number of character or block device
-	Devminor     int64     // minor number of character or block device
-	AccessTime   time.Time // access time
-	ChangeTime   time.Time // status change time
-	CreationTime time.Time // creation time
-	Xattrs       map[string]string
-	Winheaders   map[string]string
-}
-
-// File name constants from the tar spec.
-const (
-	fileNameSize       = 100 // Maximum number of bytes in a standard tar name.
-	fileNamePrefixSize = 155 // Maximum number of ustar extension bytes.
-)
-
-// FileInfo returns an os.FileInfo for the Header.
-func (h *Header) FileInfo() os.FileInfo {
-	return headerFileInfo{h}
-}
-
-// headerFileInfo implements os.FileInfo.
-type headerFileInfo struct {
-	h *Header
-}
-
-func (fi headerFileInfo) Size() int64        { return fi.h.Size }
-func (fi headerFileInfo) IsDir() bool        { return fi.Mode().IsDir() }
-func (fi headerFileInfo) ModTime() time.Time { return fi.h.ModTime }
-func (fi headerFileInfo) Sys() interface{}   { return fi.h }
-
-// Name returns the base name of the file.
-func (fi headerFileInfo) Name() string {
-	if fi.IsDir() {
-		return path.Base(path.Clean(fi.h.Name))
-	}
-	return path.Base(fi.h.Name)
-}
-
-// Mode returns the permission and mode bits for the headerFileInfo.
-func (fi headerFileInfo) Mode() (mode os.FileMode) {
-	// Set file permission bits.
-	mode = os.FileMode(fi.h.Mode).Perm()
-
-	// Set setuid, setgid and sticky bits.
-	if fi.h.Mode&c_ISUID != 0 {
-		// setuid
-		mode |= os.ModeSetuid
-	}
-	if fi.h.Mode&c_ISGID != 0 {
-		// setgid
-		mode |= os.ModeSetgid
-	}
-	if fi.h.Mode&c_ISVTX != 0 {
-		// sticky
-		mode |= os.ModeSticky
-	}
-
-	// Set file mode bits.
-	// clear perm, setuid, setgid and sticky bits.
-	m := os.FileMode(fi.h.Mode) &^ 07777
-	if m == c_ISDIR {
-		// directory
-		mode |= os.ModeDir
-	}
-	if m == c_ISFIFO {
-		// named pipe (FIFO)
-		mode |= os.ModeNamedPipe
-	}
-	if m == c_ISLNK {
-		// symbolic link
-		mode |= os.ModeSymlink
-	}
-	if m == c_ISBLK {
-		// device file
-		mode |= os.ModeDevice
-	}
-	if m == c_ISCHR {
-		// Unix character device
-		mode |= os.ModeDevice
-		mode |= os.ModeCharDevice
-	}
-	if m == c_ISSOCK {
-		// Unix domain socket
-		mode |= os.ModeSocket
-	}
-
-	switch fi.h.Typeflag {
-	case TypeSymlink:
-		// symbolic link
-		mode |= os.ModeSymlink
-	case TypeChar:
-		// character device node
-		mode |= os.ModeDevice
-		mode |= os.ModeCharDevice
-	case TypeBlock:
-		// block device node
-		mode |= os.ModeDevice
-	case TypeDir:
-		// directory
-		mode |= os.ModeDir
-	case TypeFifo:
-		// fifo node
-		mode |= os.ModeNamedPipe
-	}
-
-	return mode
-}
-
-// sysStat, if non-nil, populates h from system-dependent fields of fi.
-var sysStat func(fi os.FileInfo, h *Header) error
-
-// Mode constants from the tar spec.
-const (
-	c_ISUID  = 04000   // Set uid
-	c_ISGID  = 02000   // Set gid
-	c_ISVTX  = 01000   // Save text (sticky bit)
-	c_ISDIR  = 040000  // Directory
-	c_ISFIFO = 010000  // FIFO
-	c_ISREG  = 0100000 // Regular file
-	c_ISLNK  = 0120000 // Symbolic link
-	c_ISBLK  = 060000  // Block special file
-	c_ISCHR  = 020000  // Character special file
-	c_ISSOCK = 0140000 // Socket
-)
-
-// Keywords for the PAX Extended Header
-const (
-	paxAtime        = "atime"
-	paxCharset      = "charset"
-	paxComment      = "comment"
-	paxCtime        = "ctime" // please note that ctime is not a valid pax header.
-	paxCreationTime = "LIBARCHIVE.creationtime"
-	paxGid          = "gid"
-	paxGname        = "gname"
-	paxLinkpath     = "linkpath"
-	paxMtime        = "mtime"
-	paxPath         = "path"
-	paxSize         = "size"
-	paxUid          = "uid"
-	paxUname        = "uname"
-	paxXattr        = "SCHILY.xattr."
-	paxWindows      = "MSWINDOWS."
-	paxNone         = ""
-)
-
-// FileInfoHeader creates a partially-populated Header from fi.
-// If fi describes a symlink, FileInfoHeader records link as the link target.
-// If fi describes a directory, a slash is appended to the name.
-// Because os.FileInfo's Name method returns only the base name of
-// the file it describes, it may be necessary to modify the Name field
-// of the returned header to provide the full path name of the file.
-func FileInfoHeader(fi os.FileInfo, link string) (*Header, error) {
-	if fi == nil {
-		return nil, errors.New("tar: FileInfo is nil")
-	}
-	fm := fi.Mode()
-	h := &Header{
-		Name:    fi.Name(),
-		ModTime: fi.ModTime(),
-		Mode:    int64(fm.Perm()), // or'd with c_IS* constants later
-	}
-	switch {
-	case fm.IsRegular():
-		h.Mode |= c_ISREG
-		h.Typeflag = TypeReg
-		h.Size = fi.Size()
-	case fi.IsDir():
-		h.Typeflag = TypeDir
-		h.Mode |= c_ISDIR
-		h.Name += "/"
-	case fm&os.ModeSymlink != 0:
-		h.Typeflag = TypeSymlink
-		h.Mode |= c_ISLNK
-		h.Linkname = link
-	case fm&os.ModeDevice != 0:
-		if fm&os.ModeCharDevice != 0 {
-			h.Mode |= c_ISCHR
-			h.Typeflag = TypeChar
-		} else {
-			h.Mode |= c_ISBLK
-			h.Typeflag = TypeBlock
-		}
-	case fm&os.ModeNamedPipe != 0:
-		h.Typeflag = TypeFifo
-		h.Mode |= c_ISFIFO
-	case fm&os.ModeSocket != 0:
-		h.Mode |= c_ISSOCK
-	default:
-		return nil, fmt.Errorf("archive/tar: unknown file mode %v", fm)
-	}
-	if fm&os.ModeSetuid != 0 {
-		h.Mode |= c_ISUID
-	}
-	if fm&os.ModeSetgid != 0 {
-		h.Mode |= c_ISGID
-	}
-	if fm&os.ModeSticky != 0 {
-		h.Mode |= c_ISVTX
-	}
-	// If possible, populate additional fields from OS-specific
-	// FileInfo fields.
-	if sys, ok := fi.Sys().(*Header); ok {
-		// This FileInfo came from a Header (not the OS). Use the
-		// original Header to populate all remaining fields.
-		h.Uid = sys.Uid
-		h.Gid = sys.Gid
-		h.Uname = sys.Uname
-		h.Gname = sys.Gname
-		h.AccessTime = sys.AccessTime
-		h.ChangeTime = sys.ChangeTime
-		if sys.Xattrs != nil {
-			h.Xattrs = make(map[string]string)
-			for k, v := range sys.Xattrs {
-				h.Xattrs[k] = v
-			}
-		}
-		if sys.Typeflag == TypeLink {
-			// hard link
-			h.Typeflag = TypeLink
-			h.Size = 0
-			h.Linkname = sys.Linkname
-		}
-	}
-	if sysStat != nil {
-		return h, sysStat(fi, h)
-	}
-	return h, nil
-}
-
-var zeroBlock = make([]byte, blockSize)
-
-// POSIX specifies a sum of the unsigned byte values, but the Sun tar uses signed byte values.
-// We compute and return both.
-func checksum(header []byte) (unsigned int64, signed int64) {
-	for i := 0; i < len(header); i++ {
-		if i == 148 {
-			// The chksum field (header[148:156]) is special: it should be treated as space bytes.
-			unsigned += ' ' * 8
-			signed += ' ' * 8
-			i += 7
-			continue
-		}
-		unsigned += int64(header[i])
-		signed += int64(int8(header[i]))
-	}
-	return
-}
-
-type slicer []byte
-
-func (sp *slicer) next(n int) (b []byte) {
-	s := *sp
-	b, *sp = s[0:n], s[n:]
-	return
-}
-
-func isASCII(s string) bool {
-	for _, c := range s {
-		if c >= 0x80 {
-			return false
-		}
-	}
-	return true
-}
-
-func toASCII(s string) string {
-	if isASCII(s) {
-		return s
-	}
-	var buf bytes.Buffer
-	for _, c := range s {
-		if c < 0x80 {
-			buf.WriteByte(byte(c))
-		}
-	}
-	return buf.String()
-}
-
-// isHeaderOnlyType checks if the given type flag is of the type that has no
-// data section even if a size is specified.
-func isHeaderOnlyType(flag byte) bool {
-	switch flag {
-	case TypeLink, TypeSymlink, TypeChar, TypeBlock, TypeDir, TypeFifo:
-		return true
-	default:
-		return false
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/example_test.go

@@ -1,80 +0,0 @@
-// Copyright 2013 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 tar_test
-
-import (
-	"archive/tar"
-	"bytes"
-	"fmt"
-	"io"
-	"log"
-	"os"
-)
-
-func Example() {
-	// Create a buffer to write our archive to.
-	buf := new(bytes.Buffer)
-
-	// Create a new tar archive.
-	tw := tar.NewWriter(buf)
-
-	// Add some files to the archive.
-	var files = []struct {
-		Name, Body string
-	}{
-		{"readme.txt", "This archive contains some text files."},
-		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
-		{"todo.txt", "Get animal handling license."},
-	}
-	for _, file := range files {
-		hdr := &tar.Header{
-			Name: file.Name,
-			Mode: 0600,
-			Size: int64(len(file.Body)),
-		}
-		if err := tw.WriteHeader(hdr); err != nil {
-			log.Fatalln(err)
-		}
-		if _, err := tw.Write([]byte(file.Body)); err != nil {
-			log.Fatalln(err)
-		}
-	}
-	// Make sure to check the error on Close.
-	if err := tw.Close(); err != nil {
-		log.Fatalln(err)
-	}
-
-	// Open the tar archive for reading.
-	r := bytes.NewReader(buf.Bytes())
-	tr := tar.NewReader(r)
-
-	// Iterate through the files in the archive.
-	for {
-		hdr, err := tr.Next()
-		if err == io.EOF {
-			// end of tar archive
-			break
-		}
-		if err != nil {
-			log.Fatalln(err)
-		}
-		fmt.Printf("Contents of %s:\n", hdr.Name)
-		if _, err := io.Copy(os.Stdout, tr); err != nil {
-			log.Fatalln(err)
-		}
-		fmt.Println()
-	}
-
-	// Output:
-	// Contents of readme.txt:
-	// This archive contains some text files.
-	// Contents of gopher.txt:
-	// Gopher names:
-	// George
-	// Geoffrey
-	// Gonzo
-	// Contents of todo.txt:
-	// Get animal handling license.
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/stat_atim.go

@@ -1,20 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux dragonfly openbsd solaris
-
-package tar
-
-import (
-	"syscall"
-	"time"
-)
-
-func statAtime(st *syscall.Stat_t) time.Time {
-	return time.Unix(st.Atim.Unix())
-}
-
-func statCtime(st *syscall.Stat_t) time.Time {
-	return time.Unix(st.Ctim.Unix())
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/stat_atimespec.go

@@ -1,20 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin freebsd netbsd
-
-package tar
-
-import (
-	"syscall"
-	"time"
-)
-
-func statAtime(st *syscall.Stat_t) time.Time {
-	return time.Unix(st.Atimespec.Unix())
-}
-
-func statCtime(st *syscall.Stat_t) time.Time {
-	return time.Unix(st.Ctimespec.Unix())
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/stat_unix.go

@@ -1,32 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux darwin dragonfly freebsd openbsd netbsd solaris
-
-package tar
-
-import (
-	"os"
-	"syscall"
-)
-
-func init() {
-	sysStat = statUnix
-}
-
-func statUnix(fi os.FileInfo, h *Header) error {
-	sys, ok := fi.Sys().(*syscall.Stat_t)
-	if !ok {
-		return nil
-	}
-	h.Uid = int(sys.Uid)
-	h.Gid = int(sys.Gid)
-	// TODO(bradfitz): populate username & group.  os/user
-	// doesn't cache LookupId lookups, and lacks group
-	// lookup functions.
-	h.AccessTime = statAtime(sys)
-	h.ChangeTime = statCtime(sys)
-	// TODO(bradfitz): major/minor device numbers?
-	return nil
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/tar_test.go

@@ -1,325 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package tar
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"path"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestFileInfoHeader(t *testing.T) {
-	fi, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	h, err := FileInfoHeader(fi, "")
-	if err != nil {
-		t.Fatalf("FileInfoHeader: %v", err)
-	}
-	if g, e := h.Name, "small.txt"; g != e {
-		t.Errorf("Name = %q; want %q", g, e)
-	}
-	if g, e := h.Mode, int64(fi.Mode().Perm())|c_ISREG; g != e {
-		t.Errorf("Mode = %#o; want %#o", g, e)
-	}
-	if g, e := h.Size, int64(5); g != e {
-		t.Errorf("Size = %v; want %v", g, e)
-	}
-	if g, e := h.ModTime, fi.ModTime(); !g.Equal(e) {
-		t.Errorf("ModTime = %v; want %v", g, e)
-	}
-	// FileInfoHeader should error when passing nil FileInfo
-	if _, err := FileInfoHeader(nil, ""); err == nil {
-		t.Fatalf("Expected error when passing nil to FileInfoHeader")
-	}
-}
-
-func TestFileInfoHeaderDir(t *testing.T) {
-	fi, err := os.Stat("testdata")
-	if err != nil {
-		t.Fatal(err)
-	}
-	h, err := FileInfoHeader(fi, "")
-	if err != nil {
-		t.Fatalf("FileInfoHeader: %v", err)
-	}
-	if g, e := h.Name, "testdata/"; g != e {
-		t.Errorf("Name = %q; want %q", g, e)
-	}
-	// Ignoring c_ISGID for golang.org/issue/4867
-	if g, e := h.Mode&^c_ISGID, int64(fi.Mode().Perm())|c_ISDIR; g != e {
-		t.Errorf("Mode = %#o; want %#o", g, e)
-	}
-	if g, e := h.Size, int64(0); g != e {
-		t.Errorf("Size = %v; want %v", g, e)
-	}
-	if g, e := h.ModTime, fi.ModTime(); !g.Equal(e) {
-		t.Errorf("ModTime = %v; want %v", g, e)
-	}
-}
-
-func TestFileInfoHeaderSymlink(t *testing.T) {
-	h, err := FileInfoHeader(symlink{}, "some-target")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if g, e := h.Name, "some-symlink"; g != e {
-		t.Errorf("Name = %q; want %q", g, e)
-	}
-	if g, e := h.Linkname, "some-target"; g != e {
-		t.Errorf("Linkname = %q; want %q", g, e)
-	}
-}
-
-type symlink struct{}
-
-func (symlink) Name() string       { return "some-symlink" }
-func (symlink) Size() int64        { return 0 }
-func (symlink) Mode() os.FileMode  { return os.ModeSymlink }
-func (symlink) ModTime() time.Time { return time.Time{} }
-func (symlink) IsDir() bool        { return false }
-func (symlink) Sys() interface{}   { return nil }
-
-func TestRoundTrip(t *testing.T) {
-	data := []byte("some file contents")
-
-	var b bytes.Buffer
-	tw := NewWriter(&b)
-	hdr := &Header{
-		Name:    "file.txt",
-		Uid:     1 << 21, // too big for 8 octal digits
-		Size:    int64(len(data)),
-		ModTime: time.Now(),
-	}
-	// tar only supports second precision.
-	hdr.ModTime = hdr.ModTime.Add(-time.Duration(hdr.ModTime.Nanosecond()) * time.Nanosecond)
-	if err := tw.WriteHeader(hdr); err != nil {
-		t.Fatalf("tw.WriteHeader: %v", err)
-	}
-	if _, err := tw.Write(data); err != nil {
-		t.Fatalf("tw.Write: %v", err)
-	}
-	if err := tw.Close(); err != nil {
-		t.Fatalf("tw.Close: %v", err)
-	}
-
-	// Read it back.
-	tr := NewReader(&b)
-	rHdr, err := tr.Next()
-	if err != nil {
-		t.Fatalf("tr.Next: %v", err)
-	}
-	if !reflect.DeepEqual(rHdr, hdr) {
-		t.Errorf("Header mismatch.\n got %+v\nwant %+v", rHdr, hdr)
-	}
-	rData, err := ioutil.ReadAll(tr)
-	if err != nil {
-		t.Fatalf("Read: %v", err)
-	}
-	if !bytes.Equal(rData, data) {
-		t.Errorf("Data mismatch.\n got %q\nwant %q", rData, data)
-	}
-}
-
-type headerRoundTripTest struct {
-	h  *Header
-	fm os.FileMode
-}
-
-func TestHeaderRoundTrip(t *testing.T) {
-	golden := []headerRoundTripTest{
-		// regular file.
-		{
-			h: &Header{
-				Name:     "test.txt",
-				Mode:     0644 | c_ISREG,
-				Size:     12,
-				ModTime:  time.Unix(1360600916, 0),
-				Typeflag: TypeReg,
-			},
-			fm: 0644,
-		},
-		// symbolic link.
-		{
-			h: &Header{
-				Name:     "link.txt",
-				Mode:     0777 | c_ISLNK,
-				Size:     0,
-				ModTime:  time.Unix(1360600852, 0),
-				Typeflag: TypeSymlink,
-			},
-			fm: 0777 | os.ModeSymlink,
-		},
-		// character device node.
-		{
-			h: &Header{
-				Name:     "dev/null",
-				Mode:     0666 | c_ISCHR,
-				Size:     0,
-				ModTime:  time.Unix(1360578951, 0),
-				Typeflag: TypeChar,
-			},
-			fm: 0666 | os.ModeDevice | os.ModeCharDevice,
-		},
-		// block device node.
-		{
-			h: &Header{
-				Name:     "dev/sda",
-				Mode:     0660 | c_ISBLK,
-				Size:     0,
-				ModTime:  time.Unix(1360578954, 0),
-				Typeflag: TypeBlock,
-			},
-			fm: 0660 | os.ModeDevice,
-		},
-		// directory.
-		{
-			h: &Header{
-				Name:     "dir/",
-				Mode:     0755 | c_ISDIR,
-				Size:     0,
-				ModTime:  time.Unix(1360601116, 0),
-				Typeflag: TypeDir,
-			},
-			fm: 0755 | os.ModeDir,
-		},
-		// fifo node.
-		{
-			h: &Header{
-				Name:     "dev/initctl",
-				Mode:     0600 | c_ISFIFO,
-				Size:     0,
-				ModTime:  time.Unix(1360578949, 0),
-				Typeflag: TypeFifo,
-			},
-			fm: 0600 | os.ModeNamedPipe,
-		},
-		// setuid.
-		{
-			h: &Header{
-				Name:     "bin/su",
-				Mode:     0755 | c_ISREG | c_ISUID,
-				Size:     23232,
-				ModTime:  time.Unix(1355405093, 0),
-				Typeflag: TypeReg,
-			},
-			fm: 0755 | os.ModeSetuid,
-		},
-		// setguid.
-		{
-			h: &Header{
-				Name:     "group.txt",
-				Mode:     0750 | c_ISREG | c_ISGID,
-				Size:     0,
-				ModTime:  time.Unix(1360602346, 0),
-				Typeflag: TypeReg,
-			},
-			fm: 0750 | os.ModeSetgid,
-		},
-		// sticky.
-		{
-			h: &Header{
-				Name:     "sticky.txt",
-				Mode:     0600 | c_ISREG | c_ISVTX,
-				Size:     7,
-				ModTime:  time.Unix(1360602540, 0),
-				Typeflag: TypeReg,
-			},
-			fm: 0600 | os.ModeSticky,
-		},
-		// hard link.
-		{
-			h: &Header{
-				Name:     "hard.txt",
-				Mode:     0644 | c_ISREG,
-				Size:     0,
-				Linkname: "file.txt",
-				ModTime:  time.Unix(1360600916, 0),
-				Typeflag: TypeLink,
-			},
-			fm: 0644,
-		},
-		// More information.
-		{
-			h: &Header{
-				Name:     "info.txt",
-				Mode:     0600 | c_ISREG,
-				Size:     0,
-				Uid:      1000,
-				Gid:      1000,
-				ModTime:  time.Unix(1360602540, 0),
-				Uname:    "slartibartfast",
-				Gname:    "users",
-				Typeflag: TypeReg,
-			},
-			fm: 0600,
-		},
-	}
-
-	for i, g := range golden {
-		fi := g.h.FileInfo()
-		h2, err := FileInfoHeader(fi, "")
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-		if strings.Contains(fi.Name(), "/") {
-			t.Errorf("FileInfo of %q contains slash: %q", g.h.Name, fi.Name())
-		}
-		name := path.Base(g.h.Name)
-		if fi.IsDir() {
-			name += "/"
-		}
-		if got, want := h2.Name, name; got != want {
-			t.Errorf("i=%d: Name: got %v, want %v", i, got, want)
-		}
-		if got, want := h2.Size, g.h.Size; got != want {
-			t.Errorf("i=%d: Size: got %v, want %v", i, got, want)
-		}
-		if got, want := h2.Uid, g.h.Uid; got != want {
-			t.Errorf("i=%d: Uid: got %d, want %d", i, got, want)
-		}
-		if got, want := h2.Gid, g.h.Gid; got != want {
-			t.Errorf("i=%d: Gid: got %d, want %d", i, got, want)
-		}
-		if got, want := h2.Uname, g.h.Uname; got != want {
-			t.Errorf("i=%d: Uname: got %q, want %q", i, got, want)
-		}
-		if got, want := h2.Gname, g.h.Gname; got != want {
-			t.Errorf("i=%d: Gname: got %q, want %q", i, got, want)
-		}
-		if got, want := h2.Linkname, g.h.Linkname; got != want {
-			t.Errorf("i=%d: Linkname: got %v, want %v", i, got, want)
-		}
-		if got, want := h2.Typeflag, g.h.Typeflag; got != want {
-			t.Logf("%#v %#v", g.h, fi.Sys())
-			t.Errorf("i=%d: Typeflag: got %q, want %q", i, got, want)
-		}
-		if got, want := h2.Mode, g.h.Mode; got != want {
-			t.Errorf("i=%d: Mode: got %o, want %o", i, got, want)
-		}
-		if got, want := fi.Mode(), g.fm; got != want {
-			t.Errorf("i=%d: fi.Mode: got %o, want %o", i, got, want)
-		}
-		if got, want := h2.AccessTime, g.h.AccessTime; got != want {
-			t.Errorf("i=%d: AccessTime: got %v, want %v", i, got, want)
-		}
-		if got, want := h2.ChangeTime, g.h.ChangeTime; got != want {
-			t.Errorf("i=%d: ChangeTime: got %v, want %v", i, got, want)
-		}
-		if got, want := h2.ModTime, g.h.ModTime; got != want {
-			t.Errorf("i=%d: ModTime: got %v, want %v", i, got, want)
-		}
-		if sysh, ok := fi.Sys().(*Header); !ok || sysh != g.h {
-			t.Errorf("i=%d: Sys didn't return original *Header", i)
-		}
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/testdata/small.txt

@@ -1 +0,0 @@
-Kilts

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/testdata/small2.txt

@@ -1 +0,0 @@
-Google.com

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/writer.go

@@ -1,444 +0,0 @@
-// Copyright 2009 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 tar
-
-// TODO(dsymonds):
-// - catch more errors (no first header, etc.)
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"path"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var (
-	ErrWriteTooLong    = errors.New("archive/tar: write too long")
-	ErrFieldTooLong    = errors.New("archive/tar: header field too long")
-	ErrWriteAfterClose = errors.New("archive/tar: write after close")
-	errInvalidHeader   = errors.New("archive/tar: header field too long or contains invalid values")
-)
-
-// A Writer provides sequential writing of a tar archive in POSIX.1 format.
-// A tar archive consists of a sequence of files.
-// Call WriteHeader to begin a new file, and then call Write to supply that file's data,
-// writing at most hdr.Size bytes in total.
-type Writer struct {
-	w          io.Writer
-	err        error
-	nb         int64 // number of unwritten bytes for current file entry
-	pad        int64 // amount of padding to write after current file entry
-	closed     bool
-	usedBinary bool            // whether the binary numeric field extension was used
-	preferPax  bool            // use pax header instead of binary numeric header
-	hdrBuff    [blockSize]byte // buffer to use in writeHeader when writing a regular header
-	paxHdrBuff [blockSize]byte // buffer to use in writeHeader when writing a pax header
-}
-
-type formatter struct {
-	err error // Last error seen
-}
-
-// NewWriter creates a new Writer writing to w.
-func NewWriter(w io.Writer) *Writer { return &Writer{w: w, preferPax: true} }
-
-// Flush finishes writing the current file (optional).
-func (tw *Writer) Flush() error {
-	if tw.nb > 0 {
-		tw.err = fmt.Errorf("archive/tar: missed writing %d bytes", tw.nb)
-		return tw.err
-	}
-
-	n := tw.nb + tw.pad
-	for n > 0 && tw.err == nil {
-		nr := n
-		if nr > blockSize {
-			nr = blockSize
-		}
-		var nw int
-		nw, tw.err = tw.w.Write(zeroBlock[0:nr])
-		n -= int64(nw)
-	}
-	tw.nb = 0
-	tw.pad = 0
-	return tw.err
-}
-
-// Write s into b, terminating it with a NUL if there is room.
-func (f *formatter) formatString(b []byte, s string) {
-	if len(s) > len(b) {
-		f.err = ErrFieldTooLong
-		return
-	}
-	ascii := toASCII(s)
-	copy(b, ascii)
-	if len(ascii) < len(b) {
-		b[len(ascii)] = 0
-	}
-}
-
-// Encode x as an octal ASCII string and write it into b with leading zeros.
-func (f *formatter) formatOctal(b []byte, x int64) {
-	s := strconv.FormatInt(x, 8)
-	// leading zeros, but leave room for a NUL.
-	for len(s)+1 < len(b) {
-		s = "0" + s
-	}
-	f.formatString(b, s)
-}
-
-// fitsInBase256 reports whether x can be encoded into n bytes using base-256
-// encoding. Unlike octal encoding, base-256 encoding does not require that the
-// string ends with a NUL character. Thus, all n bytes are available for output.
-//
-// If operating in binary mode, this assumes strict GNU binary mode; which means
-// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
-// equivalent to the sign bit in two's complement form.
-func fitsInBase256(n int, x int64) bool {
-	var binBits = uint(n-1) * 8
-	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
-}
-
-// Write x into b, as binary (GNUtar/star extension).
-func (f *formatter) formatNumeric(b []byte, x int64) {
-	if fitsInBase256(len(b), x) {
-		for i := len(b) - 1; i >= 0; i-- {
-			b[i] = byte(x)
-			x >>= 8
-		}
-		b[0] |= 0x80 // Highest bit indicates binary format
-		return
-	}
-
-	f.formatOctal(b, 0) // Last resort, just write zero
-	f.err = ErrFieldTooLong
-}
-
-var (
-	minTime = time.Unix(0, 0)
-	// There is room for 11 octal digits (33 bits) of mtime.
-	maxTime = minTime.Add((1<<33 - 1) * time.Second)
-)
-
-// WriteHeader writes hdr and prepares to accept the file's contents.
-// WriteHeader calls Flush if it is not the first header.
-// Calling after a Close will return ErrWriteAfterClose.
-func (tw *Writer) WriteHeader(hdr *Header) error {
-	return tw.writeHeader(hdr, true)
-}
-
-// WriteHeader writes hdr and prepares to accept the file's contents.
-// WriteHeader calls Flush if it is not the first header.
-// Calling after a Close will return ErrWriteAfterClose.
-// As this method is called internally by writePax header to allow it to
-// suppress writing the pax header.
-func (tw *Writer) writeHeader(hdr *Header, allowPax bool) error {
-	if tw.closed {
-		return ErrWriteAfterClose
-	}
-	if tw.err == nil {
-		tw.Flush()
-	}
-	if tw.err != nil {
-		return tw.err
-	}
-
-	// a map to hold pax header records, if any are needed
-	paxHeaders := make(map[string]string)
-
-	// TODO(shanemhansen): we might want to use PAX headers for
-	// subsecond time resolution, but for now let's just capture
-	// too long fields or non ascii characters
-
-	var f formatter
-	var header []byte
-
-	// We need to select which scratch buffer to use carefully,
-	// since this method is called recursively to write PAX headers.
-	// If allowPax is true, this is the non-recursive call, and we will use hdrBuff.
-	// If allowPax is false, we are being called by writePAXHeader, and hdrBuff is
-	// already being used by the non-recursive call, so we must use paxHdrBuff.
-	header = tw.hdrBuff[:]
-	if !allowPax {
-		header = tw.paxHdrBuff[:]
-	}
-	copy(header, zeroBlock)
-	s := slicer(header)
-
-	// Wrappers around formatter that automatically sets paxHeaders if the
-	// argument extends beyond the capacity of the input byte slice.
-	var formatString = func(b []byte, s string, paxKeyword string) {
-		needsPaxHeader := paxKeyword != paxNone && len(s) > len(b) || !isASCII(s)
-		if needsPaxHeader {
-			paxHeaders[paxKeyword] = s
-			return
-		}
-		f.formatString(b, s)
-	}
-	var formatNumeric = func(b []byte, x int64, paxKeyword string) {
-		// Try octal first.
-		s := strconv.FormatInt(x, 8)
-		if len(s) < len(b) {
-			f.formatOctal(b, x)
-			return
-		}
-
-		// If it is too long for octal, and PAX is preferred, use a PAX header.
-		if paxKeyword != paxNone && tw.preferPax {
-			f.formatOctal(b, 0)
-			s := strconv.FormatInt(x, 10)
-			paxHeaders[paxKeyword] = s
-			return
-		}
-
-		tw.usedBinary = true
-		f.formatNumeric(b, x)
-	}
-	var formatTime = func(b []byte, t time.Time, paxKeyword string) {
-		var unixTime int64
-		if !t.Before(minTime) && !t.After(maxTime) {
-			unixTime = t.Unix()
-		}
-		formatNumeric(b, unixTime, paxNone)
-
-		// Write a PAX header if the time didn't fit precisely.
-		if paxKeyword != "" && tw.preferPax && allowPax && (t.Nanosecond() != 0 || !t.Before(minTime) || !t.After(maxTime)) {
-			paxHeaders[paxKeyword] = formatPAXTime(t)
-		}
-	}
-
-	// keep a reference to the filename to allow to overwrite it later if we detect that we can use ustar longnames instead of pax
-	pathHeaderBytes := s.next(fileNameSize)
-
-	formatString(pathHeaderBytes, hdr.Name, paxPath)
-
-	f.formatOctal(s.next(8), hdr.Mode)               // 100:108
-	formatNumeric(s.next(8), int64(hdr.Uid), paxUid) // 108:116
-	formatNumeric(s.next(8), int64(hdr.Gid), paxGid) // 116:124
-	formatNumeric(s.next(12), hdr.Size, paxSize)     // 124:136
-	formatTime(s.next(12), hdr.ModTime, paxMtime)    // 136:148
-	s.next(8)                                        // chksum (148:156)
-	s.next(1)[0] = hdr.Typeflag                      // 156:157
-
-	formatString(s.next(100), hdr.Linkname, paxLinkpath)
-
-	copy(s.next(8), []byte("ustar\x0000"))          // 257:265
-	formatString(s.next(32), hdr.Uname, paxUname)   // 265:297
-	formatString(s.next(32), hdr.Gname, paxGname)   // 297:329
-	formatNumeric(s.next(8), hdr.Devmajor, paxNone) // 329:337
-	formatNumeric(s.next(8), hdr.Devminor, paxNone) // 337:345
-
-	// keep a reference to the prefix to allow to overwrite it later if we detect that we can use ustar longnames instead of pax
-	prefixHeaderBytes := s.next(155)
-	formatString(prefixHeaderBytes, "", paxNone) // 345:500  prefix
-
-	// Use the GNU magic instead of POSIX magic if we used any GNU extensions.
-	if tw.usedBinary {
-		copy(header[257:265], []byte("ustar  \x00"))
-	}
-
-	_, paxPathUsed := paxHeaders[paxPath]
-	// try to use a ustar header when only the name is too long
-	if !tw.preferPax && len(paxHeaders) == 1 && paxPathUsed {
-		prefix, suffix, ok := splitUSTARPath(hdr.Name)
-		if ok {
-			// Since we can encode in USTAR format, disable PAX header.
-			delete(paxHeaders, paxPath)
-
-			// Update the path fields
-			formatString(pathHeaderBytes, suffix, paxNone)
-			formatString(prefixHeaderBytes, prefix, paxNone)
-		}
-	}
-
-	// The chksum field is terminated by a NUL and a space.
-	// This is different from the other octal fields.
-	chksum, _ := checksum(header)
-	f.formatOctal(header[148:155], chksum) // Never fails
-	header[155] = ' '
-
-	// Check if there were any formatting errors.
-	if f.err != nil {
-		tw.err = f.err
-		return tw.err
-	}
-
-	if allowPax {
-		if !hdr.AccessTime.IsZero() {
-			paxHeaders[paxAtime] = formatPAXTime(hdr.AccessTime)
-		}
-		if !hdr.ChangeTime.IsZero() {
-			paxHeaders[paxCtime] = formatPAXTime(hdr.ChangeTime)
-		}
-		if !hdr.CreationTime.IsZero() {
-			paxHeaders[paxCreationTime] = formatPAXTime(hdr.CreationTime)
-		}
-		for k, v := range hdr.Xattrs {
-			paxHeaders[paxXattr+k] = v
-		}
-		for k, v := range hdr.Winheaders {
-			paxHeaders[paxWindows+k] = v
-		}
-	}
-
-	if len(paxHeaders) > 0 {
-		if !allowPax {
-			return errInvalidHeader
-		}
-		if err := tw.writePAXHeader(hdr, paxHeaders); err != nil {
-			return err
-		}
-	}
-	tw.nb = int64(hdr.Size)
-	tw.pad = (blockSize - (tw.nb % blockSize)) % blockSize
-
-	_, tw.err = tw.w.Write(header)
-	return tw.err
-}
-
-func formatPAXTime(t time.Time) string {
-	sec := t.Unix()
-	usec := t.Nanosecond()
-	s := strconv.FormatInt(sec, 10)
-	if usec != 0 {
-		s = fmt.Sprintf("%s.%09d", s, usec)
-	}
-	return s
-}
-
-// splitUSTARPath splits a path according to USTAR prefix and suffix rules.
-// If the path is not splittable, then it will return ("", "", false).
-func splitUSTARPath(name string) (prefix, suffix string, ok bool) {
-	length := len(name)
-	if length <= fileNameSize || !isASCII(name) {
-		return "", "", false
-	} else if length > fileNamePrefixSize+1 {
-		length = fileNamePrefixSize + 1
-	} else if name[length-1] == '/' {
-		length--
-	}
-
-	i := strings.LastIndex(name[:length], "/")
-	nlen := len(name) - i - 1 // nlen is length of suffix
-	plen := i                 // plen is length of prefix
-	if i <= 0 || nlen > fileNameSize || nlen == 0 || plen > fileNamePrefixSize {
-		return "", "", false
-	}
-	return name[:i], name[i+1:], true
-}
-
-// writePaxHeader writes an extended pax header to the
-// archive.
-func (tw *Writer) writePAXHeader(hdr *Header, paxHeaders map[string]string) error {
-	// Prepare extended header
-	ext := new(Header)
-	ext.Typeflag = TypeXHeader
-	// Setting ModTime is required for reader parsing to
-	// succeed, and seems harmless enough.
-	ext.ModTime = hdr.ModTime
-	// The spec asks that we namespace our pseudo files
-	// with the current pid.  However, this results in differing outputs
-	// for identical inputs.  As such, the constant 0 is now used instead.
-	// golang.org/issue/12358
-	dir, file := path.Split(hdr.Name)
-	fullName := path.Join(dir, "PaxHeaders.0", file)
-
-	ascii := toASCII(fullName)
-	if len(ascii) > 100 {
-		ascii = ascii[:100]
-	}
-	ext.Name = ascii
-	// Construct the body
-	var buf bytes.Buffer
-
-	// Keys are sorted before writing to body to allow deterministic output.
-	var keys []string
-	for k := range paxHeaders {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	for _, k := range keys {
-		fmt.Fprint(&buf, formatPAXRecord(k, paxHeaders[k]))
-	}
-
-	ext.Size = int64(len(buf.Bytes()))
-	if err := tw.writeHeader(ext, false); err != nil {
-		return err
-	}
-	if _, err := tw.Write(buf.Bytes()); err != nil {
-		return err
-	}
-	if err := tw.Flush(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// formatPAXRecord formats a single PAX record, prefixing it with the
-// appropriate length.
-func formatPAXRecord(k, v string) string {
-	const padding = 3 // Extra padding for ' ', '=', and '\n'
-	size := len(k) + len(v) + padding
-	size += len(strconv.Itoa(size))
-	record := fmt.Sprintf("%d %s=%s\n", size, k, v)
-
-	// Final adjustment if adding size field increased the record size.
-	if len(record) != size {
-		size = len(record)
-		record = fmt.Sprintf("%d %s=%s\n", size, k, v)
-	}
-	return record
-}
-
-// Write writes to the current entry in the tar archive.
-// Write returns the error ErrWriteTooLong if more than
-// hdr.Size bytes are written after WriteHeader.
-func (tw *Writer) Write(b []byte) (n int, err error) {
-	if tw.closed {
-		err = ErrWriteAfterClose
-		return
-	}
-	overwrite := false
-	if int64(len(b)) > tw.nb {
-		b = b[0:tw.nb]
-		overwrite = true
-	}
-	n, err = tw.w.Write(b)
-	tw.nb -= int64(n)
-	if err == nil && overwrite {
-		err = ErrWriteTooLong
-		return
-	}
-	tw.err = err
-	return
-}
-
-// Close closes the tar archive, flushing any unwritten
-// data to the underlying writer.
-func (tw *Writer) Close() error {
-	if tw.err != nil || tw.closed {
-		return tw.err
-	}
-	tw.Flush()
-	tw.closed = true
-	if tw.err != nil {
-		return tw.err
-	}
-
-	// trailer: two zero blocks
-	for i := 0; i < 2; i++ {
-		_, tw.err = tw.w.Write(zeroBlock)
-		if tw.err != nil {
-			break
-		}
-	}
-	return tw.err
-}

gateway/vendor/github.com/Microsoft/go-winio/archive/tar/writer_test.go

@@ -1,739 +0,0 @@
-// Copyright 2009 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 tar
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math"
-	"os"
-	"reflect"
-	"sort"
-	"strings"
-	"testing"
-	"testing/iotest"
-	"time"
-)
-
-type writerTestEntry struct {
-	header   *Header
-	contents string
-}
-
-type writerTest struct {
-	file    string // filename of expected output
-	entries []*writerTestEntry
-}
-
-var writerTests = []*writerTest{
-	// The writer test file was produced with this command:
-	// tar (GNU tar) 1.26
-	//   ln -s small.txt link.txt
-	//   tar -b 1 --format=ustar -c -f writer.tar small.txt small2.txt link.txt
-	{
-		file: "testdata/writer.tar",
-		entries: []*writerTestEntry{
-			{
-				header: &Header{
-					Name:     "small.txt",
-					Mode:     0640,
-					Uid:      73025,
-					Gid:      5000,
-					Size:     5,
-					ModTime:  time.Unix(1246508266, 0),
-					Typeflag: '0',
-					Uname:    "dsymonds",
-					Gname:    "eng",
-				},
-				contents: "Kilts",
-			},
-			{
-				header: &Header{
-					Name:     "small2.txt",
-					Mode:     0640,
-					Uid:      73025,
-					Gid:      5000,
-					Size:     11,
-					ModTime:  time.Unix(1245217492, 0),
-					Typeflag: '0',
-					Uname:    "dsymonds",
-					Gname:    "eng",
-				},
-				contents: "Google.com\n",
-			},
-			{
-				header: &Header{
-					Name:     "link.txt",
-					Mode:     0777,
-					Uid:      1000,
-					Gid:      1000,
-					Size:     0,
-					ModTime:  time.Unix(1314603082, 0),
-					Typeflag: '2',
-					Linkname: "small.txt",
-					Uname:    "strings",
-					Gname:    "strings",
-				},
-				// no contents
-			},
-		},
-	},
-	// The truncated test file was produced using these commands:
-	//   dd if=/dev/zero bs=1048576 count=16384 > /tmp/16gig.txt
-	//   tar -b 1 -c -f- /tmp/16gig.txt | dd bs=512 count=8 > writer-big.tar
-	{
-		file: "testdata/writer-big.tar",
-		entries: []*writerTestEntry{
-			{
-				header: &Header{
-					Name:     "tmp/16gig.txt",
-					Mode:     0640,
-					Uid:      73025,
-					Gid:      5000,
-					Size:     16 << 30,
-					ModTime:  time.Unix(1254699560, 0),
-					Typeflag: '0',
-					Uname:    "dsymonds",
-					Gname:    "eng",
-				},
-				// fake contents
-				contents: strings.Repeat("\x00", 4<<10),
-			},
-		},
-	},
-	// The truncated test file was produced using these commands:
-	//   dd if=/dev/zero bs=1048576 count=16384 > (longname/)*15 /16gig.txt
-	//   tar -b 1 -c -f- (longname/)*15 /16gig.txt | dd bs=512 count=8 > writer-big-long.tar
-	{
-		file: "testdata/writer-big-long.tar",
-		entries: []*writerTestEntry{
-			{
-				header: &Header{
-					Name:     strings.Repeat("longname/", 15) + "16gig.txt",
-					Mode:     0644,
-					Uid:      1000,
-					Gid:      1000,
-					Size:     16 << 30,
-					ModTime:  time.Unix(1399583047, 0),
-					Typeflag: '0',
-					Uname:    "guillaume",
-					Gname:    "guillaume",
-				},
-				// fake contents
-				contents: strings.Repeat("\x00", 4<<10),
-			},
-		},
-	},
-	// This file was produced using gnu tar 1.17
-	// gnutar  -b 4 --format=ustar (longname/)*15 + file.txt
-	{
-		file: "testdata/ustar.tar",
-		entries: []*writerTestEntry{
-			{
-				header: &Header{
-					Name:     strings.Repeat("longname/", 15) + "file.txt",
-					Mode:     0644,
-					Uid:      0765,
-					Gid:      024,
-					Size:     06,
-					ModTime:  time.Unix(1360135598, 0),
-					Typeflag: '0',
-					Uname:    "shane",
-					Gname:    "staff",
-				},
-				contents: "hello\n",
-			},
-		},
-	},
-	// This file was produced using gnu tar 1.26
-	// echo "Slartibartfast" > file.txt
-	// ln file.txt hard.txt
-	// tar -b 1 --format=ustar -c -f hardlink.tar file.txt hard.txt
-	{
-		file: "testdata/hardlink.tar",
-		entries: []*writerTestEntry{
-			{
-				header: &Header{
-					Name:     "file.txt",
-					Mode:     0644,
-					Uid:      1000,
-					Gid:      100,
-					Size:     15,
-					ModTime:  time.Unix(1425484303, 0),
-					Typeflag: '0',
-					Uname:    "vbatts",
-					Gname:    "users",
-				},
-				contents: "Slartibartfast\n",
-			},
-			{
-				header: &Header{
-					Name:     "hard.txt",
-					Mode:     0644,
-					Uid:      1000,
-					Gid:      100,
-					Size:     0,
-					ModTime:  time.Unix(1425484303, 0),
-					Typeflag: '1',
-					Linkname: "file.txt",
-					Uname:    "vbatts",
-					Gname:    "users",
-				},
-				// no contents
-			},
-		},
-	},
-}
-
-// Render byte array in a two-character hexadecimal string, spaced for easy visual inspection.
-func bytestr(offset int, b []byte) string {
-	const rowLen = 32
-	s := fmt.Sprintf("%04x ", offset)
-	for _, ch := range b {
-		switch {
-		case '0' <= ch && ch <= '9', 'A' <= ch && ch <= 'Z', 'a' <= ch && ch <= 'z':
-			s += fmt.Sprintf("  %c", ch)
-		default:
-			s += fmt.Sprintf(" %02x", ch)
-		}
-	}
-	return s
-}
-
-// Render a pseudo-diff between two blocks of bytes.
-func bytediff(a []byte, b []byte) string {
-	const rowLen = 32
-	s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b))
-	for offset := 0; len(a)+len(b) > 0; offset += rowLen {
-		na, nb := rowLen, rowLen
-		if na > len(a) {
-			na = len(a)
-		}
-		if nb > len(b) {
-			nb = len(b)
-		}
-		sa := bytestr(offset, a[0:na])
-		sb := bytestr(offset, b[0:nb])
-		if sa != sb {
-			s += fmt.Sprintf("-%v\n+%v\n", sa, sb)
-		}
-		a = a[na:]
-		b = b[nb:]
-	}
-	return s
-}
-
-func TestWriter(t *testing.T) {
-testLoop:
-	for i, test := range writerTests {
-		expected, err := ioutil.ReadFile(test.file)
-		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err)
-			continue
-		}
-
-		buf := new(bytes.Buffer)
-		tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)) // only catch the first 4 KB
-		big := false
-		for j, entry := range test.entries {
-			big = big || entry.header.Size > 1<<10
-			if err := tw.WriteHeader(entry.header); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err)
-				continue testLoop
-			}
-			if _, err := io.WriteString(tw, entry.contents); err != nil {
-				t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err)
-				continue testLoop
-			}
-		}
-		// Only interested in Close failures for the small tests.
-		if err := tw.Close(); err != nil && !big {
-			t.Errorf("test %d: Failed closing archive: %v", i, err)
-			continue testLoop
-		}
-
-		actual := buf.Bytes()
-		if !bytes.Equal(expected, actual) {
-			t.Errorf("test %d: Incorrect result: (-=expected, +=actual)\n%v",
-				i, bytediff(expected, actual))
-		}
-		if testing.Short() { // The second test is expensive.
-			break
-		}
-	}
-}
-
-func TestPax(t *testing.T) {
-	// Create an archive with a large name
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	hdr, err := FileInfoHeader(fileinfo, "")
-	if err != nil {
-		t.Fatalf("os.Stat: %v", err)
-	}
-	// Force a PAX long name to be written
-	longName := strings.Repeat("ab", 100)
-	contents := strings.Repeat(" ", int(hdr.Size))
-	hdr.Name = longName
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if _, err = writer.Write([]byte(contents)); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Simple test to make sure PAX extensions are in effect
-	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
-		t.Fatal("Expected at least one PAX header to be written.")
-	}
-	// Test that we can get a long name back out of the archive.
-	reader := NewReader(&buf)
-	hdr, err = reader.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hdr.Name != longName {
-		t.Fatal("Couldn't recover long file name")
-	}
-}
-
-func TestPaxSymlink(t *testing.T) {
-	// Create an archive with a large linkname
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	hdr, err := FileInfoHeader(fileinfo, "")
-	hdr.Typeflag = TypeSymlink
-	if err != nil {
-		t.Fatalf("os.Stat:1 %v", err)
-	}
-	// Force a PAX long linkname to be written
-	longLinkname := strings.Repeat("1234567890/1234567890", 10)
-	hdr.Linkname = longLinkname
-
-	hdr.Size = 0
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Simple test to make sure PAX extensions are in effect
-	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
-		t.Fatal("Expected at least one PAX header to be written.")
-	}
-	// Test that we can get a long name back out of the archive.
-	reader := NewReader(&buf)
-	hdr, err = reader.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hdr.Linkname != longLinkname {
-		t.Fatal("Couldn't recover long link name")
-	}
-}
-
-func TestPaxNonAscii(t *testing.T) {
-	// Create an archive with non ascii. These should trigger a pax header
-	// because pax headers have a defined utf-8 encoding.
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	hdr, err := FileInfoHeader(fileinfo, "")
-	if err != nil {
-		t.Fatalf("os.Stat:1 %v", err)
-	}
-
-	// some sample data
-	chineseFilename := "文件名"
-	chineseGroupname := "組"
-	chineseUsername := "用戶名"
-
-	hdr.Name = chineseFilename
-	hdr.Gname = chineseGroupname
-	hdr.Uname = chineseUsername
-
-	contents := strings.Repeat(" ", int(hdr.Size))
-
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if _, err = writer.Write([]byte(contents)); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Simple test to make sure PAX extensions are in effect
-	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
-		t.Fatal("Expected at least one PAX header to be written.")
-	}
-	// Test that we can get a long name back out of the archive.
-	reader := NewReader(&buf)
-	hdr, err = reader.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hdr.Name != chineseFilename {
-		t.Fatal("Couldn't recover unicode name")
-	}
-	if hdr.Gname != chineseGroupname {
-		t.Fatal("Couldn't recover unicode group")
-	}
-	if hdr.Uname != chineseUsername {
-		t.Fatal("Couldn't recover unicode user")
-	}
-}
-
-func TestPaxXattrs(t *testing.T) {
-	xattrs := map[string]string{
-		"user.key": "value",
-	}
-
-	// Create an archive with an xattr
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	hdr, err := FileInfoHeader(fileinfo, "")
-	if err != nil {
-		t.Fatalf("os.Stat: %v", err)
-	}
-	contents := "Kilts"
-	hdr.Xattrs = xattrs
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if _, err = writer.Write([]byte(contents)); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Test that we can get the xattrs back out of the archive.
-	reader := NewReader(&buf)
-	hdr, err = reader.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(hdr.Xattrs, xattrs) {
-		t.Fatalf("xattrs did not survive round trip: got %+v, want %+v",
-			hdr.Xattrs, xattrs)
-	}
-}
-
-func TestPaxHeadersSorted(t *testing.T) {
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	hdr, err := FileInfoHeader(fileinfo, "")
-	if err != nil {
-		t.Fatalf("os.Stat: %v", err)
-	}
-	contents := strings.Repeat(" ", int(hdr.Size))
-
-	hdr.Xattrs = map[string]string{
-		"foo": "foo",
-		"bar": "bar",
-		"baz": "baz",
-		"qux": "qux",
-	}
-
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if _, err = writer.Write([]byte(contents)); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Simple test to make sure PAX extensions are in effect
-	if !bytes.Contains(buf.Bytes(), []byte("PaxHeaders.0")) {
-		t.Fatal("Expected at least one PAX header to be written.")
-	}
-
-	// xattr bar should always appear before others
-	indices := []int{
-		bytes.Index(buf.Bytes(), []byte("bar=bar")),
-		bytes.Index(buf.Bytes(), []byte("baz=baz")),
-		bytes.Index(buf.Bytes(), []byte("foo=foo")),
-		bytes.Index(buf.Bytes(), []byte("qux=qux")),
-	}
-	if !sort.IntsAreSorted(indices) {
-		t.Fatal("PAX headers are not sorted")
-	}
-}
-
-func TestUSTARLongName(t *testing.T) {
-	// Create an archive with a path that failed to split with USTAR extension in previous versions.
-	fileinfo, err := os.Stat("testdata/small.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	hdr, err := FileInfoHeader(fileinfo, "")
-	hdr.Typeflag = TypeDir
-	if err != nil {
-		t.Fatalf("os.Stat:1 %v", err)
-	}
-	// Force a PAX long name to be written. The name was taken from a practical example
-	// that fails and replaced ever char through numbers to anonymize the sample.
-	longName := "/0000_0000000/00000-000000000/0000_0000000/00000-0000000000000/0000_0000000/00000-0000000-00000000/0000_0000000/00000000/0000_0000000/000/0000_0000000/00000000v00/0000_0000000/000000/0000_0000000/0000000/0000_0000000/00000y-00/0000/0000/00000000/0x000000/"
-	hdr.Name = longName
-
-	hdr.Size = 0
-	var buf bytes.Buffer
-	writer := NewWriter(&buf)
-	if err := writer.WriteHeader(hdr); err != nil {
-		t.Fatal(err)
-	}
-	if err := writer.Close(); err != nil {
-		t.Fatal(err)
-	}
-	// Test that we can get a long name back out of the archive.
-	reader := NewReader(&buf)
-	hdr, err = reader.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if hdr.Name != longName {
-		t.Fatal("Couldn't recover long name")
-	}
-}
-
-func TestValidTypeflagWithPAXHeader(t *testing.T) {
-	var buffer bytes.Buffer
-	tw := NewWriter(&buffer)
-
-	fileName := strings.Repeat("ab", 100)
-
-	hdr := &Header{
-		Name:     fileName,
-		Size:     4,
-		Typeflag: 0,
-	}
-	if err := tw.WriteHeader(hdr); err != nil {
-		t.Fatalf("Failed to write header: %s", err)
-	}
-	if _, err := tw.Write([]byte("fooo")); err != nil {
-		t.Fatalf("Failed to write the file's data: %s", err)
-	}
-	tw.Close()
-
-	tr := NewReader(&buffer)
-
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Failed to read header: %s", err)
-		}
-		if header.Typeflag != 0 {
-			t.Fatalf("Typeflag should've been 0, found %d", header.Typeflag)
-		}
-	}
-}
-
-func TestWriteAfterClose(t *testing.T) {
-	var buffer bytes.Buffer
-	tw := NewWriter(&buffer)
-
-	hdr := &Header{
-		Name: "small.txt",
-		Size: 5,
-	}
-	if err := tw.WriteHeader(hdr); err != nil {
-		t.Fatalf("Failed to write header: %s", err)
-	}
-	tw.Close()
-	if _, err := tw.Write([]byte("Kilts")); err != ErrWriteAfterClose {
-		t.Fatalf("Write: got %v; want ErrWriteAfterClose", err)
-	}
-}
-
-func TestSplitUSTARPath(t *testing.T) {
-	var sr = strings.Repeat
-
-	var vectors = []struct {
-		input  string // Input path
-		prefix string // Expected output prefix
-		suffix string // Expected output suffix
-		ok     bool   // Split success?
-	}{
-		{"", "", "", false},
-		{"abc", "", "", false},
-		{"用戶名", "", "", false},
-		{sr("a", fileNameSize), "", "", false},
-		{sr("a", fileNameSize) + "/", "", "", false},
-		{sr("a", fileNameSize) + "/a", sr("a", fileNameSize), "a", true},
-		{sr("a", fileNamePrefixSize) + "/", "", "", false},
-		{sr("a", fileNamePrefixSize) + "/a", sr("a", fileNamePrefixSize), "a", true},
-		{sr("a", fileNameSize+1), "", "", false},
-		{sr("/", fileNameSize+1), sr("/", fileNameSize-1), "/", true},
-		{sr("a", fileNamePrefixSize) + "/" + sr("b", fileNameSize),
-			sr("a", fileNamePrefixSize), sr("b", fileNameSize), true},
-		{sr("a", fileNamePrefixSize) + "//" + sr("b", fileNameSize), "", "", false},
-		{sr("a/", fileNameSize), sr("a/", 77) + "a", sr("a/", 22), true},
-	}
-
-	for _, v := range vectors {
-		prefix, suffix, ok := splitUSTARPath(v.input)
-		if prefix != v.prefix || suffix != v.suffix || ok != v.ok {
-			t.Errorf("splitUSTARPath(%q):\ngot  (%q, %q, %v)\nwant (%q, %q, %v)",
-				v.input, prefix, suffix, ok, v.prefix, v.suffix, v.ok)
-		}
-	}
-}
-
-func TestFormatPAXRecord(t *testing.T) {
-	var medName = strings.Repeat("CD", 50)
-	var longName = strings.Repeat("AB", 100)
-
-	var vectors = []struct {
-		inputKey string
-		inputVal string
-		output   string
-	}{
-		{"k", "v", "6 k=v\n"},
-		{"path", "/etc/hosts", "19 path=/etc/hosts\n"},
-		{"path", longName, "210 path=" + longName + "\n"},
-		{"path", medName, "110 path=" + medName + "\n"},
-		{"foo", "ba", "9 foo=ba\n"},
-		{"foo", "bar", "11 foo=bar\n"},
-		{"foo", "b=\nar=\n==\x00", "18 foo=b=\nar=\n==\x00\n"},
-		{"foo", "hello9 foo=ba\nworld", "27 foo=hello9 foo=ba\nworld\n"},
-		{"☺☻☹", "日a本b語ç", "27 ☺☻☹=日a本b語ç\n"},
-		{"\x00hello", "\x00world", "17 \x00hello=\x00world\n"},
-	}
-
-	for _, v := range vectors {
-		output := formatPAXRecord(v.inputKey, v.inputVal)
-		if output != v.output {
-			t.Errorf("formatPAXRecord(%q, %q): got %q, want %q",
-				v.inputKey, v.inputVal, output, v.output)
-		}
-	}
-}
-
-func TestFitsInBase256(t *testing.T) {
-	var vectors = []struct {
-		input int64
-		width int
-		ok    bool
-	}{
-		{+1, 8, true},
-		{0, 8, true},
-		{-1, 8, true},
-		{1 << 56, 8, false},
-		{(1 << 56) - 1, 8, true},
-		{-1 << 56, 8, true},
-		{(-1 << 56) - 1, 8, false},
-		{121654, 8, true},
-		{-9849849, 8, true},
-		{math.MaxInt64, 9, true},
-		{0, 9, true},
-		{math.MinInt64, 9, true},
-		{math.MaxInt64, 12, true},
-		{0, 12, true},
-		{math.MinInt64, 12, true},
-	}
-
-	for _, v := range vectors {
-		ok := fitsInBase256(v.width, v.input)
-		if ok != v.ok {
-			t.Errorf("checkNumeric(%d, %d): got %v, want %v", v.input, v.width, ok, v.ok)
-		}
-	}
-}
-
-func TestFormatNumeric(t *testing.T) {
-	var vectors = []struct {
-		input  int64
-		output string
-		ok     bool
-	}{
-		// Test base-256 (binary) encoded values.
-		{-1, "\xff", true},
-		{-1, "\xff\xff", true},
-		{-1, "\xff\xff\xff", true},
-		{(1 << 0), "0", false},
-		{(1 << 8) - 1, "\x80\xff", true},
-		{(1 << 8), "0\x00", false},
-		{(1 << 16) - 1, "\x80\xff\xff", true},
-		{(1 << 16), "00\x00", false},
-		{-1 * (1 << 0), "\xff", true},
-		{-1*(1<<0) - 1, "0", false},
-		{-1 * (1 << 8), "\xff\x00", true},
-		{-1*(1<<8) - 1, "0\x00", false},
-		{-1 * (1 << 16), "\xff\x00\x00", true},
-		{-1*(1<<16) - 1, "00\x00", false},
-		{537795476381659745, "0000000\x00", false},
-		{537795476381659745, "\x80\x00\x00\x00\x07\x76\xa2\x22\xeb\x8a\x72\x61", true},
-		{-615126028225187231, "0000000\x00", false},
-		{-615126028225187231, "\xff\xff\xff\xff\xf7\x76\xa2\x22\xeb\x8a\x72\x61", true},
-		{math.MaxInt64, "0000000\x00", false},
-		{math.MaxInt64, "\x80\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff", true},
-		{math.MinInt64, "0000000\x00", false},
-		{math.MinInt64, "\xff\xff\xff\xff\x80\x00\x00\x00\x00\x00\x00\x00", true},
-		{math.MaxInt64, "\x80\x7f\xff\xff\xff\xff\xff\xff\xff", true},
-		{math.MinInt64, "\xff\x80\x00\x00\x00\x00\x00\x00\x00", true},
-	}
-
-	for _, v := range vectors {
-		var f formatter
-		output := make([]byte, len(v.output))
-		f.formatNumeric(output, v.input)
-		ok := (f.err == nil)
-		if ok != v.ok {
-			if v.ok {
-				t.Errorf("formatNumeric(%d): got formatting failure, want success", v.input)
-			} else {
-				t.Errorf("formatNumeric(%d): got formatting success, want failure", v.input)
-			}
-		}
-		if string(output) != v.output {
-			t.Errorf("formatNumeric(%d): got %q, want %q", v.input, output, v.output)
-		}
-	}
-}
-
-func TestFormatPAXTime(t *testing.T) {
-	t1 := time.Date(2000, 1, 1, 11, 0, 0, 0, time.UTC)
-	t2 := time.Date(2000, 1, 1, 11, 0, 0, 100, time.UTC)
-	t3 := time.Date(1960, 1, 1, 11, 0, 0, 0, time.UTC)
-	t4 := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
-	verify := func(time time.Time, s string) {
-		p := formatPAXTime(time)
-		if p != s {
-			t.Errorf("for %v, expected %s, got %s", time, s, p)
-		}
-	}
-	verify(t1, "946724400")
-	verify(t2, "946724400.000000100")
-	verify(t3, "-315579600")
-	verify(t4, "0")
-}

gateway/vendor/github.com/Microsoft/go-winio/backup.go

@@ -185,7 +185,6 @@ type BackupFileReader struct {
 // Read will attempt to read the security descriptor of the file.
 func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
 	r := &BackupFileReader{f, includeSecurity, 0}
-	runtime.SetFinalizer(r, func(r *BackupFileReader) { r.Close() })
 	return r
 }
 
@@ -196,6 +195,7 @@ func (r *BackupFileReader) Read(b []byte) (int, error) {
 	if err != nil {
 		return 0, &os.PathError{"BackupRead", r.f.Name(), err}
 	}
+	runtime.KeepAlive(r.f)
 	if bytesRead == 0 {
 		return 0, io.EOF
 	}
@@ -207,6 +207,7 @@ func (r *BackupFileReader) Read(b []byte) (int, error) {
 func (r *BackupFileReader) Close() error {
 	if r.ctx != 0 {
 		backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
+		runtime.KeepAlive(r.f)
 		r.ctx = 0
 	}
 	return nil
@@ -223,7 +224,6 @@ type BackupFileWriter struct {
 // Write() will attempt to restore the security descriptor from the stream.
 func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
 	w := &BackupFileWriter{f, includeSecurity, 0}
-	runtime.SetFinalizer(w, func(w *BackupFileWriter) { w.Close() })
 	return w
 }
 
@@ -234,6 +234,7 @@ func (w *BackupFileWriter) Write(b []byte) (int, error) {
 	if err != nil {
 		return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
 	}
+	runtime.KeepAlive(w.f)
 	if int(bytesWritten) != len(b) {
 		return int(bytesWritten), errors.New("not all bytes could be written")
 	}
@@ -245,6 +246,7 @@ func (w *BackupFileWriter) Write(b []byte) (int, error) {
 func (w *BackupFileWriter) Close() error {
 	if w.ctx != 0 {
 		backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
+		runtime.KeepAlive(w.f)
 		w.ctx = 0
 	}
 	return nil

gateway/vendor/github.com/Microsoft/go-winio/backup_test.go

@@ -1,255 +0,0 @@
-package winio
-
-import (
-	"io"
-	"io/ioutil"
-	"os"
-	"syscall"
-	"testing"
-)
-
-var testFileName string
-
-func TestMain(m *testing.M) {
-	f, err := ioutil.TempFile("", "tmp")
-	if err != nil {
-		panic(err)
-	}
-	testFileName = f.Name()
-	f.Close()
-	defer os.Remove(testFileName)
-	os.Exit(m.Run())
-}
-
-func makeTestFile(makeADS bool) error {
-	os.Remove(testFileName)
-	f, err := os.Create(testFileName)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-	_, err = f.Write([]byte("testing 1 2 3\n"))
-	if err != nil {
-		return err
-	}
-	if makeADS {
-		a, err := os.Create(testFileName + ":ads.txt")
-		if err != nil {
-			return err
-		}
-		defer a.Close()
-		_, err = a.Write([]byte("alternate data stream\n"))
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func TestBackupRead(t *testing.T) {
-	err := makeTestFile(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	f, err := os.Open(testFileName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	r := NewBackupFileReader(f, false)
-	defer r.Close()
-	b, err := ioutil.ReadAll(r)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(b) == 0 {
-		t.Fatal("no data")
-	}
-}
-
-func TestBackupStreamRead(t *testing.T) {
-	err := makeTestFile(true)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	f, err := os.Open(testFileName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	r := NewBackupFileReader(f, false)
-	defer r.Close()
-
-	br := NewBackupStreamReader(r)
-	gotData := false
-	gotAltData := false
-	for {
-		hdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		switch hdr.Id {
-		case BackupData:
-			if gotData {
-				t.Fatal("duplicate data")
-			}
-			if hdr.Name != "" {
-				t.Fatalf("unexpected name %s", hdr.Name)
-			}
-			b, err := ioutil.ReadAll(br)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if string(b) != "testing 1 2 3\n" {
-				t.Fatalf("incorrect data %v", b)
-			}
-			gotData = true
-		case BackupAlternateData:
-			if gotAltData {
-				t.Fatal("duplicate alt data")
-			}
-			if hdr.Name != ":ads.txt:$DATA" {
-				t.Fatalf("incorrect name %s", hdr.Name)
-			}
-			b, err := ioutil.ReadAll(br)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if string(b) != "alternate data stream\n" {
-				t.Fatalf("incorrect data %v", b)
-			}
-			gotAltData = true
-		default:
-			t.Fatalf("unknown stream ID %d", hdr.Id)
-		}
-	}
-	if !gotData || !gotAltData {
-		t.Fatal("missing stream")
-	}
-}
-
-func TestBackupStreamWrite(t *testing.T) {
-	f, err := os.Create(testFileName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	w := NewBackupFileWriter(f, false)
-	defer w.Close()
-
-	data := "testing 1 2 3\n"
-	altData := "alternate stream\n"
-
-	br := NewBackupStreamWriter(w)
-	err = br.WriteHeader(&BackupHeader{Id: BackupData, Size: int64(len(data))})
-	if err != nil {
-		t.Fatal(err)
-	}
-	n, err := br.Write([]byte(data))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n != len(data) {
-		t.Fatal("short write")
-	}
-
-	err = br.WriteHeader(&BackupHeader{Id: BackupAlternateData, Size: int64(len(altData)), Name: ":ads.txt:$DATA"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	n, err = br.Write([]byte(altData))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n != len(altData) {
-		t.Fatal("short write")
-	}
-
-	f.Close()
-
-	b, err := ioutil.ReadFile(testFileName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(b) != data {
-		t.Fatalf("wrong data %v", b)
-	}
-
-	b, err = ioutil.ReadFile(testFileName + ":ads.txt")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(b) != altData {
-		t.Fatalf("wrong data %v", b)
-	}
-}
-
-func makeSparseFile() error {
-	os.Remove(testFileName)
-	f, err := os.Create(testFileName)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	const (
-		FSCTL_SET_SPARSE    = 0x000900c4
-		FSCTL_SET_ZERO_DATA = 0x000980c8
-	)
-
-	err = syscall.DeviceIoControl(syscall.Handle(f.Fd()), FSCTL_SET_SPARSE, nil, 0, nil, 0, nil, nil)
-	if err != nil {
-		return err
-	}
-
-	_, err = f.Write([]byte("testing 1 2 3\n"))
-	if err != nil {
-		return err
-	}
-
-	_, err = f.Seek(1000000, 0)
-	if err != nil {
-		return err
-	}
-
-	_, err = f.Write([]byte("more data later\n"))
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func TestBackupSparseFile(t *testing.T) {
-	err := makeSparseFile()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	f, err := os.Open(testFileName)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	r := NewBackupFileReader(f, false)
-	defer r.Close()
-
-	br := NewBackupStreamReader(r)
-	for {
-		hdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		t.Log(hdr)
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/backuptar/noop.go

@@ -1,4 +0,0 @@
-// +build !windows
-// This file only exists to allow go get on non-Windows platforms.
-
-package backuptar

gateway/vendor/github.com/Microsoft/go-winio/backuptar/tar.go

@@ -1,353 +0,0 @@
-// +build windows
-
-package backuptar
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/Microsoft/go-winio"
-	"github.com/Microsoft/go-winio/archive/tar" // until archive/tar supports pax extensions in its interface
-)
-
-const (
-	c_ISUID  = 04000   // Set uid
-	c_ISGID  = 02000   // Set gid
-	c_ISVTX  = 01000   // Save text (sticky bit)
-	c_ISDIR  = 040000  // Directory
-	c_ISFIFO = 010000  // FIFO
-	c_ISREG  = 0100000 // Regular file
-	c_ISLNK  = 0120000 // Symbolic link
-	c_ISBLK  = 060000  // Block special file
-	c_ISCHR  = 020000  // Character special file
-	c_ISSOCK = 0140000 // Socket
-)
-
-const (
-	hdrFileAttributes        = "fileattr"
-	hdrSecurityDescriptor    = "sd"
-	hdrRawSecurityDescriptor = "rawsd"
-	hdrMountPoint            = "mountpoint"
-)
-
-func writeZeroes(w io.Writer, count int64) error {
-	buf := make([]byte, 8192)
-	c := len(buf)
-	for i := int64(0); i < count; i += int64(c) {
-		if int64(c) > count-i {
-			c = int(count - i)
-		}
-		_, err := w.Write(buf[:c])
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func copySparse(t *tar.Writer, br *winio.BackupStreamReader) error {
-	curOffset := int64(0)
-	for {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		if err != nil {
-			return err
-		}
-		if bhdr.Id != winio.BackupSparseBlock {
-			return fmt.Errorf("unexpected stream %d", bhdr.Id)
-		}
-
-		// archive/tar does not support writing sparse files
-		// so just write zeroes to catch up to the current offset.
-		err = writeZeroes(t, bhdr.Offset-curOffset)
-		if bhdr.Size == 0 {
-			break
-		}
-		n, err := io.Copy(t, br)
-		if err != nil {
-			return err
-		}
-		curOffset = bhdr.Offset + n
-	}
-	return nil
-}
-
-// BasicInfoHeader creates a tar header from basic file information.
-func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
-	hdr := &tar.Header{
-		Name:         filepath.ToSlash(name),
-		Size:         size,
-		Typeflag:     tar.TypeReg,
-		ModTime:      time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
-		ChangeTime:   time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
-		AccessTime:   time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
-		CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
-		Winheaders:   make(map[string]string),
-	}
-	hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
-
-	if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
-		hdr.Mode |= c_ISDIR
-		hdr.Size = 0
-		hdr.Typeflag = tar.TypeDir
-	}
-	return hdr
-}
-
-// WriteTarFileFromBackupStream writes a file to a tar writer using data from a Win32 backup stream.
-//
-// This encodes Win32 metadata as tar pax vendor extensions starting with MSWINDOWS.
-//
-// The additional Win32 metadata is:
-//
-// MSWINDOWS.fileattr: The Win32 file attributes, as a decimal value
-//
-// MSWINDOWS.rawsd: The Win32 security descriptor, in raw binary format
-//
-// MSWINDOWS.mountpoint: If present, this is a mount point and not a symlink, even though the type is '2' (symlink)
-func WriteTarFileFromBackupStream(t *tar.Writer, r io.Reader, name string, size int64, fileInfo *winio.FileBasicInfo) error {
-	name = filepath.ToSlash(name)
-	hdr := BasicInfoHeader(name, size, fileInfo)
-	br := winio.NewBackupStreamReader(r)
-	var dataHdr *winio.BackupHeader
-	for dataHdr == nil {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		switch bhdr.Id {
-		case winio.BackupData:
-			hdr.Mode |= c_ISREG
-			dataHdr = bhdr
-		case winio.BackupSecurity:
-			sd, err := ioutil.ReadAll(br)
-			if err != nil {
-				return err
-			}
-			hdr.Winheaders[hdrRawSecurityDescriptor] = base64.StdEncoding.EncodeToString(sd)
-
-		case winio.BackupReparseData:
-			hdr.Mode |= c_ISLNK
-			hdr.Typeflag = tar.TypeSymlink
-			reparseBuffer, err := ioutil.ReadAll(br)
-			rp, err := winio.DecodeReparsePoint(reparseBuffer)
-			if err != nil {
-				return err
-			}
-			if rp.IsMountPoint {
-				hdr.Winheaders[hdrMountPoint] = "1"
-			}
-			hdr.Linkname = rp.Target
-		case winio.BackupEaData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
-			// ignore these streams
-		default:
-			return fmt.Errorf("%s: unknown stream ID %d", name, bhdr.Id)
-		}
-	}
-
-	err := t.WriteHeader(hdr)
-	if err != nil {
-		return err
-	}
-
-	if dataHdr != nil {
-		// A data stream was found. Copy the data.
-		if (dataHdr.Attributes & winio.StreamSparseAttributes) == 0 {
-			if size != dataHdr.Size {
-				return fmt.Errorf("%s: mismatch between file size %d and header size %d", name, size, dataHdr.Size)
-			}
-			_, err = io.Copy(t, br)
-			if err != nil {
-				return err
-			}
-		} else {
-			err = copySparse(t, br)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	// Look for streams after the data stream. The only ones we handle are alternate data streams.
-	// Other streams may have metadata that could be serialized, but the tar header has already
-	// been written. In practice, this means that we don't get EA or TXF metadata.
-	for {
-		bhdr, err := br.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		switch bhdr.Id {
-		case winio.BackupAlternateData:
-			altName := bhdr.Name
-			if strings.HasSuffix(altName, ":$DATA") {
-				altName = altName[:len(altName)-len(":$DATA")]
-			}
-			if (bhdr.Attributes & winio.StreamSparseAttributes) == 0 {
-				hdr = &tar.Header{
-					Name:       name + altName,
-					Mode:       hdr.Mode,
-					Typeflag:   tar.TypeReg,
-					Size:       bhdr.Size,
-					ModTime:    hdr.ModTime,
-					AccessTime: hdr.AccessTime,
-					ChangeTime: hdr.ChangeTime,
-				}
-				err = t.WriteHeader(hdr)
-				if err != nil {
-					return err
-				}
-				_, err = io.Copy(t, br)
-				if err != nil {
-					return err
-				}
-
-			} else {
-				// Unsupported for now, since the size of the alternate stream is not present
-				// in the backup stream until after the data has been read.
-				return errors.New("tar of sparse alternate data streams is unsupported")
-			}
-		case winio.BackupEaData, winio.BackupLink, winio.BackupPropertyData, winio.BackupObjectId, winio.BackupTxfsData:
-			// ignore these streams
-		default:
-			return fmt.Errorf("%s: unknown stream ID %d after data", name, bhdr.Id)
-		}
-	}
-	return nil
-}
-
-// FileInfoFromHeader retrieves basic Win32 file information from a tar header, using the additional metadata written by
-// WriteTarFileFromBackupStream.
-func FileInfoFromHeader(hdr *tar.Header) (name string, size int64, fileInfo *winio.FileBasicInfo, err error) {
-	name = hdr.Name
-	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
-		size = hdr.Size
-	}
-	fileInfo = &winio.FileBasicInfo{
-		LastAccessTime: syscall.NsecToFiletime(hdr.AccessTime.UnixNano()),
-		LastWriteTime:  syscall.NsecToFiletime(hdr.ModTime.UnixNano()),
-		ChangeTime:     syscall.NsecToFiletime(hdr.ChangeTime.UnixNano()),
-		CreationTime:   syscall.NsecToFiletime(hdr.CreationTime.UnixNano()),
-	}
-	if attrStr, ok := hdr.Winheaders[hdrFileAttributes]; ok {
-		attr, err := strconv.ParseUint(attrStr, 10, 32)
-		if err != nil {
-			return "", 0, nil, err
-		}
-		fileInfo.FileAttributes = uintptr(attr)
-	} else {
-		if hdr.Typeflag == tar.TypeDir {
-			fileInfo.FileAttributes |= syscall.FILE_ATTRIBUTE_DIRECTORY
-		}
-	}
-	return
-}
-
-// WriteBackupStreamFromTarFile writes a Win32 backup stream from the current tar file. Since this function may process multiple
-// tar file entries in order to collect all the alternate data streams for the file, it returns the next
-// tar file that was not processed, or io.EOF is there are no more.
-func WriteBackupStreamFromTarFile(w io.Writer, t *tar.Reader, hdr *tar.Header) (*tar.Header, error) {
-	bw := winio.NewBackupStreamWriter(w)
-	var sd []byte
-	var err error
-	// Maintaining old SDDL-based behavior for backward compatibility.  All new tar headers written
-	// by this library will have raw binary for the security descriptor.
-	if sddl, ok := hdr.Winheaders[hdrSecurityDescriptor]; ok {
-		sd, err = winio.SddlToSecurityDescriptor(sddl)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if sdraw, ok := hdr.Winheaders[hdrRawSecurityDescriptor]; ok {
-		sd, err = base64.StdEncoding.DecodeString(sdraw)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if len(sd) != 0 {
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupSecurity,
-			Size: int64(len(sd)),
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = bw.Write(sd)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if hdr.Typeflag == tar.TypeSymlink {
-		_, isMountPoint := hdr.Winheaders[hdrMountPoint]
-		rp := winio.ReparsePoint{
-			Target:       filepath.FromSlash(hdr.Linkname),
-			IsMountPoint: isMountPoint,
-		}
-		reparse := winio.EncodeReparsePoint(&rp)
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupReparseData,
-			Size: int64(len(reparse)),
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = bw.Write(reparse)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if hdr.Typeflag == tar.TypeReg || hdr.Typeflag == tar.TypeRegA {
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupData,
-			Size: hdr.Size,
-		}
-		err := bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = io.Copy(bw, t)
-		if err != nil {
-			return nil, err
-		}
-	}
-	// Copy all the alternate data streams and return the next non-ADS header.
-	for {
-		ahdr, err := t.Next()
-		if err != nil {
-			return nil, err
-		}
-		if ahdr.Typeflag != tar.TypeReg || !strings.HasPrefix(ahdr.Name, hdr.Name+":") {
-			return ahdr, nil
-		}
-		bhdr := winio.BackupHeader{
-			Id:   winio.BackupAlternateData,
-			Size: ahdr.Size,
-			Name: ahdr.Name[len(hdr.Name):] + ":$DATA",
-		}
-		err = bw.WriteHeader(&bhdr)
-		if err != nil {
-			return nil, err
-		}
-		_, err = io.Copy(bw, t)
-		if err != nil {
-			return nil, err
-		}
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/backuptar/tar_test.go

@@ -1,84 +0,0 @@
-package backuptar
-
-import (
-	"bytes"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"reflect"
-	"testing"
-
-	"github.com/Microsoft/go-winio"
-	"github.com/Microsoft/go-winio/archive/tar"
-)
-
-func ensurePresent(t *testing.T, m map[string]string, keys ...string) {
-	for _, k := range keys {
-		if _, ok := m[k]; !ok {
-			t.Error(k, "not present in tar header")
-		}
-	}
-}
-
-func TestRoundTrip(t *testing.T) {
-	f, err := ioutil.TempFile("", "tst")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-	defer os.Remove(f.Name())
-
-	if _, err = f.Write([]byte("testing 1 2 3\n")); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err = f.Seek(0, 0); err != nil {
-		t.Fatal(err)
-	}
-
-	fi, err := f.Stat()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	bi, err := winio.GetFileBasicInfo(f)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	br := winio.NewBackupFileReader(f, true)
-	defer br.Close()
-
-	var buf bytes.Buffer
-	tw := tar.NewWriter(&buf)
-
-	err = WriteTarFileFromBackupStream(tw, br, f.Name(), fi.Size(), bi)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tr := tar.NewReader(&buf)
-	hdr, err := tr.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	name, size, bi2, err := FileInfoFromHeader(hdr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if name != filepath.ToSlash(f.Name()) {
-		t.Errorf("got name %s, expected %s", name, filepath.ToSlash(f.Name()))
-	}
-
-	if size != fi.Size() {
-		t.Errorf("got size %d, expected %d", size, fi.Size())
-	}
-
-	if !reflect.DeepEqual(*bi, *bi2) {
-		t.Errorf("got %#v, expected %#v", *bi, *bi2)
-	}
-
-	ensurePresent(t, hdr.Winheaders, "fileattr", "sd")
-}

gateway/vendor/github.com/Microsoft/go-winio/file.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"runtime"
 	"sync"
+	"sync/atomic"
 	"syscall"
 	"time"
 )
@@ -17,6 +18,12 @@ import (
 //sys setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
 //sys timeBeginPeriod(period uint32) (n int32) = winmm.timeBeginPeriod
 
+type atomicBool int32
+
+func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
+func (b *atomicBool) setFalse()   { atomic.StoreInt32((*int32)(b), 0) }
+func (b *atomicBool) setTrue()    { atomic.StoreInt32((*int32)(b), 1) }
+
 const (
 	cFILE_SKIP_COMPLETION_PORT_ON_SUCCESS = 1
 	cFILE_SKIP_SET_EVENT_ON_HANDLE        = 2
@@ -33,6 +40,8 @@ func (e *timeoutError) Error() string   { return "i/o timeout" }
 func (e *timeoutError) Timeout() bool   { return true }
 func (e *timeoutError) Temporary() bool { return true }
 
+type timeoutChan chan struct{}
+
 var ioInitOnce sync.Once
 var ioCompletionPort syscall.Handle
 
@@ -63,8 +72,16 @@ type win32File struct {
 	handle        syscall.Handle
 	wg            sync.WaitGroup
 	closing       bool
-	readDeadline  time.Time
-	writeDeadline time.Time
+	readDeadline  deadlineHandler
+	writeDeadline deadlineHandler
+}
+
+type deadlineHandler struct {
+	setLock     sync.Mutex
+	channel     timeoutChan
+	channelLock sync.RWMutex
+	timer       *time.Timer
+	timedout    atomicBool
 }
 
 // makeWin32File makes a new win32File from an existing file handle
@@ -79,7 +96,8 @@ func makeWin32File(h syscall.Handle) (*win32File, error) {
 	if err != nil {
 		return nil, err
 	}
-	runtime.SetFinalizer(f, (*win32File).closeHandle)
+	f.readDeadline.channel = make(timeoutChan)
+	f.writeDeadline.channel = make(timeoutChan)
 	return f, nil
 }
 
@@ -103,11 +121,11 @@ func (f *win32File) closeHandle() {
 // Close closes a win32File.
 func (f *win32File) Close() error {
 	f.closeHandle()
-	runtime.SetFinalizer(f, nil)
 	return nil
 }
 
-// prepareIo prepares for a new IO operation
+// prepareIo prepares for a new IO operation.
+// The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.
 func (f *win32File) prepareIo() (*ioOperation, error) {
 	f.wg.Add(1)
 	if f.closing {
@@ -136,47 +154,45 @@ func ioCompletionProcessor(h syscall.Handle) {
 
 // asyncIo processes the return value from ReadFile or WriteFile, blocking until
 // the operation has actually completed.
-func (f *win32File) asyncIo(c *ioOperation, deadline time.Time, bytes uint32, err error) (int, error) {
+func (f *win32File) asyncIo(c *ioOperation, d *deadlineHandler, bytes uint32, err error) (int, error) {
 	if err != syscall.ERROR_IO_PENDING {
-		f.wg.Done()
 		return int(bytes), err
-	} else {
-		var r ioResult
-		wait := true
-		timedout := false
+	}
+
 	if f.closing {
 		cancelIoEx(f.handle, &c.o)
-		} else if !deadline.IsZero() {
-			now := time.Now()
-			if !deadline.After(now) {
-				timedout = true
-			} else {
-				timeout := time.After(deadline.Sub(now))
+	}
+
+	var timeout timeoutChan
+	if d != nil {
+		d.channelLock.Lock()
+		timeout = d.channel
+		d.channelLock.Unlock()
+	}
+
+	var r ioResult
 	select {
 	case r = <-c.ch:
-					wait = false
-				case <-timeout:
-					timedout = true
-				}
-			}
-		}
-		if timedout {
-			cancelIoEx(f.handle, &c.o)
-		}
-		if wait {
-			r = <-c.ch
-		}
 		err = r.err
 		if err == syscall.ERROR_OPERATION_ABORTED {
 			if f.closing {
 				err = ErrFileClosed
-			} else if timedout {
+			}
+		}
+	case <-timeout:
+		cancelIoEx(f.handle, &c.o)
+		r = <-c.ch
+		err = r.err
+		if err == syscall.ERROR_OPERATION_ABORTED {
 			err = ErrTimeout
 		}
 	}
-		f.wg.Done()
+
+	// runtime.KeepAlive is needed, as c is passed via native
+	// code to ioCompletionProcessor, c must remain alive
+	// until the channel read is complete.
+	runtime.KeepAlive(c)
 	return int(r.bytes), err
-	}
 }
 
 // Read reads from a file handle.
@@ -185,9 +201,16 @@ func (f *win32File) Read(b []byte) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	defer f.wg.Done()
+
+	if f.readDeadline.timedout.isSet() {
+		return 0, ErrTimeout
+	}
+
 	var bytes uint32
 	err = syscall.ReadFile(f.handle, b, &bytes, &c.o)
-	n, err := f.asyncIo(c, f.readDeadline, bytes, err)
+	n, err := f.asyncIo(c, &f.readDeadline, bytes, err)
+	runtime.KeepAlive(b)
 
 	// Handle EOF conditions.
 	if err == nil && n == 0 && len(b) != 0 {
@@ -205,21 +228,68 @@ func (f *win32File) Write(b []byte) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	defer f.wg.Done()
+
+	if f.writeDeadline.timedout.isSet() {
+		return 0, ErrTimeout
+	}
+
 	var bytes uint32
 	err = syscall.WriteFile(f.handle, b, &bytes, &c.o)
-	return f.asyncIo(c, f.writeDeadline, bytes, err)
+	n, err := f.asyncIo(c, &f.writeDeadline, bytes, err)
+	runtime.KeepAlive(b)
+	return n, err
 }
 
-func (f *win32File) SetReadDeadline(t time.Time) error {
-	f.readDeadline = t
-	return nil
+func (f *win32File) SetReadDeadline(deadline time.Time) error {
+	return f.readDeadline.set(deadline)
 }
 
-func (f *win32File) SetWriteDeadline(t time.Time) error {
-	f.writeDeadline = t
-	return nil
+func (f *win32File) SetWriteDeadline(deadline time.Time) error {
+	return f.writeDeadline.set(deadline)
 }
 
 func (f *win32File) Flush() error {
 	return syscall.FlushFileBuffers(f.handle)
 }
+
+func (d *deadlineHandler) set(deadline time.Time) error {
+	d.setLock.Lock()
+	defer d.setLock.Unlock()
+
+	if d.timer != nil {
+		if !d.timer.Stop() {
+			<-d.channel
+		}
+		d.timer = nil
+	}
+	d.timedout.setFalse()
+
+	select {
+	case <-d.channel:
+		d.channelLock.Lock()
+		d.channel = make(chan struct{})
+		d.channelLock.Unlock()
+	default:
+	}
+
+	if deadline.IsZero() {
+		return nil
+	}
+
+	timeoutIO := func() {
+		d.timedout.setTrue()
+		close(d.channel)
+	}
+
+	now := time.Now()
+	duration := deadline.Sub(now)
+	if deadline.After(now) {
+		// Deadline is in the future, set a timer to wait
+		d.timer = time.AfterFunc(duration, timeoutIO)
+	} else {
+		// Deadline is in the past. Cancel all pending IO now.
+		timeoutIO()
+	}
+	return nil
+}

gateway/vendor/github.com/Microsoft/go-winio/fileinfo.go

@@ -4,6 +4,7 @@ package winio
 
 import (
 	"os"
+	"runtime"
 	"syscall"
 	"unsafe"
 )
@@ -28,6 +29,7 @@ func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
 	if err := getFileInformationByHandleEx(syscall.Handle(f.Fd()), fileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
 		return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
 	}
+	runtime.KeepAlive(f)
 	return bi, nil
 }
 
@@ -36,6 +38,7 @@ func SetFileBasicInfo(f *os.File, bi *FileBasicInfo) error {
 	if err := setFileInformationByHandle(syscall.Handle(f.Fd()), fileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
 		return &os.PathError{Op: "SetFileInformationByHandle", Path: f.Name(), Err: err}
 	}
+	runtime.KeepAlive(f)
 	return nil
 }
 
@@ -52,5 +55,6 @@ func GetFileID(f *os.File) (*FileIDInfo, error) {
 	if err := getFileInformationByHandleEx(syscall.Handle(f.Fd()), fileIDInfo, (*byte)(unsafe.Pointer(fileID)), uint32(unsafe.Sizeof(*fileID))); err != nil {
 		return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
 	}
+	runtime.KeepAlive(f)
 	return fileID, nil
 }

gateway/vendor/github.com/Microsoft/go-winio/pipe.go

@@ -13,17 +13,12 @@ import (
 )
 
 //sys connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) = ConnectNamedPipe
-//sys createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *securityAttributes) (handle syscall.Handle, err error)  [failretval==syscall.InvalidHandle] = CreateNamedPipeW
-//sys createFile(name string, access uint32, mode uint32, sa *securityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateFileW
+//sys createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error)  [failretval==syscall.InvalidHandle] = CreateNamedPipeW
+//sys createFile(name string, access uint32, mode uint32, sa *syscall.SecurityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateFileW
 //sys waitNamedPipe(name string, timeout uint32) (err error) = WaitNamedPipeW
 //sys getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) = GetNamedPipeInfo
 //sys getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW
-
-type securityAttributes struct {
-	Length             uint32
-	SecurityDescriptor *byte
-	InheritHandle      uint32
-}
+//sys localAlloc(uFlags uint32, length uint32) (ptr uintptr) = LocalAlloc
 
 const (
 	cERROR_PIPE_BUSY      = syscall.Errno(231)
@@ -231,12 +226,15 @@ func makeServerPipeHandle(path string, securityDescriptor []byte, c *PipeConfig,
 		mode |= cPIPE_TYPE_MESSAGE
 	}
 
-	var sa securityAttributes
-	sa.Length = uint32(unsafe.Sizeof(sa))
+	sa := &syscall.SecurityAttributes{}
+	sa.Length = uint32(unsafe.Sizeof(*sa))
 	if securityDescriptor != nil {
-		sa.SecurityDescriptor = &securityDescriptor[0]
+		len := uint32(len(securityDescriptor))
+		sa.SecurityDescriptor = localAlloc(0, len)
+		defer localFree(sa.SecurityDescriptor)
+		copy((*[0xffff]byte)(unsafe.Pointer(sa.SecurityDescriptor))[:], securityDescriptor)
 	}
-	h, err := createNamedPipe(path, flags, mode, cPIPE_UNLIMITED_INSTANCES, uint32(c.OutputBufferSize), uint32(c.InputBufferSize), 0, &sa)
+	h, err := createNamedPipe(path, flags, mode, cPIPE_UNLIMITED_INSTANCES, uint32(c.OutputBufferSize), uint32(c.InputBufferSize), 0, sa)
 	if err != nil {
 		return 0, &os.PathError{Op: "open", Path: path, Err: err}
 	}
@@ -362,8 +360,10 @@ func connectPipe(p *win32File) error {
 	if err != nil {
 		return err
 	}
+	defer p.wg.Done()
+
 	err = connectNamedPipe(p.handle, &c.o)
-	_, err = p.asyncIo(c, time.Time{}, 0, err)
+	_, err = p.asyncIo(c, nil, 0, err)
 	if err != nil && err != cERROR_PIPE_CONNECTED {
 		return err
 	}

gateway/vendor/github.com/Microsoft/go-winio/pipe_test.go

@@ -1,327 +0,0 @@
-package winio
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"os"
-	"syscall"
-	"testing"
-	"time"
-)
-
-var testPipeName = `\\.\pipe\winiotestpipe`
-
-func TestDialUnknownFailsImmediately(t *testing.T) {
-	_, err := DialPipe(testPipeName, nil)
-	if err.(*os.PathError).Err != syscall.ENOENT {
-		t.Fatalf("expected ENOENT got %v", err)
-	}
-}
-
-func TestDialListenerTimesOut(t *testing.T) {
-	l, err := ListenPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-	var d = time.Duration(10 * time.Millisecond)
-	_, err = DialPipe(testPipeName, &d)
-	if err != ErrTimeout {
-		t.Fatalf("expected ErrTimeout, got %v", err)
-	}
-}
-
-func TestDialAccessDeniedWithRestrictedSD(t *testing.T) {
-	c := PipeConfig{
-		SecurityDescriptor: "D:P(A;;0x1200FF;;;WD)",
-	}
-	l, err := ListenPipe(testPipeName, &c)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-	_, err = DialPipe(testPipeName, nil)
-	if err.(*os.PathError).Err != syscall.ERROR_ACCESS_DENIED {
-		t.Fatalf("expected ERROR_ACCESS_DENIED, got %v", err)
-	}
-}
-
-func getConnection(cfg *PipeConfig) (client net.Conn, server net.Conn, err error) {
-	l, err := ListenPipe(testPipeName, cfg)
-	if err != nil {
-		return
-	}
-	defer l.Close()
-
-	type response struct {
-		c   net.Conn
-		err error
-	}
-	ch := make(chan response)
-	go func() {
-		c, err := l.Accept()
-		ch <- response{c, err}
-	}()
-
-	c, err := DialPipe(testPipeName, nil)
-	if err != nil {
-		return
-	}
-
-	r := <-ch
-	if err = r.err; err != nil {
-		c.Close()
-		return
-	}
-
-	client = c
-	server = r.c
-	return
-}
-
-func TestReadTimeout(t *testing.T) {
-	c, s, err := getConnection(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	defer s.Close()
-
-	c.SetReadDeadline(time.Now().Add(10 * time.Millisecond))
-
-	buf := make([]byte, 10)
-	_, err = c.Read(buf)
-	if err != ErrTimeout {
-		t.Fatalf("expected ErrTimeout, got %v", err)
-	}
-}
-
-func server(l net.Listener, ch chan int) {
-	c, err := l.Accept()
-	if err != nil {
-		panic(err)
-	}
-	rw := bufio.NewReadWriter(bufio.NewReader(c), bufio.NewWriter(c))
-	s, err := rw.ReadString('\n')
-	if err != nil {
-		panic(err)
-	}
-	_, err = rw.WriteString("got " + s)
-	if err != nil {
-		panic(err)
-	}
-	err = rw.Flush()
-	if err != nil {
-		panic(err)
-	}
-	c.Close()
-	ch <- 1
-}
-
-func TestFullListenDialReadWrite(t *testing.T) {
-	l, err := ListenPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-
-	ch := make(chan int)
-	go server(l, ch)
-
-	c, err := DialPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	rw := bufio.NewReadWriter(bufio.NewReader(c), bufio.NewWriter(c))
-	_, err = rw.WriteString("hello world\n")
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = rw.Flush()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	s, err := rw.ReadString('\n')
-	if err != nil {
-		t.Fatal(err)
-	}
-	ms := "got hello world\n"
-	if s != ms {
-		t.Errorf("expected '%s', got '%s'", ms, s)
-	}
-
-	<-ch
-}
-
-func TestCloseAbortsListen(t *testing.T) {
-	l, err := ListenPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ch := make(chan error)
-	go func() {
-		_, err := l.Accept()
-		ch <- err
-	}()
-
-	time.Sleep(30 * time.Millisecond)
-	l.Close()
-
-	err = <-ch
-	if err != ErrPipeListenerClosed {
-		t.Fatalf("expected ErrPipeListenerClosed, got %v", err)
-	}
-}
-
-func ensureEOFOnClose(t *testing.T, r io.Reader, w io.Closer) {
-	b := make([]byte, 10)
-	w.Close()
-	n, err := r.Read(b)
-	if n > 0 {
-		t.Errorf("unexpected byte count %d", n)
-	}
-	if err != io.EOF {
-		t.Errorf("expected EOF: %v", err)
-	}
-}
-
-func TestCloseClientEOFServer(t *testing.T) {
-	c, s, err := getConnection(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	defer s.Close()
-	ensureEOFOnClose(t, c, s)
-}
-
-func TestCloseServerEOFClient(t *testing.T) {
-	c, s, err := getConnection(nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	defer s.Close()
-	ensureEOFOnClose(t, s, c)
-}
-
-func TestCloseWriteEOF(t *testing.T) {
-	cfg := &PipeConfig{
-		MessageMode: true,
-	}
-	c, s, err := getConnection(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-	defer s.Close()
-
-	type closeWriter interface {
-		CloseWrite() error
-	}
-
-	err = c.(closeWriter).CloseWrite()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	b := make([]byte, 10)
-	_, err = s.Read(b)
-	if err != io.EOF {
-		t.Fatal(err)
-	}
-}
-
-func TestAcceptAfterCloseFails(t *testing.T) {
-	l, err := ListenPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	l.Close()
-	_, err = l.Accept()
-	if err != ErrPipeListenerClosed {
-		t.Fatalf("expected ErrPipeListenerClosed, got %v", err)
-	}
-}
-
-func TestDialTimesOutByDefault(t *testing.T) {
-	l, err := ListenPipe(testPipeName, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-	_, err = DialPipe(testPipeName, nil)
-	if err != ErrTimeout {
-		t.Fatalf("expected ErrTimeout, got %v", err)
-	}
-}
-
-type CloseWriter interface {
-	CloseWrite() error
-}
-
-func TestEchoWithMessaging(t *testing.T) {
-	c := PipeConfig{
-		MessageMode:      true,  // Use message mode so that CloseWrite() is supported
-		InputBufferSize:  65536, // Use 64KB buffers to improve performance
-		OutputBufferSize: 65536,
-	}
-	l, err := ListenPipe(testPipeName, &c)
-
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-	listenerDone := make(chan bool)
-	clientDone := make(chan bool)
-	go func() {
-		// server echo
-		conn, e := l.Accept()
-		if e != nil {
-			t.Fatal(e)
-		}
-		time.Sleep(500 * time.Millisecond) // make *sure* we don't begin to read before eof signal is sent
-		io.Copy(conn, conn)
-		conn.(CloseWriter).CloseWrite()
-		close(listenerDone)
-	}()
-	timeout := 1 * time.Second
-	client, err := DialPipe(testPipeName, &timeout)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer client.Close()
-
-	go func() {
-		// client read back
-		bytes := make([]byte, 2)
-		n, e := client.Read(bytes)
-		if e != nil {
-			t.Fatal(e)
-		}
-		if n != 2 {
-			t.Fatalf("expected 2 bytes, got %v", n)
-		}
-		close(clientDone)
-	}()
-
-	payload := make([]byte, 2)
-	payload[0] = 0
-	payload[1] = 1
-
-	n, err := client.Write(payload)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if n != 2 {
-		t.Fatalf("expected 2 bytes, got %v", n)
-	}
-	client.(CloseWriter).CloseWrite()
-	<-listenerDone
-	<-clientDone
-}

gateway/vendor/github.com/Microsoft/go-winio/privileges_test.go

@@ -1,17 +0,0 @@
-package winio
-
-import "testing"
-
-func TestRunWithUnavailablePrivilege(t *testing.T) {
-	err := RunWithPrivilege("SeCreateTokenPrivilege", func() error { return nil })
-	if _, ok := err.(*PrivilegeError); err == nil || !ok {
-		t.Fatal("expected PrivilegeError")
-	}
-}
-
-func TestRunWithPrivileges(t *testing.T) {
-	err := RunWithPrivilege("SeShutdownPrivilege", func() error { return nil })
-	if err != nil {
-		t.Fatal(err)
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/sd_test.go

@@ -1,26 +0,0 @@
-package winio
-
-import "testing"
-
-func TestLookupInvalidSid(t *testing.T) {
-	_, err := LookupSidByName(".\\weoifjdsklfj")
-	aerr, ok := err.(*AccountLookupError)
-	if !ok || aerr.Err != cERROR_NONE_MAPPED {
-		t.Fatalf("expected AccountLookupError with ERROR_NONE_MAPPED, got %s", err)
-	}
-}
-
-func TestLookupValidSid(t *testing.T) {
-	sid, err := LookupSidByName("Everyone")
-	if err != nil || sid != "S-1-1-0" {
-		t.Fatal("expected S-1-1-0, got %s, %s", sid, err)
-	}
-}
-
-func TestLookupEmptyNameFails(t *testing.T) {
-	_, err := LookupSidByName(".\\weoifjdsklfj")
-	aerr, ok := err.(*AccountLookupError)
-	if !ok || aerr.Err != cERROR_NONE_MAPPED {
-		t.Fatalf("expected AccountLookupError with ERROR_NONE_MAPPED, got %s", err)
-	}
-}

gateway/vendor/github.com/Microsoft/go-winio/wim/decompress.go

@@ -1,138 +0,0 @@
-package wim
-
-import (
-	"encoding/binary"
-	"io"
-	"io/ioutil"
-
-	"github.com/Microsoft/go-winio/wim/lzx"
-)
-
-const chunkSize = 32768 // Compressed resource chunk size
-
-type compressedReader struct {
-	r            *io.SectionReader
-	d            io.ReadCloser
-	chunks       []int64
-	curChunk     int
-	originalSize int64
-}
-
-func newCompressedReader(r *io.SectionReader, originalSize int64, offset int64) (*compressedReader, error) {
-	nchunks := (originalSize + chunkSize - 1) / chunkSize
-	var base int64
-	chunks := make([]int64, nchunks)
-	if originalSize <= 0xffffffff {
-		// 32-bit chunk offsets
-		base = (nchunks - 1) * 4
-		chunks32 := make([]uint32, nchunks-1)
-		err := binary.Read(r, binary.LittleEndian, chunks32)
-		if err != nil {
-			return nil, err
-		}
-		for i, n := range chunks32 {
-			chunks[i+1] = int64(n)
-		}
-
-	} else {
-		// 64-bit chunk offsets
-		base = (nchunks - 1) * 8
-		err := binary.Read(r, binary.LittleEndian, chunks[1:])
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	for i, c := range chunks {
-		chunks[i] = c + base
-	}
-
-	cr := &compressedReader{
-		r:            r,
-		chunks:       chunks,
-		originalSize: originalSize,
-	}
-
-	err := cr.reset(int(offset / chunkSize))
-	if err != nil {
-		return nil, err
-	}
-
-	suboff := offset % chunkSize
-	if suboff != 0 {
-		_, err := io.CopyN(ioutil.Discard, cr.d, suboff)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return cr, nil
-}
-
-func (r *compressedReader) chunkOffset(n int) int64 {
-	if n == len(r.chunks) {
-		return r.r.Size()
-	}
-	return r.chunks[n]
-}
-
-func (r *compressedReader) chunkSize(n int) int {
-	return int(r.chunkOffset(n+1) - r.chunkOffset(n))
-}
-
-func (r *compressedReader) uncompressedSize(n int) int {
-	if n < len(r.chunks)-1 {
-		return chunkSize
-	}
-	size := int(r.originalSize % chunkSize)
-	if size == 0 {
-		size = chunkSize
-	}
-	return size
-}
-
-func (r *compressedReader) reset(n int) error {
-	if n >= len(r.chunks) {
-		return io.EOF
-	}
-	if r.d != nil {
-		r.d.Close()
-	}
-	r.curChunk = n
-	size := r.chunkSize(n)
-	uncompressedSize := r.uncompressedSize(n)
-	section := io.NewSectionReader(r.r, r.chunkOffset(n), int64(size))
-	if size != uncompressedSize {
-		d, err := lzx.NewReader(section, uncompressedSize)
-		if err != nil {
-			return err
-		}
-		r.d = d
-	} else {
-		r.d = ioutil.NopCloser(section)
-	}
-
-	return nil
-}
-
-func (r *compressedReader) Read(b []byte) (int, error) {
-	for {
-		n, err := r.d.Read(b)
-		if err != io.EOF {
-			return n, err
-		}
-
-		err = r.reset(r.curChunk + 1)
-		if err != nil {
-			return n, err
-		}
-	}
-}
-
-func (r *compressedReader) Close() error {
-	var err error
-	if r.d != nil {
-		err = r.d.Close()
-		r.d = nil
-	}
-	return err
-}

gateway/vendor/github.com/Microsoft/go-winio/wim/lzx/lzx.go

@@ -1,606 +0,0 @@
-// Package lzx implements a decompressor for the the WIM variant of the
-// LZX compression algorithm.
-//
-// The LZX algorithm is an earlier variant of LZX DELTA, which is documented
-// at https://msdn.microsoft.com/en-us/library/cc483133(v=exchg.80).aspx.
-package lzx
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"io"
-)
-
-const (
-	maincodecount = 496
-	maincodesplit = 256
-	lencodecount  = 249
-	lenshift      = 9
-	codemask      = 0x1ff
-	tablebits     = 9
-	tablesize     = 1 << tablebits
-
-	maxBlockSize = 32768
-	windowSize   = 32768
-
-	maxTreePathLen = 16
-
-	e8filesize  = 12000000
-	maxe8offset = 0x3fffffff
-
-	verbatimBlock      = 1
-	alignedOffsetBlock = 2
-	uncompressedBlock  = 3
-)
-
-var footerBits = [...]byte{
-	0, 0, 0, 0, 1, 1, 2, 2,
-	3, 3, 4, 4, 5, 5, 6, 6,
-	7, 7, 8, 8, 9, 9, 10, 10,
-	11, 11, 12, 12, 13, 13, 14,
-}
-
-var basePosition = [...]uint16{
-	0, 1, 2, 3, 4, 6, 8, 12,
-	16, 24, 32, 48, 64, 96, 128, 192,
-	256, 384, 512, 768, 1024, 1536, 2048, 3072,
-	4096, 6144, 8192, 12288, 16384, 24576, 32768,
-}
-
-var (
-	errCorrupt = errors.New("LZX data corrupt")
-)
-
-// Reader is an interface used by the decompressor to access
-// the input stream. If the provided io.Reader does not implement
-// Reader, then a bufio.Reader is used.
-type Reader interface {
-	io.Reader
-	io.ByteReader
-}
-
-type decompressor struct {
-	r            io.Reader
-	err          error
-	unaligned    bool
-	nbits        byte
-	c            uint32
-	lru          [3]uint16
-	uncompressed int
-	windowReader *bytes.Reader
-	mainlens     [maincodecount]byte
-	lenlens      [lencodecount]byte
-	window       [windowSize]byte
-	b            []byte
-	bv           int
-	bo           int
-}
-
-//go:noinline
-func (f *decompressor) fail(err error) {
-	if f.err == nil {
-		f.err = err
-	}
-	f.bo = 0
-	f.bv = 0
-}
-
-func (f *decompressor) ensureAtLeast(n int) error {
-	if f.bv-f.bo >= n {
-		return nil
-	}
-
-	if f.err != nil {
-		return f.err
-	}
-
-	if f.bv != f.bo {
-		copy(f.b[:f.bv-f.bo], f.b[f.bo:f.bv])
-	}
-	n, err := io.ReadAtLeast(f.r, f.b[f.bv-f.bo:], n)
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		} else {
-			f.fail(err)
-		}
-		return err
-	}
-	f.bv = f.bv - f.bo + n
-	f.bo = 0
-	return nil
-}
-
-// feed retrieves another 16-bit word from the stream and consumes
-// it into f.c. It returns false if there are no more bytes available.
-// Otherwise, on error, it sets f.err.
-func (f *decompressor) feed() bool {
-	err := f.ensureAtLeast(2)
-	if err != nil {
-		if err == io.ErrUnexpectedEOF {
-			return false
-		}
-	}
-	f.c |= (uint32(f.b[f.bo+1])<<8 | uint32(f.b[f.bo])) << (16 - f.nbits)
-	f.nbits += 16
-	f.bo += 2
-	return true
-}
-
-// getBits retrieves the next n bits from the byte stream. n
-// must be <= 16. It sets f.err on error.
-func (f *decompressor) getBits(n byte) uint16 {
-	if f.nbits < n {
-		if !f.feed() {
-			f.fail(io.ErrUnexpectedEOF)
-		}
-	}
-	c := uint16(f.c >> (32 - n))
-	f.c <<= n
-	f.nbits -= n
-	return c
-}
-
-type huffman struct {
-	extra   [][]uint16
-	maxbits byte
-	table   [tablesize]uint16
-}
-
-// buildTable builds a huffman decoding table from a slice of code lengths,
-// one per code, in order. Each code length must be <= maxTreePathLen.
-// See https://en.wikipedia.org/wiki/Canonical_Huffman_code.
-func buildTable(codelens []byte) *huffman {
-	// Determine the number of codes of each length, and the
-	// maximum length.
-	var count [maxTreePathLen + 1]uint
-	var max byte
-	for _, cl := range codelens {
-		count[cl]++
-		if max < cl {
-			max = cl
-		}
-	}
-
-	if max == 0 {
-		return &huffman{}
-	}
-
-	// Determine the first code of each length.
-	var first [maxTreePathLen + 1]uint
-	code := uint(0)
-	for i := byte(1); i <= max; i++ {
-		code <<= 1
-		first[i] = code
-		code += count[i]
-	}
-
-	if code != 1<<max {
-		return nil
-	}
-
-	// Build a table for code lookup. For code sizes < max,
-	// put all possible suffixes for the code into the table, too.
-	// For max > tablebits, split long codes into additional tables
-	// of suffixes of max-tablebits length.
-	h := &huffman{maxbits: max}
-	if max > tablebits {
-		core := first[tablebits+1] / 2 // Number of codes that fit without extra tables
-		nextra := 1<<tablebits - core  // Number of extra entries
-		h.extra = make([][]uint16, nextra)
-		for code := core; code < 1<<tablebits; code++ {
-			h.table[code] = uint16(code - core)
-			h.extra[code-core] = make([]uint16, 1<<(max-tablebits))
-		}
-	}
-
-	for i, cl := range codelens {
-		if cl != 0 {
-			code := first[cl]
-			first[cl]++
-			v := uint16(cl)<<lenshift | uint16(i)
-			if cl <= tablebits {
-				extendedCode := code << (tablebits - cl)
-				for j := uint(0); j < 1<<(tablebits-cl); j++ {
-					h.table[extendedCode+j] = v
-				}
-			} else {
-				prefix := code >> (cl - tablebits)
-				suffix := code & (1<<(cl-tablebits) - 1)
-				extendedCode := suffix << (max - cl)
-				for j := uint(0); j < 1<<(max-cl); j++ {
-					h.extra[h.table[prefix]][extendedCode+j] = v
-				}
-			}
-		}
-	}
-
-	return h
-}
-
-// getCode retrieves the next code using the provided
-// huffman tree. It sets f.err on error.
-func (f *decompressor) getCode(h *huffman) uint16 {
-	if h.maxbits > 0 {
-		if f.nbits < maxTreePathLen {
-			f.feed()
-		}
-
-		// For codes with length < tablebits, it doesn't matter
-		// what the remainder of the bits used for table lookup
-		// are, since entries with all possible suffixes were
-		// added to the table.
-		c := h.table[f.c>>(32-tablebits)]
-		if c >= 1<<lenshift {
-			// The code is already in c.
-		} else {
-			c = h.extra[c][f.c<<tablebits>>(32-(h.maxbits-tablebits))]
-		}
-
-		n := byte(c >> lenshift)
-		if f.nbits >= n {
-			// Only consume the length of the code, not the maximum
-			// code length.
-			f.c <<= n
-			f.nbits -= n
-			return c & codemask
-		}
-
-		f.fail(io.ErrUnexpectedEOF)
-		return 0
-	}
-
-	// This is an empty tree. It should not be used.
-	f.fail(errCorrupt)
-	return 0
-}
-
-// readTree updates the huffman tree path lengths in lens by
-// reading and decoding lengths from the byte stream. lens
-// should be prepopulated with the previous block's tree's path
-// lengths. For the first block, lens should be zero.
-func (f *decompressor) readTree(lens []byte) error {
-	// Get the pre-tree for the main tree.
-	var pretreeLen [20]byte
-	for i := range pretreeLen {
-		pretreeLen[i] = byte(f.getBits(4))
-	}
-	if f.err != nil {
-		return f.err
-	}
-	h := buildTable(pretreeLen[:])
-
-	// The lengths are encoded as a series of huffman codes
-	// encoded by the pre-tree.
-	for i := 0; i < len(lens); {
-		c := byte(f.getCode(h))
-		if f.err != nil {
-			return f.err
-		}
-		switch {
-		case c <= 16: // length is delta from previous length
-			lens[i] = (lens[i] + 17 - c) % 17
-			i++
-		case c == 17: // next n + 4 lengths are zero
-			zeroes := int(f.getBits(4)) + 4
-			if i+zeroes > len(lens) {
-				return errCorrupt
-			}
-			for j := 0; j < zeroes; j++ {
-				lens[i+j] = 0
-			}
-			i += zeroes
-		case c == 18: // next n + 20 lengths are zero
-			zeroes := int(f.getBits(5)) + 20
-			if i+zeroes > len(lens) {
-				return errCorrupt
-			}
-			for j := 0; j < zeroes; j++ {
-				lens[i+j] = 0
-			}
-			i += zeroes
-		case c == 19: // next n + 4 lengths all have the same value
-			same := int(f.getBits(1)) + 4
-			if i+same > len(lens) {
-				return errCorrupt
-			}
-			c = byte(f.getCode(h))
-			if c > 16 {
-				return errCorrupt
-			}
-			l := (lens[i] + 17 - c) % 17
-			for j := 0; j < same; j++ {
-				lens[i+j] = l
-			}
-			i += same
-		default:
-			return errCorrupt
-		}
-	}
-
-	if f.err != nil {
-		return f.err
-	}
-	return nil
-}
-
-func (f *decompressor) readBlockHeader() (byte, uint16, error) {
-	// If the previous block was an unaligned uncompressed block, restore
-	// 2-byte alignment.
-	if f.unaligned {
-		err := f.ensureAtLeast(1)
-		if err != nil {
-			return 0, 0, err
-		}
-		f.bo++
-		f.unaligned = false
-	}
-
-	blockType := f.getBits(3)
-	full := f.getBits(1)
-	var blockSize uint16
-	if full != 0 {
-		blockSize = maxBlockSize
-	} else {
-		blockSize = f.getBits(16)
-		if blockSize > maxBlockSize {
-			return 0, 0, errCorrupt
-		}
-	}
-
-	if f.err != nil {
-		return 0, 0, f.err
-	}
-
-	switch blockType {
-	case verbatimBlock, alignedOffsetBlock:
-		// The caller will read the huffman trees.
-	case uncompressedBlock:
-		if f.nbits > 16 {
-			panic("impossible: more than one 16-bit word remains")
-		}
-
-		// Drop the remaining bits in the current 16-bit word
-		// If there are no bits left, discard a full 16-bit word.
-		n := f.nbits
-		if n == 0 {
-			n = 16
-		}
-
-		f.getBits(n)
-
-		// Read the LRU values for the next block.
-		err := f.ensureAtLeast(12)
-		if err != nil {
-			return 0, 0, err
-		}
-
-		f.lru[0] = uint16(binary.LittleEndian.Uint32(f.b[f.bo : f.bo+4]))
-		f.lru[1] = uint16(binary.LittleEndian.Uint32(f.b[f.bo+4 : f.bo+8]))
-		f.lru[2] = uint16(binary.LittleEndian.Uint32(f.b[f.bo+8 : f.bo+12]))
-		f.bo += 12
-
-	default:
-		return 0, 0, errCorrupt
-	}
-
-	return byte(blockType), blockSize, nil
-}
-
-// readTrees reads the two or three huffman trees for the current block.
-// readAligned specifies whether to read the aligned offset tree.
-func (f *decompressor) readTrees(readAligned bool) (main *huffman, length *huffman, aligned *huffman, err error) {
-	// Aligned offset blocks start with a small aligned offset tree.
-	if readAligned {
-		var alignedLen [8]byte
-		for i := range alignedLen {
-			alignedLen[i] = byte(f.getBits(3))
-		}
-		aligned = buildTable(alignedLen[:])
-		if aligned == nil {
-			err = errors.New("corrupt")
-			return
-		}
-	}
-
-	// The main tree is encoded in two parts.
-	err = f.readTree(f.mainlens[:maincodesplit])
-	if err != nil {
-		return
-	}
-	err = f.readTree(f.mainlens[maincodesplit:])
-	if err != nil {
-		return
-	}
-
-	main = buildTable(f.mainlens[:])
-	if main == nil {
-		err = errors.New("corrupt")
-		return
-	}
-
-	// The length tree is encoding in a single part.
-	err = f.readTree(f.lenlens[:])
-	if err != nil {
-		return
-	}
-
-	length = buildTable(f.lenlens[:])
-	if length == nil {
-		err = errors.New("corrupt")
-		return
-	}
-
-	err = f.err
-	return
-}
-
-// readCompressedBlock decodes a compressed block, writing into the window
-// starting at start and ending at end, and using the provided huffman trees.
-func (f *decompressor) readCompressedBlock(start, end uint16, hmain, hlength, haligned *huffman) (int, error) {
-	i := start
-	for i < end {
-		main := f.getCode(hmain)
-		if f.err != nil {
-			break
-		}
-		if main < 256 {
-			// Literal byte.
-			f.window[i] = byte(main)
-			i++
-			continue
-		}
-
-		// This is a match backward in the window. Determine
-		// the offset and dlength.
-		matchlen := (main - 256) % 8
-		slot := (main - 256) / 8
-
-		// The length is either the low bits of the code,
-		// or if this is 7, is encoded with the length tree.
-		if matchlen == 7 {
-			matchlen += f.getCode(hlength)
-		}
-		matchlen += 2
-
-		var matchoffset uint16
-		if slot < 3 {
-			// The offset is one of the LRU values.
-			matchoffset = f.lru[slot]
-			f.lru[slot] = f.lru[0]
-			f.lru[0] = matchoffset
-		} else {
-			// The offset is encoded as a combination of the
-			// slot and more bits from the bit stream.
-			offsetbits := footerBits[slot]
-			var verbatimbits, alignedbits uint16
-			if offsetbits > 0 {
-				if haligned != nil && offsetbits >= 3 {
-					// This is an aligned offset block. Combine
-					// the bits written verbatim with the aligned
-					// offset tree code.
-					verbatimbits = f.getBits(offsetbits-3) * 8
-					alignedbits = f.getCode(haligned)
-				} else {
-					// There are no aligned offset bits to read,
-					// only verbatim bits.
-					verbatimbits = f.getBits(offsetbits)
-					alignedbits = 0
-				}
-			}
-			matchoffset = basePosition[slot] + verbatimbits + alignedbits - 2
-			// Update the LRU cache.
-			f.lru[2] = f.lru[1]
-			f.lru[1] = f.lru[0]
-			f.lru[0] = matchoffset
-		}
-
-		if matchoffset <= i && matchlen <= end-i {
-			copyend := i + matchlen
-			for ; i < copyend; i++ {
-				f.window[i] = f.window[i-matchoffset]
-			}
-		} else {
-			f.fail(errCorrupt)
-			break
-		}
-	}
-	return int(i - start), f.err
-}
-
-// readBlock decodes the current block and returns the number of uncompressed bytes.
-func (f *decompressor) readBlock(start uint16) (int, error) {
-	blockType, size, err := f.readBlockHeader()
-	if err != nil {
-		return 0, err
-	}
-
-	if blockType == uncompressedBlock {
-		if size%2 == 1 {
-			// Remember to realign the byte stream at the next block.
-			f.unaligned = true
-		}
-		copied := 0
-		if f.bo < f.bv {
-			copied = int(size)
-			s := int(start)
-			if copied > f.bv-f.bo {
-				copied = f.bv - f.bo
-			}
-			copy(f.window[s:s+copied], f.b[f.bo:f.bo+copied])
-			f.bo += copied
-		}
-		n, err := io.ReadFull(f.r, f.window[start+uint16(copied):start+size])
-		return copied + n, err
-	}
-
-	hmain, hlength, haligned, err := f.readTrees(blockType == alignedOffsetBlock)
-	if err != nil {
-		return 0, err
-	}
-
-	return f.readCompressedBlock(start, start+size, hmain, hlength, haligned)
-}
-
-// decodeE8 reverses the 0xe8 x86 instruction encoding that was performed
-// to the uncompressed data before it was compressed.
-func decodeE8(b []byte, off int64) {
-	if off > maxe8offset || len(b) < 10 {
-		return
-	}
-	for i := 0; i < len(b)-10; i++ {
-		if b[i] == 0xe8 {
-			currentPtr := int32(off) + int32(i)
-			abs := int32(binary.LittleEndian.Uint32(b[i+1 : i+5]))
-			if abs >= -currentPtr && abs < e8filesize {
-				var rel int32
-				if abs >= 0 {
-					rel = abs - currentPtr
-				} else {
-					rel = abs + e8filesize
-				}
-				binary.LittleEndian.PutUint32(b[i+1:i+5], uint32(rel))
-			}
-			i += 4
-		}
-	}
-}
-
-func (f *decompressor) Read(b []byte) (int, error) {
-	// Read and uncompress everything.
-	if f.windowReader == nil {
-		n := 0
-		for n < f.uncompressed {
-			k, err := f.readBlock(uint16(n))
-			if err != nil {
-				return 0, err
-			}
-			n += k
-		}
-		decodeE8(f.window[:f.uncompressed], 0)
-		f.windowReader = bytes.NewReader(f.window[:f.uncompressed])
-	}
-
-	// Just read directly from the window.
-	return f.windowReader.Read(b)
-}
-
-func (f *decompressor) Close() error {
-	return nil
-}
-
-// NewReader returns a new io.ReadCloser that decompresses a
-// WIM LZX stream until uncompressedSize bytes have been returned.
-func NewReader(r io.Reader, uncompressedSize int) (io.ReadCloser, error) {
-	if uncompressedSize > windowSize {
-		return nil, errors.New("uncompressed size is limited to 32KB")
-	}
-	f := &decompressor{
-		lru:          [3]uint16{1, 1, 1},
-		uncompressed: uncompressedSize,
-		b:            make([]byte, 4096),
-		r:            r,
-	}
-	return f, nil
-}

gateway/vendor/github.com/Microsoft/go-winio/wim/validate/validate.go

@@ -1,51 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"os"
-
-	"github.com/Microsoft/go-winio/wim"
-)
-
-func main() {
-	flag.Parse()
-	f, err := os.Open(flag.Arg(0))
-	if err != nil {
-		panic(err)
-	}
-
-	w, err := wim.NewReader(f)
-	if err != nil {
-		panic(err)
-
-	}
-
-	fmt.Printf("%#v\n%#v\n", w.Image[0], w.Image[0].Windows)
-
-	dir, err := w.Image[0].Open()
-	if err != nil {
-		panic(err)
-	}
-
-	err = recur(dir)
-	if err != nil {
-		panic(err)
-	}
-}
-
-func recur(d *wim.File) error {
-	files, err := d.Readdir()
-	if err != nil {
-		return fmt.Errorf("%s: %s", d.Name, err)
-	}
-	for _, f := range files {
-		if f.IsDir() {
-			err = recur(f)
-			if err != nil {
-				return fmt.Errorf("%s: %s", f.Name, err)
-			}
-		}
-	}
-	return nil
-}

gateway/vendor/github.com/Microsoft/go-winio/wim/wim.go

@@ -1,866 +0,0 @@
-// Package wim implements a WIM file parser.
-//
-// WIM files are used to distribute Windows file system and container images.
-// They are documented at https://msdn.microsoft.com/en-us/library/windows/desktop/dd861280.aspx.
-package wim
-
-import (
-	"bytes"
-	"crypto/sha1"
-	"encoding/binary"
-	"encoding/xml"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"strconv"
-	"sync"
-	"time"
-	"unicode/utf16"
-)
-
-// File attribute constants from Windows.
-const (
-	FILE_ATTRIBUTE_READONLY            = 0x00000001
-	FILE_ATTRIBUTE_HIDDEN              = 0x00000002
-	FILE_ATTRIBUTE_SYSTEM              = 0x00000004
-	FILE_ATTRIBUTE_DIRECTORY           = 0x00000010
-	FILE_ATTRIBUTE_ARCHIVE             = 0x00000020
-	FILE_ATTRIBUTE_DEVICE              = 0x00000040
-	FILE_ATTRIBUTE_NORMAL              = 0x00000080
-	FILE_ATTRIBUTE_TEMPORARY           = 0x00000100
-	FILE_ATTRIBUTE_SPARSE_FILE         = 0x00000200
-	FILE_ATTRIBUTE_REPARSE_POINT       = 0x00000400
-	FILE_ATTRIBUTE_COMPRESSED          = 0x00000800
-	FILE_ATTRIBUTE_OFFLINE             = 0x00001000
-	FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000
-	FILE_ATTRIBUTE_ENCRYPTED           = 0x00004000
-	FILE_ATTRIBUTE_INTEGRITY_STREAM    = 0x00008000
-	FILE_ATTRIBUTE_VIRTUAL             = 0x00010000
-	FILE_ATTRIBUTE_NO_SCRUB_DATA       = 0x00020000
-	FILE_ATTRIBUTE_EA                  = 0x00040000
-)
-
-// Windows processor architectures.
-const (
-	PROCESSOR_ARCHITECTURE_INTEL         = 0
-	PROCESSOR_ARCHITECTURE_MIPS          = 1
-	PROCESSOR_ARCHITECTURE_ALPHA         = 2
-	PROCESSOR_ARCHITECTURE_PPC           = 3
-	PROCESSOR_ARCHITECTURE_SHX           = 4
-	PROCESSOR_ARCHITECTURE_ARM           = 5
-	PROCESSOR_ARCHITECTURE_IA64          = 6
-	PROCESSOR_ARCHITECTURE_ALPHA64       = 7
-	PROCESSOR_ARCHITECTURE_MSIL          = 8
-	PROCESSOR_ARCHITECTURE_AMD64         = 9
-	PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 = 10
-	PROCESSOR_ARCHITECTURE_NEUTRAL       = 11
-	PROCESSOR_ARCHITECTURE_ARM64         = 12
-)
-
-var wimImageTag = [...]byte{'M', 'S', 'W', 'I', 'M', 0, 0, 0}
-
-type guid struct {
-	Data1 uint32
-	Data2 uint16
-	Data3 uint16
-	Data4 [8]byte
-}
-
-func (g guid) String() string {
-	return fmt.Sprintf("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", g.Data1, g.Data2, g.Data3, g.Data4[0], g.Data4[1], g.Data4[2], g.Data4[3], g.Data4[4], g.Data4[5], g.Data4[6], g.Data4[7])
-}
-
-type resourceDescriptor struct {
-	FlagsAndCompressedSize uint64
-	Offset                 int64
-	OriginalSize           int64
-}
-
-type resFlag byte
-
-const (
-	resFlagFree resFlag = 1 << iota
-	resFlagMetadata
-	resFlagCompressed
-	resFlagSpanned
-)
-
-const validate = false
-
-const supportedResFlags = resFlagMetadata | resFlagCompressed
-
-func (r *resourceDescriptor) Flags() resFlag {
-	return resFlag(r.FlagsAndCompressedSize >> 56)
-}
-
-func (r *resourceDescriptor) CompressedSize() int64 {
-	return int64(r.FlagsAndCompressedSize & 0xffffffffffffff)
-}
-
-func (r *resourceDescriptor) String() string {
-	s := fmt.Sprintf("%d bytes at %d", r.CompressedSize(), r.Offset)
-	if r.Flags()&4 != 0 {
-		s += fmt.Sprintf(" (uncompresses to %d)", r.OriginalSize)
-	}
-	return s
-}
-
-// SHA1Hash contains the SHA1 hash of a file or stream.
-type SHA1Hash [20]byte
-
-type streamDescriptor struct {
-	resourceDescriptor
-	PartNumber uint16
-	RefCount   uint32
-	Hash       SHA1Hash
-}
-
-type hdrFlag uint32
-
-const (
-	hdrFlagReserved hdrFlag = 1 << iota
-	hdrFlagCompressed
-	hdrFlagReadOnly
-	hdrFlagSpanned
-	hdrFlagResourceOnly
-	hdrFlagMetadataOnly
-	hdrFlagWriteInProgress
-	hdrFlagRpFix
-)
-
-const (
-	hdrFlagCompressReserved hdrFlag = 1 << (iota + 16)
-	hdrFlagCompressXpress
-	hdrFlagCompressLzx
-)
-
-const supportedHdrFlags = hdrFlagRpFix | hdrFlagReadOnly | hdrFlagCompressed | hdrFlagCompressLzx
-
-type wimHeader struct {
-	ImageTag        [8]byte
-	Size            uint32
-	Version         uint32
-	Flags           hdrFlag
-	CompressionSize uint32
-	WIMGuid         guid
-	PartNumber      uint16
-	TotalParts      uint16
-	ImageCount      uint32
-	OffsetTable     resourceDescriptor
-	XMLData         resourceDescriptor
-	BootMetadata    resourceDescriptor
-	BootIndex       uint32
-	Padding         uint32
-	Integrity       resourceDescriptor
-	Unused          [60]byte
-}
-
-type securityblockDisk struct {
-	TotalLength uint32
-	NumEntries  uint32
-}
-
-const securityblockDiskSize = 8
-
-type direntry struct {
-	Attributes       uint32
-	SecurityID       uint32
-	SubdirOffset     int64
-	Unused1, Unused2 int64
-	CreationTime     Filetime
-	LastAccessTime   Filetime
-	LastWriteTime    Filetime
-	Hash             SHA1Hash
-	Padding          uint32
-	ReparseHardLink  int64
-	StreamCount      uint16
-	ShortNameLength  uint16
-	FileNameLength   uint16
-}
-
-var direntrySize = int64(binary.Size(direntry{}) + 8) // includes an 8-byte length prefix
-
-type streamentry struct {
-	Unused     int64
-	Hash       SHA1Hash
-	NameLength int16
-}
-
-var streamentrySize = int64(binary.Size(streamentry{}) + 8) // includes an 8-byte length prefix
-
-// Filetime represents a Windows time.
-type Filetime struct {
-	LowDateTime  uint32
-	HighDateTime uint32
-}
-
-// Time returns the time as time.Time.
-func (ft *Filetime) Time() time.Time {
-	// 100-nanosecond intervals since January 1, 1601
-	nsec := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime)
-	// change starting time to the Epoch (00:00:00 UTC, January 1, 1970)
-	nsec -= 116444736000000000
-	// convert into nanoseconds
-	nsec *= 100
-	return time.Unix(0, nsec)
-}
-
-// UnmarshalXML unmarshals the time from a WIM XML blob.
-func (ft *Filetime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
-	type time struct {
-		Low  string `xml:"LOWPART"`
-		High string `xml:"HIGHPART"`
-	}
-	var t time
-	err := d.DecodeElement(&t, &start)
-	if err != nil {
-		return err
-	}
-
-	low, err := strconv.ParseUint(t.Low, 0, 32)
-	if err != nil {
-		return err
-	}
-	high, err := strconv.ParseUint(t.High, 0, 32)
-	if err != nil {
-		return err
-	}
-
-	ft.LowDateTime = uint32(low)
-	ft.HighDateTime = uint32(high)
-	return nil
-}
-
-type info struct {
-	Image []ImageInfo `xml:"IMAGE"`
-}
-
-// ImageInfo contains information about the image.
-type ImageInfo struct {
-	Name         string       `xml:"NAME"`
-	Index        int          `xml:"INDEX,attr"`
-	CreationTime Filetime     `xml:"CREATIONTIME"`
-	ModTime      Filetime     `xml:"LASTMODIFICATIONTIME"`
-	Windows      *WindowsInfo `xml:"WINDOWS"`
-}
-
-// WindowsInfo contains information about the Windows installation in the image.
-type WindowsInfo struct {
-	Arch             byte     `xml:"ARCH"`
-	ProductName      string   `xml:"PRODUCTNAME"`
-	EditionID        string   `xml:"EDITIONID"`
-	InstallationType string   `xml:"INSTALLATIONTYPE"`
-	ProductType      string   `xml:"PRODUCTTYPE"`
-	Languages        []string `xml:"LANGUAGES>LANGUAGE"`
-	DefaultLanguage  string   `xml:"LANGUAGES>DEFAULT"`
-	Version          Version  `xml:"VERSION"`
-	SystemRoot       string   `xml:"SYSTEMROOT"`
-}
-
-// Version represents a Windows build version.
-type Version struct {
-	Major   int `xml:"MAJOR"`
-	Minor   int `xml:"MINOR"`
-	Build   int `xml:"BUILD"`
-	SPBuild int `xml:"SPBUILD"`
-	SPLevel int `xml:"SPLEVEL"`
-}
-
-// ParseError is returned when the WIM cannot be parsed.
-type ParseError struct {
-	Oper string
-	Path string
-	Err  error
-}
-
-func (e *ParseError) Error() string {
-	if e.Path == "" {
-		return "WIM parse error at " + e.Oper + ": " + e.Err.Error()
-	}
-	return fmt.Sprintf("WIM parse error: %s %s: %s", e.Oper, e.Path, e.Err.Error())
-}
-
-// Reader provides functions to read a WIM file.
-type Reader struct {
-	hdr      wimHeader
-	r        io.ReaderAt
-	fileData map[SHA1Hash]resourceDescriptor
-
-	XMLInfo string   // The XML information about the WIM.
-	Image   []*Image // The WIM's images.
-}
-
-// Image represents an image within a WIM file.
-type Image struct {
-	wim        *Reader
-	offset     resourceDescriptor
-	sds        [][]byte
-	rootOffset int64
-	r          io.ReadCloser
-	curOffset  int64
-	m          sync.Mutex
-
-	ImageInfo
-}
-
-// StreamHeader contains alternate data stream metadata.
-type StreamHeader struct {
-	Name string
-	Hash SHA1Hash
-	Size int64
-}
-
-// Stream represents an alternate data stream or reparse point data stream.
-type Stream struct {
-	StreamHeader
-	wim    *Reader
-	offset resourceDescriptor
-}
-
-// FileHeader contains file metadata.
-type FileHeader struct {
-	Name               string
-	ShortName          string
-	Attributes         uint32
-	SecurityDescriptor []byte
-	CreationTime       Filetime
-	LastAccessTime     Filetime
-	LastWriteTime      Filetime
-	Hash               SHA1Hash
-	Size               int64
-	LinkID             int64
-	ReparseTag         uint32
-	ReparseReserved    uint32
-}
-
-// File represents a file or directory in a WIM image.
-type File struct {
-	FileHeader
-	Streams      []*Stream
-	offset       resourceDescriptor
-	img          *Image
-	subdirOffset int64
-}
-
-// NewReader returns a Reader that can be used to read WIM file data.
-func NewReader(f io.ReaderAt) (*Reader, error) {
-	r := &Reader{r: f}
-	section := io.NewSectionReader(f, 0, 0xffff)
-	err := binary.Read(section, binary.LittleEndian, &r.hdr)
-	if err != nil {
-		return nil, err
-	}
-
-	if r.hdr.ImageTag != wimImageTag {
-		return nil, &ParseError{Oper: "image tag", Err: errors.New("not a WIM file")}
-	}
-
-	if r.hdr.Flags&^supportedHdrFlags != 0 {
-		return nil, fmt.Errorf("unsupported WIM flags %x", r.hdr.Flags&^supportedHdrFlags)
-	}
-
-	if r.hdr.CompressionSize != 0x8000 {
-		return nil, fmt.Errorf("unsupported compression size %d", r.hdr.CompressionSize)
-	}
-
-	if r.hdr.TotalParts != 1 {
-		return nil, errors.New("multi-part WIM not supported")
-	}
-
-	fileData, images, err := r.readOffsetTable(&r.hdr.OffsetTable)
-	if err != nil {
-		return nil, err
-	}
-
-	xmlinfo, err := r.readXML()
-	if err != nil {
-		return nil, err
-	}
-
-	var info info
-	err = xml.Unmarshal([]byte(xmlinfo), &info)
-	if err != nil {
-		return nil, &ParseError{Oper: "XML info", Err: err}
-	}
-
-	for i, img := range images {
-		for _, imgInfo := range info.Image {
-			if imgInfo.Index == i+1 {
-				img.ImageInfo = imgInfo
-				break
-			}
-		}
-	}
-
-	r.fileData = fileData
-	r.Image = images
-	r.XMLInfo = xmlinfo
-	return r, nil
-}
-
-// Close releases resources associated with the Reader.
-func (r *Reader) Close() error {
-	for _, img := range r.Image {
-		img.reset()
-	}
-	return nil
-}
-
-func (r *Reader) resourceReader(hdr *resourceDescriptor) (io.ReadCloser, error) {
-	return r.resourceReaderWithOffset(hdr, 0)
-}
-
-func (r *Reader) resourceReaderWithOffset(hdr *resourceDescriptor, offset int64) (io.ReadCloser, error) {
-	var sr io.ReadCloser
-	section := io.NewSectionReader(r.r, hdr.Offset, hdr.CompressedSize())
-	if hdr.Flags()&resFlagCompressed == 0 {
-		section.Seek(offset, 0)
-		sr = ioutil.NopCloser(section)
-	} else {
-		cr, err := newCompressedReader(section, hdr.OriginalSize, offset)
-		if err != nil {
-			return nil, err
-		}
-		sr = cr
-	}
-
-	return sr, nil
-}
-
-func (r *Reader) readResource(hdr *resourceDescriptor) ([]byte, error) {
-	rsrc, err := r.resourceReader(hdr)
-	if err != nil {
-		return nil, err
-	}
-	defer rsrc.Close()
-	return ioutil.ReadAll(rsrc)
-}
-
-func (r *Reader) readXML() (string, error) {
-	if r.hdr.XMLData.CompressedSize() == 0 {
-		return "", nil
-	}
-	rsrc, err := r.resourceReader(&r.hdr.XMLData)
-	if err != nil {
-		return "", err
-	}
-	defer rsrc.Close()
-
-	XMLData := make([]uint16, r.hdr.XMLData.OriginalSize/2)
-	err = binary.Read(rsrc, binary.LittleEndian, XMLData)
-	if err != nil {
-		return "", &ParseError{Oper: "XML data", Err: err}
-	}
-
-	// The BOM will always indicate little-endian UTF-16.
-	if XMLData[0] != 0xfeff {
-		return "", &ParseError{Oper: "XML data", Err: errors.New("invalid BOM")}
-	}
-	return string(utf16.Decode(XMLData[1:])), nil
-}
-
-func (r *Reader) readOffsetTable(res *resourceDescriptor) (map[SHA1Hash]resourceDescriptor, []*Image, error) {
-	fileData := make(map[SHA1Hash]resourceDescriptor)
-	var images []*Image
-
-	offsetTable, err := r.readResource(res)
-	if err != nil {
-		return nil, nil, &ParseError{Oper: "offset table", Err: err}
-	}
-
-	br := bytes.NewReader(offsetTable)
-	for i := 0; ; i++ {
-		var res streamDescriptor
-		err := binary.Read(br, binary.LittleEndian, &res)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return nil, nil, &ParseError{Oper: "offset table", Err: err}
-		}
-		if res.Flags()&^supportedResFlags != 0 {
-			return nil, nil, &ParseError{Oper: "offset table", Err: errors.New("unsupported resource flag")}
-		}
-
-		// Validation for ad-hoc testing
-		if validate {
-			sec, err := r.resourceReader(&res.resourceDescriptor)
-			if err != nil {
-				panic(fmt.Sprint(i, err))
-			}
-			hash := sha1.New()
-			_, err = io.Copy(hash, sec)
-			sec.Close()
-			if err != nil {
-				panic(fmt.Sprint(i, err))
-			}
-			var cmphash SHA1Hash
-			copy(cmphash[:], hash.Sum(nil))
-			if cmphash != res.Hash {
-				panic(fmt.Sprint(i, "hash mismatch"))
-			}
-		}
-
-		if res.Flags()&resFlagMetadata != 0 {
-			image := &Image{
-				wim:    r,
-				offset: res.resourceDescriptor,
-			}
-			images = append(images, image)
-		} else {
-			fileData[res.Hash] = res.resourceDescriptor
-		}
-	}
-
-	if len(images) != int(r.hdr.ImageCount) {
-		return nil, nil, &ParseError{Oper: "offset table", Err: errors.New("mismatched image count")}
-	}
-
-	return fileData, images, nil
-}
-
-func (r *Reader) readSecurityDescriptors(rsrc io.Reader) (sds [][]byte, n int64, err error) {
-	var secBlock securityblockDisk
-	err = binary.Read(rsrc, binary.LittleEndian, &secBlock)
-	if err != nil {
-		err = &ParseError{Oper: "security table", Err: err}
-		return
-	}
-
-	n += securityblockDiskSize
-
-	secSizes := make([]int64, secBlock.NumEntries)
-	err = binary.Read(rsrc, binary.LittleEndian, &secSizes)
-	if err != nil {
-		err = &ParseError{Oper: "security table sizes", Err: err}
-		return
-	}
-
-	n += int64(secBlock.NumEntries * 8)
-
-	sds = make([][]byte, secBlock.NumEntries)
-	for i, size := range secSizes {
-		sd := make([]byte, size&0xffffffff)
-		_, err = io.ReadFull(rsrc, sd)
-		if err != nil {
-			err = &ParseError{Oper: "security descriptor", Err: err}
-			return
-		}
-		n += int64(len(sd))
-		sds[i] = sd
-	}
-
-	secsize := int64((secBlock.TotalLength + 7) &^ 7)
-	if n > secsize {
-		err = &ParseError{Oper: "security descriptor", Err: errors.New("security descriptor table too small")}
-		return
-	}
-
-	_, err = io.CopyN(ioutil.Discard, rsrc, secsize-n)
-	if err != nil {
-		return
-	}
-
-	n = secsize
-	return
-}
-
-// Open parses the image and returns the root directory.
-func (img *Image) Open() (*File, error) {
-	if img.sds == nil {
-		rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, img.rootOffset)
-		if err != nil {
-			return nil, err
-		}
-		sds, n, err := img.wim.readSecurityDescriptors(rsrc)
-		if err != nil {
-			rsrc.Close()
-			return nil, err
-		}
-		img.sds = sds
-		img.r = rsrc
-		img.rootOffset = n
-		img.curOffset = n
-	}
-
-	f, err := img.readdir(img.rootOffset)
-	if err != nil {
-		return nil, err
-	}
-	if len(f) != 1 {
-		return nil, &ParseError{Oper: "root directory", Err: errors.New("expected exactly 1 root directory entry")}
-	}
-	return f[0], err
-}
-
-func (img *Image) reset() {
-	if img.r != nil {
-		img.r.Close()
-		img.r = nil
-	}
-	img.curOffset = -1
-}
-
-func (img *Image) readdir(offset int64) ([]*File, error) {
-	img.m.Lock()
-	defer img.m.Unlock()
-
-	if offset < img.curOffset || offset > img.curOffset+chunkSize {
-		// Reset to seek backward or to seek forward very far.
-		img.reset()
-	}
-	if img.r == nil {
-		rsrc, err := img.wim.resourceReaderWithOffset(&img.offset, offset)
-		if err != nil {
-			return nil, err
-		}
-		img.r = rsrc
-		img.curOffset = offset
-	}
-	if offset > img.curOffset {
-		_, err := io.CopyN(ioutil.Discard, img.r, offset-img.curOffset)
-		if err != nil {
-			img.reset()
-			if err == io.EOF {
-				err = io.ErrUnexpectedEOF
-			}
-			return nil, err
-		}
-	}
-
-	var entries []*File
-	for {
-		e, n, err := img.readNextEntry(img.r)
-		img.curOffset += n
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			img.reset()
-			return nil, err
-		}
-		entries = append(entries, e)
-	}
-	return entries, nil
-}
-
-func (img *Image) readNextEntry(r io.Reader) (*File, int64, error) {
-	var length int64
-	err := binary.Read(r, binary.LittleEndian, &length)
-	if err != nil {
-		return nil, 0, &ParseError{Oper: "directory length check", Err: err}
-	}
-
-	if length == 0 {
-		return nil, 8, io.EOF
-	}
-
-	left := length
-	if left < direntrySize {
-		return nil, 0, &ParseError{Oper: "directory entry", Err: errors.New("size too short")}
-	}
-
-	var dentry direntry
-	err = binary.Read(r, binary.LittleEndian, &dentry)
-	if err != nil {
-		return nil, 0, &ParseError{Oper: "directory entry", Err: err}
-	}
-
-	left -= direntrySize
-
-	namesLen := int64(dentry.FileNameLength + 2 + dentry.ShortNameLength)
-	if left < namesLen {
-		return nil, 0, &ParseError{Oper: "directory entry", Err: errors.New("size too short for names")}
-	}
-
-	names := make([]uint16, namesLen/2)
-	err = binary.Read(r, binary.LittleEndian, names)
-	if err != nil {
-		return nil, 0, &ParseError{Oper: "file name", Err: err}
-	}
-
-	left -= namesLen
-
-	var name, shortName string
-	if dentry.FileNameLength > 0 {
-		name = string(utf16.Decode(names[:dentry.FileNameLength/2]))
-	}
-
-	if dentry.ShortNameLength > 0 {
-		shortName = string(utf16.Decode(names[dentry.FileNameLength/2+1:]))
-	}
-
-	var offset resourceDescriptor
-	zerohash := SHA1Hash{}
-	if dentry.Hash != zerohash {
-		var ok bool
-		offset, ok = img.wim.fileData[dentry.Hash]
-		if !ok {
-			return nil, 0, &ParseError{Oper: "directory entry", Path: name, Err: fmt.Errorf("could not find file data matching hash %#v", dentry)}
-		}
-	}
-
-	f := &File{
-		FileHeader: FileHeader{
-			Attributes:     dentry.Attributes,
-			CreationTime:   dentry.CreationTime,
-			LastAccessTime: dentry.LastAccessTime,
-			LastWriteTime:  dentry.LastWriteTime,
-			Hash:           dentry.Hash,
-			Size:           offset.OriginalSize,
-			Name:           name,
-			ShortName:      shortName,
-		},
-
-		offset:       offset,
-		img:          img,
-		subdirOffset: dentry.SubdirOffset,
-	}
-
-	isDir := false
-
-	if dentry.Attributes&FILE_ATTRIBUTE_REPARSE_POINT == 0 {
-		f.LinkID = dentry.ReparseHardLink
-		if dentry.Attributes&FILE_ATTRIBUTE_DIRECTORY != 0 {
-			isDir = true
-		}
-	} else {
-		f.ReparseTag = uint32(dentry.ReparseHardLink)
-		f.ReparseReserved = uint32(dentry.ReparseHardLink >> 32)
-	}
-
-	if isDir && f.subdirOffset == 0 {
-		return nil, 0, &ParseError{Oper: "directory entry", Path: name, Err: errors.New("no subdirectory data for directory")}
-	} else if !isDir && f.subdirOffset != 0 {
-		return nil, 0, &ParseError{Oper: "directory entry", Path: name, Err: errors.New("unexpected subdirectory data for non-directory")}
-	}
-
-	if dentry.SecurityID != 0xffffffff {
-		f.SecurityDescriptor = img.sds[dentry.SecurityID]
-	}
-
-	_, err = io.CopyN(ioutil.Discard, r, left)
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return nil, 0, err
-	}
-
-	if dentry.StreamCount > 0 {
-		var streams []*Stream
-		for i := uint16(0); i < dentry.StreamCount; i++ {
-			s, n, err := img.readNextStream(r)
-			length += n
-			if err != nil {
-				return nil, 0, err
-			}
-			// The first unnamed stream should be treated as the file stream.
-			if i == 0 && s.Name == "" {
-				f.Hash = s.Hash
-				f.Size = s.Size
-				f.offset = s.offset
-			} else if s.Name != "" {
-				streams = append(streams, s)
-			}
-		}
-		f.Streams = streams
-	}
-
-	if dentry.Attributes&FILE_ATTRIBUTE_REPARSE_POINT != 0 && f.Size == 0 {
-		return nil, 0, &ParseError{Oper: "directory entry", Path: name, Err: errors.New("reparse point is missing reparse stream")}
-	}
-
-	return f, length, nil
-}
-
-func (img *Image) readNextStream(r io.Reader) (*Stream, int64, error) {
-	var length int64
-	err := binary.Read(r, binary.LittleEndian, &length)
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return nil, 0, &ParseError{Oper: "stream length check", Err: err}
-	}
-
-	left := length
-	if left < streamentrySize {
-		return nil, 0, &ParseError{Oper: "stream entry", Err: errors.New("size too short")}
-	}
-
-	var sentry streamentry
-	err = binary.Read(r, binary.LittleEndian, &sentry)
-	if err != nil {
-		return nil, 0, &ParseError{Oper: "stream entry", Err: err}
-	}
-
-	left -= streamentrySize
-
-	if left < int64(sentry.NameLength) {
-		return nil, 0, &ParseError{Oper: "stream entry", Err: errors.New("size too short for name")}
-	}
-
-	names := make([]uint16, sentry.NameLength/2)
-	err = binary.Read(r, binary.LittleEndian, names)
-	if err != nil {
-		return nil, 0, &ParseError{Oper: "file name", Err: err}
-	}
-
-	left -= int64(sentry.NameLength)
-	name := string(utf16.Decode(names))
-
-	var offset resourceDescriptor
-	if sentry.Hash != (SHA1Hash{}) {
-		var ok bool
-		offset, ok = img.wim.fileData[sentry.Hash]
-		if !ok {
-			return nil, 0, &ParseError{Oper: "stream entry", Path: name, Err: fmt.Errorf("could not find file data matching hash %v", sentry.Hash)}
-		}
-	}
-
-	s := &Stream{
-		StreamHeader: StreamHeader{
-			Hash: sentry.Hash,
-			Size: offset.OriginalSize,
-			Name: name,
-		},
-		wim:    img.wim,
-		offset: offset,
-	}
-
-	_, err = io.CopyN(ioutil.Discard, r, left)
-	if err != nil {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-		return nil, 0, err
-	}
-
-	return s, length, nil
-}
-
-// Open returns an io.ReadCloser that can be used to read the stream's contents.
-func (s *Stream) Open() (io.ReadCloser, error) {
-	return s.wim.resourceReader(&s.offset)
-}
-
-// Open returns an io.ReadCloser that can be used to read the file's contents.
-func (f *File) Open() (io.ReadCloser, error) {
-	return f.img.wim.resourceReader(&f.offset)
-}
-
-// Readdir reads the directory entries.
-func (f *File) Readdir() ([]*File, error) {
-	if !f.IsDir() {
-		return nil, errors.New("not a directory")
-	}
-	return f.img.readdir(f.subdirOffset)
-}
-
-// IsDir returns whether the given file is a directory. It returns false when it
-// is a directory reparse point.
-func (f *FileHeader) IsDir() bool {
-	return f.Attributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT) == FILE_ATTRIBUTE_DIRECTORY
-}

gateway/vendor/github.com/Microsoft/go-winio/zsyscall_windows.go

@@ -11,6 +11,31 @@ import (
 
 var _ unsafe.Pointer
 
+// Do the interface allocations only once for common
+// Errno values.
+const (
+	errnoERROR_IO_PENDING = 997
+)
+
+var (
+	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+	switch e {
+	case 0:
+		return nil
+	case errnoERROR_IO_PENDING:
+		return errERROR_IO_PENDING
+	}
+	// TODO: add more here, after collecting data on the common
+	// error values see on Windows. (perhaps when running
+	// all.bat?)
+	return e
+}
+
 var (
 	modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
 	modwinmm    = windows.NewLazySystemDLL("winmm.dll")
@@ -27,6 +52,7 @@ var (
 	procWaitNamedPipeW                                       = modkernel32.NewProc("WaitNamedPipeW")
 	procGetNamedPipeInfo                                     = modkernel32.NewProc("GetNamedPipeInfo")
 	procGetNamedPipeHandleStateW                             = modkernel32.NewProc("GetNamedPipeHandleStateW")
+	procLocalAlloc                                           = modkernel32.NewProc("LocalAlloc")
 	procLookupAccountNameW                                   = modadvapi32.NewProc("LookupAccountNameW")
 	procConvertSidToStringSidW                               = modadvapi32.NewProc("ConvertSidToStringSidW")
 	procConvertStringSecurityDescriptorToSecurityDescriptorW = modadvapi32.NewProc("ConvertStringSecurityDescriptorToSecurityDescriptorW")
@@ -51,7 +77,7 @@ func cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) {
 	r1, _, e1 := syscall.Syscall(procCancelIoEx.Addr(), 2, uintptr(file), uintptr(unsafe.Pointer(o)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -64,7 +90,7 @@ func createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintpt
 	newport = syscall.Handle(r0)
 	if newport == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -76,7 +102,7 @@ func getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr,
 	r1, _, e1 := syscall.Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(port), uintptr(unsafe.Pointer(bytes)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(o)), uintptr(timeout), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -88,7 +114,7 @@ func setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err erro
 	r1, _, e1 := syscall.Syscall(procSetFileCompletionNotificationModes.Addr(), 2, uintptr(h), uintptr(flags), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -106,7 +132,7 @@ func connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) {
 	r1, _, e1 := syscall.Syscall(procConnectNamedPipe.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(o)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -114,7 +140,7 @@ func connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) {
 	return
 }
 
-func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *securityAttributes) (handle syscall.Handle, err error) {
+func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
 	var _p0 *uint16
 	_p0, err = syscall.UTF16PtrFromString(name)
 	if err != nil {
@@ -123,12 +149,12 @@ func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances ui
 	return _createNamedPipe(_p0, flags, pipeMode, maxInstances, outSize, inSize, defaultTimeout, sa)
 }
 
-func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *securityAttributes) (handle syscall.Handle, err error) {
+func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
 	r0, _, e1 := syscall.Syscall9(procCreateNamedPipeW.Addr(), 8, uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)), 0)
 	handle = syscall.Handle(r0)
 	if handle == syscall.InvalidHandle {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -136,7 +162,7 @@ func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances
 	return
 }
 
-func createFile(name string, access uint32, mode uint32, sa *securityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) {
+func createFile(name string, access uint32, mode uint32, sa *syscall.SecurityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) {
 	var _p0 *uint16
 	_p0, err = syscall.UTF16PtrFromString(name)
 	if err != nil {
@@ -145,12 +171,12 @@ func createFile(name string, access uint32, mode uint32, sa *securityAttributes,
 	return _createFile(_p0, access, mode, sa, createmode, attrs, templatefile)
 }
 
-func _createFile(name *uint16, access uint32, mode uint32, sa *securityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) {
+func _createFile(name *uint16, access uint32, mode uint32, sa *syscall.SecurityAttributes, createmode uint32, attrs uint32, templatefile syscall.Handle) (handle syscall.Handle, err error) {
 	r0, _, e1 := syscall.Syscall9(procCreateFileW.Addr(), 7, uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile), 0, 0)
 	handle = syscall.Handle(r0)
 	if handle == syscall.InvalidHandle {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -171,7 +197,7 @@ func _waitNamedPipe(name *uint16, timeout uint32) (err error) {
 	r1, _, e1 := syscall.Syscall(procWaitNamedPipeW.Addr(), 2, uintptr(unsafe.Pointer(name)), uintptr(timeout), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -183,7 +209,7 @@ func getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSiz
 	r1, _, e1 := syscall.Syscall6(procGetNamedPipeInfo.Addr(), 5, uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -195,7 +221,7 @@ func getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *u
 	r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -203,6 +229,12 @@ func getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *u
 	return
 }
 
+func localAlloc(uFlags uint32, length uint32) (ptr uintptr) {
+	r0, _, _ := syscall.Syscall(procLocalAlloc.Addr(), 2, uintptr(uFlags), uintptr(length), 0)
+	ptr = uintptr(r0)
+	return
+}
+
 func lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
 	var _p0 *uint16
 	_p0, err = syscall.UTF16PtrFromString(accountName)
@@ -216,7 +248,7 @@ func _lookupAccountName(systemName *uint16, accountName *uint16, sid *byte, sidS
 	r1, _, e1 := syscall.Syscall9(procLookupAccountNameW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -228,7 +260,7 @@ func convertSidToStringSid(sid *byte, str **uint16) (err error) {
 	r1, _, e1 := syscall.Syscall(procConvertSidToStringSidW.Addr(), 2, uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(str)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -249,7 +281,7 @@ func _convertStringSecurityDescriptorToSecurityDescriptor(str *uint16, revision
 	r1, _, e1 := syscall.Syscall6(procConvertStringSecurityDescriptorToSecurityDescriptorW.Addr(), 4, uintptr(unsafe.Pointer(str)), uintptr(revision), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(size)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -261,7 +293,7 @@ func convertSecurityDescriptorToStringSecurityDescriptor(sd *byte, revision uint
 	r1, _, e1 := syscall.Syscall6(procConvertSecurityDescriptorToStringSecurityDescriptorW.Addr(), 5, uintptr(unsafe.Pointer(sd)), uintptr(revision), uintptr(secInfo), uintptr(unsafe.Pointer(sddl)), uintptr(unsafe.Pointer(sddlSize)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -284,7 +316,7 @@ func getFileInformationByHandleEx(h syscall.Handle, class uint32, buffer *byte,
 	r1, _, e1 := syscall.Syscall6(procGetFileInformationByHandleEx.Addr(), 4, uintptr(h), uintptr(class), uintptr(unsafe.Pointer(buffer)), uintptr(size), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -296,7 +328,7 @@ func setFileInformationByHandle(h syscall.Handle, class uint32, buffer *byte, si
 	r1, _, e1 := syscall.Syscall6(procSetFileInformationByHandle.Addr(), 4, uintptr(h), uintptr(class), uintptr(unsafe.Pointer(buffer)), uintptr(size), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -315,7 +347,7 @@ func adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, ou
 	success = r0 != 0
 	if true {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -327,7 +359,7 @@ func impersonateSelf(level uint32) (err error) {
 	r1, _, e1 := syscall.Syscall(procImpersonateSelf.Addr(), 1, uintptr(level), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -339,7 +371,7 @@ func revertToSelf() (err error) {
 	r1, _, e1 := syscall.Syscall(procRevertToSelf.Addr(), 0, 0, 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -357,7 +389,7 @@ func openThreadToken(thread syscall.Handle, accessMask uint32, openAsSelf bool,
 	r1, _, e1 := syscall.Syscall6(procOpenThreadToken.Addr(), 4, uintptr(thread), uintptr(accessMask), uintptr(_p0), uintptr(unsafe.Pointer(token)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -389,7 +421,7 @@ func _lookupPrivilegeValue(systemName *uint16, name *uint16, luid *uint64) (err
 	r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -410,7 +442,7 @@ func _lookupPrivilegeName(systemName *uint16, luid *uint64, buffer *uint16, size
 	r1, _, e1 := syscall.Syscall6(procLookupPrivilegeNameW.Addr(), 4, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -431,7 +463,7 @@ func _lookupPrivilegeDisplayName(systemName *uint16, name *uint16, buffer *uint1
 	r1, _, e1 := syscall.Syscall6(procLookupPrivilegeDisplayNameW.Addr(), 5, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(languageId)), 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -459,7 +491,7 @@ func backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, proce
 	r1, _, e1 := syscall.Syscall9(procBackupRead.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesRead)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}
@@ -487,7 +519,7 @@ func backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, p
 	r1, _, e1 := syscall.Syscall9(procBackupWrite.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesWritten)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
 	if r1 == 0 {
 		if e1 != 0 {
-			err = error(e1)
+			err = errnoErr(e1)
 		} else {
 			err = syscall.EINVAL
 		}

gateway/vendor/github.com/Nvveen/Gotty/gotty.go

@@ -8,12 +8,10 @@ package gotty
 // TODO add more concurrency to name lookup, look for more opportunities.
 
 import (
-	"bytes"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"os"
-	"path"
 	"reflect"
 	"strings"
 	"sync"
@@ -23,30 +21,33 @@ import (
 // If something went wrong reading the terminfo database file, an error is
 // returned.
 func OpenTermInfo(termName string) (*TermInfo, error) {
-	if len(termName) == 0 {
-		return nil, errors.New("No termname given")
-	}
+	var term *TermInfo
+	var err error
 	// Find the environment variables
-	if termloc := os.Getenv("TERMINFO"); len(termloc) > 0 {
-		return readTermInfo(path.Join(termloc, string(termName[0]), termName))
-	} else {
+	termloc := os.Getenv("TERMINFO")
+	if len(termloc) == 0 {
 		// Search like ncurses
-		locations := []string{}
-		if h := os.Getenv("HOME"); len(h) > 0 {
-			locations = append(locations, path.Join(h, ".terminfo"))
-		}
-		locations = append(locations,
-			"/etc/terminfo/",
-			"/lib/terminfo/",
-			"/usr/share/terminfo/")
+		locations := []string{os.Getenv("HOME") + "/.terminfo/", "/etc/terminfo/",
+			"/lib/terminfo/", "/usr/share/terminfo/"}
+		var path string
 		for _, str := range locations {
-			term, err := readTermInfo(path.Join(str, string(termName[0]), termName))
-			if err == nil {
-				return term, nil
+			// Construct path
+			path = str + string(termName[0]) + "/" + termName
+			// Check if path can be opened
+			file, _ := os.Open(path)
+			if file != nil {
+				// Path can open, fall out and use current path
+				file.Close()
+				break
 			}
 		}
-		return nil, errors.New("No terminfo file(-location) found")
+		if len(path) > 0 {
+			term, err = readTermInfo(path)
+		} else {
+			err = errors.New(fmt.Sprintf("No terminfo file(-location) found"))
 		}
+	}
+	return term, err
 }
 
 // Open a terminfo file from the environment variable containing the current
@@ -191,9 +192,7 @@ func readTermInfo(path string) (*TermInfo, error) {
 		}
 	}
 	// If the number of bytes read is not even, a byte for alignment is added
-	// We know the header is an even number of bytes so only need to check the
-	// total of the names and booleans.
-	if (header[1]+header[2])%2 != 0 {
+	if len(byteArray)%2 != 0 {
 		err = binary.Read(file, binary.LittleEndian, make([]byte, 1))
 		if err != nil {
 			return nil, err
@@ -229,14 +228,9 @@ func readTermInfo(path string) (*TermInfo, error) {
 	// We get an offset, and then iterate until the string is null-terminated
 	for i, offset := range shArray {
 		if offset > -1 {
-			if int(offset) >= len(byteArray) {
-				return nil, errors.New("array out of bounds reading string section")
+			r := offset
+			for ; byteArray[r] != 0; r++ {
 			}
-			r := bytes.IndexByte(byteArray[offset:], 0)
-			if r == -1 {
-				return nil, errors.New("missing nul byte reading string section")
-			}
-			r += int(offset)
 			term.strAttributes[StrAttr[i*2+1]] = string(byteArray[offset:r])
 		}
 	}

gateway/vendor/github.com/Sirupsen/logrus/.gitignore

@@ -1 +0,0 @@
-logrus

gateway/vendor/github.com/Sirupsen/logrus/.travis.yml

@@ -1,8 +0,0 @@
-language: go
-go:
-  - 1.6
-  - 1.7
-  - tip
-install:
-  - go get -t ./...
-script: GOMAXPROCS=4 GORACE="halt_on_error=1" go test -race -v ./...

gateway/vendor/github.com/Sirupsen/logrus/CHANGELOG.md

@@ -1,94 +0,0 @@
-# 0.11.5
-
-* feature: add writer and writerlevel to entry (#372)
-
-# 0.11.4
-
-* bug: fix undefined variable on solaris (#493)
-
-# 0.11.3
-
-* formatter: configure quoting of empty values (#484)
-* formatter: configure quoting character (default is `"`) (#484)
-* bug: fix not importing io correctly in non-linux environments (#481)
-
-# 0.11.2
-
-* bug: fix windows terminal detection (#476)
-
-# 0.11.1
-
-* bug: fix tty detection with custom out (#471)
-
-# 0.11.0
-
-* performance: Use bufferpool to allocate (#370)
-* terminal: terminal detection for app-engine (#343)
-* feature: exit handler (#375)
-
-# 0.10.0
-
-* feature: Add a test hook (#180)
-* feature: `ParseLevel` is now case-insensitive (#326)
-* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
-* performance: avoid re-allocations on `WithFields` (#335)
-
-# 0.9.0
-
-* logrus/text_formatter: don't emit empty msg
-* logrus/hooks/airbrake: move out of main repository
-* logrus/hooks/sentry: move out of main repository
-* logrus/hooks/papertrail: move out of main repository
-* logrus/hooks/bugsnag: move out of main repository
-* logrus/core: run tests with `-race`
-* logrus/core: detect TTY based on `stderr`
-* logrus/core: support `WithError` on logger
-* logrus/core: Solaris support
-
-# 0.8.7
-
-* logrus/core: fix possible race (#216)
-* logrus/doc: small typo fixes and doc improvements
-
-
-# 0.8.6
-
-* hooks/raven: allow passing an initialized client
-
-# 0.8.5
-
-* logrus/core: revert #208
-
-# 0.8.4
-
-* formatter/text: fix data race (#218)
-
-# 0.8.3
-
-* logrus/core: fix entry log level (#208)
-* logrus/core: improve performance of text formatter by 40%
-* logrus/core: expose `LevelHooks` type
-* logrus/core: add support for DragonflyBSD and NetBSD
-* formatter/text: print structs more verbosely
-
-# 0.8.2
-
-* logrus: fix more Fatal family functions
-
-# 0.8.1
-
-* logrus: fix not exiting on `Fatalf` and `Fatalln`
-
-# 0.8.0
-
-* logrus: defaults to stderr instead of stdout
-* hooks/sentry: add special field for `*http.Request`
-* formatter/text: ignore Windows for colors
-
-# 0.7.3
-
-* formatter/\*: allow configuration of timestamp layout
-
-# 0.7.2
-
-* formatter/text: Add configuration option for time format (#158)

gateway/vendor/github.com/Sirupsen/logrus/alt_exit_test.go

@@ -1,74 +0,0 @@
-package logrus
-
-import (
-	"io/ioutil"
-	"os/exec"
-	"testing"
-	"time"
-)
-
-func TestRegister(t *testing.T) {
-	current := len(handlers)
-	RegisterExitHandler(func() {})
-	if len(handlers) != current+1 {
-		t.Fatalf("can't add handler")
-	}
-}
-
-func TestHandler(t *testing.T) {
-	gofile := "/tmp/testprog.go"
-	if err := ioutil.WriteFile(gofile, testprog, 0666); err != nil {
-		t.Fatalf("can't create go file")
-	}
-
-	outfile := "/tmp/testprog.out"
-	arg := time.Now().UTC().String()
-	err := exec.Command("go", "run", gofile, outfile, arg).Run()
-	if err == nil {
-		t.Fatalf("completed normally, should have failed")
-	}
-
-	data, err := ioutil.ReadFile(outfile)
-	if err != nil {
-		t.Fatalf("can't read output file %s", outfile)
-	}
-
-	if string(data) != arg {
-		t.Fatalf("bad data")
-	}
-}
-
-var testprog = []byte(`
-// Test program for atexit, gets output file and data as arguments and writes
-// data to output file in atexit handler.
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	"flag"
-	"fmt"
-	"io/ioutil"
-)
-
-var outfile = ""
-var data = ""
-
-func handler() {
-	ioutil.WriteFile(outfile, []byte(data), 0666)
-}
-
-func badHandler() {
-	n := 0
-	fmt.Println(1/n)
-}
-
-func main() {
-	flag.Parse()
-	outfile = flag.Arg(0)
-	data = flag.Arg(1)
-
-	logrus.RegisterExitHandler(handler)
-	logrus.RegisterExitHandler(badHandler)
-	logrus.Fatal("Bye bye")
-}
-`)

gateway/vendor/github.com/Sirupsen/logrus/entry_test.go

@@ -1,77 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestEntryWithError(t *testing.T) {
-
-	assert := assert.New(t)
-
-	defer func() {
-		ErrorKey = "error"
-	}()
-
-	err := fmt.Errorf("kaboom at layer %d", 4711)
-
-	assert.Equal(err, WithError(err).Data["error"])
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-
-	assert.Equal(err, entry.WithError(err).Data["error"])
-
-	ErrorKey = "err"
-
-	assert.Equal(err, entry.WithError(err).Data["err"])
-
-}
-
-func TestEntryPanicln(t *testing.T) {
-	errBoom := fmt.Errorf("boom time")
-
-	defer func() {
-		p := recover()
-		assert.NotNil(t, p)
-
-		switch pVal := p.(type) {
-		case *Entry:
-			assert.Equal(t, "kaboom", pVal.Message)
-			assert.Equal(t, errBoom, pVal.Data["err"])
-		default:
-			t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
-		}
-	}()
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-	entry.WithField("err", errBoom).Panicln("kaboom")
-}
-
-func TestEntryPanicf(t *testing.T) {
-	errBoom := fmt.Errorf("boom again")
-
-	defer func() {
-		p := recover()
-		assert.NotNil(t, p)
-
-		switch pVal := p.(type) {
-		case *Entry:
-			assert.Equal(t, "kaboom true", pVal.Message)
-			assert.Equal(t, errBoom, pVal.Data["err"])
-		default:
-			t.Fatalf("want type *Entry, got %T: %#v", pVal, pVal)
-		}
-	}()
-
-	logger := New()
-	logger.Out = &bytes.Buffer{}
-	entry := NewEntry(logger)
-	entry.WithField("err", errBoom).Panicf("kaboom %v", true)
-}

gateway/vendor/github.com/Sirupsen/logrus/examples/basic/basic.go

@@ -1,59 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	// "os"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.JSONFormatter)
-	log.Formatter = new(logrus.TextFormatter) // default
-
-	// file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666)
-	// if err == nil {
-	// 	log.Out = file
-	// } else {
-	// 	log.Info("Failed to log to file, using default stderr")
-	// }
-
-	log.Level = logrus.DebugLevel
-}
-
-func main() {
-	defer func() {
-		err := recover()
-		if err != nil {
-			log.WithFields(logrus.Fields{
-				"omg":    true,
-				"err":    err,
-				"number": 100,
-			}).Fatal("The ice breaks!")
-		}
-	}()
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"number": 8,
-	}).Debug("Started observing beach")
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"temperature": -4,
-	}).Debug("Temperature changes")
-
-	log.WithFields(logrus.Fields{
-		"animal": "orca",
-		"size":   9009,
-	}).Panic("It's over 9000!")
-}

gateway/vendor/github.com/Sirupsen/logrus/examples/hook/hook.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	"gopkg.in/gemnasium/logrus-airbrake-hook.v2"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.TextFormatter) // default
-	log.Hooks.Add(airbrake.NewHook(123, "xyz", "development"))
-}
-
-func main() {
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 100,
-	}).Fatal("The ice breaks!")
-}

gateway/vendor/github.com/Sirupsen/logrus/formatter_bench_test.go

@@ -1,101 +0,0 @@
-package logrus
-
-import (
-	"fmt"
-	"testing"
-	"time"
-)
-
-// smallFields is a small size data set for benchmarking
-var smallFields = Fields{
-	"foo":   "bar",
-	"baz":   "qux",
-	"one":   "two",
-	"three": "four",
-}
-
-// largeFields is a large size data set for benchmarking
-var largeFields = Fields{
-	"foo":       "bar",
-	"baz":       "qux",
-	"one":       "two",
-	"three":     "four",
-	"five":      "six",
-	"seven":     "eight",
-	"nine":      "ten",
-	"eleven":    "twelve",
-	"thirteen":  "fourteen",
-	"fifteen":   "sixteen",
-	"seventeen": "eighteen",
-	"nineteen":  "twenty",
-	"a":         "b",
-	"c":         "d",
-	"e":         "f",
-	"g":         "h",
-	"i":         "j",
-	"k":         "l",
-	"m":         "n",
-	"o":         "p",
-	"q":         "r",
-	"s":         "t",
-	"u":         "v",
-	"w":         "x",
-	"y":         "z",
-	"this":      "will",
-	"make":      "thirty",
-	"entries":   "yeah",
-}
-
-var errorFields = Fields{
-	"foo": fmt.Errorf("bar"),
-	"baz": fmt.Errorf("qux"),
-}
-
-func BenchmarkErrorTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, errorFields)
-}
-
-func BenchmarkSmallTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func BenchmarkLargeTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{DisableColors: true}, largeFields)
-}
-
-func BenchmarkSmallColoredTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{ForceColors: true}, smallFields)
-}
-
-func BenchmarkLargeColoredTextFormatter(b *testing.B) {
-	doBenchmark(b, &TextFormatter{ForceColors: true}, largeFields)
-}
-
-func BenchmarkSmallJSONFormatter(b *testing.B) {
-	doBenchmark(b, &JSONFormatter{}, smallFields)
-}
-
-func BenchmarkLargeJSONFormatter(b *testing.B) {
-	doBenchmark(b, &JSONFormatter{}, largeFields)
-}
-
-func doBenchmark(b *testing.B, formatter Formatter, fields Fields) {
-	logger := New()
-
-	entry := &Entry{
-		Time:    time.Time{},
-		Level:   InfoLevel,
-		Message: "message",
-		Data:    fields,
-		Logger:  logger,
-	}
-	var d []byte
-	var err error
-	for i := 0; i < b.N; i++ {
-		d, err = formatter.Format(entry)
-		if err != nil {
-			b.Fatal(err)
-		}
-		b.SetBytes(int64(len(d)))
-	}
-}

gateway/vendor/github.com/Sirupsen/logrus/hook_test.go

@@ -1,122 +0,0 @@
-package logrus
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type TestHook struct {
-	Fired bool
-}
-
-func (hook *TestHook) Fire(entry *Entry) error {
-	hook.Fired = true
-	return nil
-}
-
-func (hook *TestHook) Levels() []Level {
-	return []Level{
-		DebugLevel,
-		InfoLevel,
-		WarnLevel,
-		ErrorLevel,
-		FatalLevel,
-		PanicLevel,
-	}
-}
-
-func TestHookFires(t *testing.T) {
-	hook := new(TestHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		assert.Equal(t, hook.Fired, false)
-
-		log.Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, true)
-	})
-}
-
-type ModifyHook struct {
-}
-
-func (hook *ModifyHook) Fire(entry *Entry) error {
-	entry.Data["wow"] = "whale"
-	return nil
-}
-
-func (hook *ModifyHook) Levels() []Level {
-	return []Level{
-		DebugLevel,
-		InfoLevel,
-		WarnLevel,
-		ErrorLevel,
-		FatalLevel,
-		PanicLevel,
-	}
-}
-
-func TestHookCanModifyEntry(t *testing.T) {
-	hook := new(ModifyHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.WithField("wow", "elephant").Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["wow"], "whale")
-	})
-}
-
-func TestCanFireMultipleHooks(t *testing.T) {
-	hook1 := new(ModifyHook)
-	hook2 := new(TestHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook1)
-		log.Hooks.Add(hook2)
-
-		log.WithField("wow", "elephant").Print("test")
-	}, func(fields Fields) {
-		assert.Equal(t, fields["wow"], "whale")
-		assert.Equal(t, hook2.Fired, true)
-	})
-}
-
-type ErrorHook struct {
-	Fired bool
-}
-
-func (hook *ErrorHook) Fire(entry *Entry) error {
-	hook.Fired = true
-	return nil
-}
-
-func (hook *ErrorHook) Levels() []Level {
-	return []Level{
-		ErrorLevel,
-	}
-}
-
-func TestErrorHookShouldntFireOnInfo(t *testing.T) {
-	hook := new(ErrorHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.Info("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, false)
-	})
-}
-
-func TestErrorHookShouldFireOnError(t *testing.T) {
-	hook := new(ErrorHook)
-
-	LogAndAssertJSON(t, func(log *Logger) {
-		log.Hooks.Add(hook)
-		log.Error("test")
-	}, func(fields Fields) {
-		assert.Equal(t, hook.Fired, true)
-	})
-}

gateway/vendor/github.com/Sirupsen/logrus/hooks/syslog/README.md

@@ -1,39 +0,0 @@
-# Syslog Hooks for Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>
-
-## Usage
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```
-
-If you want to connect to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). Just assign empty string to the first two parameters of `NewSyslogHook`. It should look like the following.
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```

gateway/vendor/github.com/Sirupsen/logrus/hooks/syslog/syslog.go

@@ -1,54 +0,0 @@
-// +build !windows,!nacl,!plan9
-
-package logrus_syslog
-
-import (
-	"fmt"
-	"github.com/Sirupsen/logrus"
-	"log/syslog"
-	"os"
-)
-
-// SyslogHook to send logs via syslog.
-type SyslogHook struct {
-	Writer        *syslog.Writer
-	SyslogNetwork string
-	SyslogRaddr   string
-}
-
-// Creates a hook to be added to an instance of logger. This is called with
-// `hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_DEBUG, "")`
-// `if err == nil { log.Hooks.Add(hook) }`
-func NewSyslogHook(network, raddr string, priority syslog.Priority, tag string) (*SyslogHook, error) {
-	w, err := syslog.Dial(network, raddr, priority, tag)
-	return &SyslogHook{w, network, raddr}, err
-}
-
-func (hook *SyslogHook) Fire(entry *logrus.Entry) error {
-	line, err := entry.String()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Unable to read entry, %v", err)
-		return err
-	}
-
-	switch entry.Level {
-	case logrus.PanicLevel:
-		return hook.Writer.Crit(line)
-	case logrus.FatalLevel:
-		return hook.Writer.Crit(line)
-	case logrus.ErrorLevel:
-		return hook.Writer.Err(line)
-	case logrus.WarnLevel:
-		return hook.Writer.Warning(line)
-	case logrus.InfoLevel:
-		return hook.Writer.Info(line)
-	case logrus.DebugLevel:
-		return hook.Writer.Debug(line)
-	default:
-		return nil
-	}
-}
-
-func (hook *SyslogHook) Levels() []logrus.Level {
-	return logrus.AllLevels
-}

gateway/vendor/github.com/Sirupsen/logrus/hooks/syslog/syslog_test.go

@@ -1,26 +0,0 @@
-package logrus_syslog
-
-import (
-	"github.com/Sirupsen/logrus"
-	"log/syslog"
-	"testing"
-)
-
-func TestLocalhostAddAndPrint(t *testing.T) {
-	log := logrus.New()
-	hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-
-	if err != nil {
-		t.Errorf("Unable to connect to local syslog.")
-	}
-
-	log.Hooks.Add(hook)
-
-	for _, level := range hook.Levels() {
-		if len(log.Hooks[level]) != 1 {
-			t.Errorf("SyslogHook was not added. The length of log.Hooks[%v]: %v", level, len(log.Hooks[level]))
-		}
-	}
-
-	log.Info("Congratulations!")
-}

gateway/vendor/github.com/Sirupsen/logrus/hooks/test/test.go

@@ -1,67 +0,0 @@
-package test
-
-import (
-	"io/ioutil"
-
-	"github.com/Sirupsen/logrus"
-)
-
-// test.Hook is a hook designed for dealing with logs in test scenarios.
-type Hook struct {
-	Entries []*logrus.Entry
-}
-
-// Installs a test hook for the global logger.
-func NewGlobal() *Hook {
-
-	hook := new(Hook)
-	logrus.AddHook(hook)
-
-	return hook
-
-}
-
-// Installs a test hook for a given local logger.
-func NewLocal(logger *logrus.Logger) *Hook {
-
-	hook := new(Hook)
-	logger.Hooks.Add(hook)
-
-	return hook
-
-}
-
-// Creates a discarding logger and installs the test hook.
-func NewNullLogger() (*logrus.Logger, *Hook) {
-
-	logger := logrus.New()
-	logger.Out = ioutil.Discard
-
-	return logger, NewLocal(logger)
-
-}
-
-func (t *Hook) Fire(e *logrus.Entry) error {
-	t.Entries = append(t.Entries, e)
-	return nil
-}
-
-func (t *Hook) Levels() []logrus.Level {
-	return logrus.AllLevels
-}
-
-// LastEntry returns the last entry that was logged or nil.
-func (t *Hook) LastEntry() (l *logrus.Entry) {
-
-	if i := len(t.Entries) - 1; i < 0 {
-		return nil
-	} else {
-		return t.Entries[i]
-	}
-
-}
-
-// Reset removes all Entries from this test hook.
-func (t *Hook) Reset() {
-	t.Entries = make([]*logrus.Entry, 0)
-}

gateway/vendor/github.com/Sirupsen/logrus/hooks/test/test_test.go

@@ -1,39 +0,0 @@
-package test
-
-import (
-	"testing"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestAllHooks(t *testing.T) {
-
-	assert := assert.New(t)
-
-	logger, hook := NewNullLogger()
-	assert.Nil(hook.LastEntry())
-	assert.Equal(0, len(hook.Entries))
-
-	logger.Error("Hello error")
-	assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
-	assert.Equal("Hello error", hook.LastEntry().Message)
-	assert.Equal(1, len(hook.Entries))
-
-	logger.Warn("Hello warning")
-	assert.Equal(logrus.WarnLevel, hook.LastEntry().Level)
-	assert.Equal("Hello warning", hook.LastEntry().Message)
-	assert.Equal(2, len(hook.Entries))
-
-	hook.Reset()
-	assert.Nil(hook.LastEntry())
-	assert.Equal(0, len(hook.Entries))
-
-	hook = NewGlobal()
-
-	logrus.Error("Hello error")
-	assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)
-	assert.Equal("Hello error", hook.LastEntry().Message)
-	assert.Equal(1, len(hook.Entries))
-
-}

gateway/vendor/github.com/Sirupsen/logrus/json_formatter_test.go

@@ -1,199 +0,0 @@
-package logrus
-
-import (
-	"encoding/json"
-	"errors"
-	"strings"
-	"testing"
-)
-
-func TestErrorNotLost(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("error", errors.New("wild walrus")))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["error"] != "wild walrus" {
-		t.Fatal("Error field not set")
-	}
-}
-
-func TestErrorNotLostOnFieldNotNamedError(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("omg", errors.New("wild walrus")))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["omg"] != "wild walrus" {
-		t.Fatal("Error field not set")
-	}
-}
-
-func TestFieldClashWithTime(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("time", "right now!"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.time"] != "right now!" {
-		t.Fatal("fields.time not set to original time field")
-	}
-
-	if entry["time"] != "0001-01-01T00:00:00Z" {
-		t.Fatal("time field not set to current time, was: ", entry["time"])
-	}
-}
-
-func TestFieldClashWithMsg(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("msg", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.msg"] != "something" {
-		t.Fatal("fields.msg not set to original msg field")
-	}
-}
-
-func TestFieldClashWithLevel(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	entry := make(map[string]interface{})
-	err = json.Unmarshal(b, &entry)
-	if err != nil {
-		t.Fatal("Unable to unmarshal formatted entry: ", err)
-	}
-
-	if entry["fields.level"] != "something" {
-		t.Fatal("fields.level not set to original level field")
-	}
-}
-
-func TestJSONEntryEndsWithNewline(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-
-	if b[len(b)-1] != '\n' {
-		t.Fatal("Expected JSON log entry to end with a newline")
-	}
-}
-
-func TestJSONMessageKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyMsg: "message",
-		},
-	}
-
-	b, err := formatter.Format(&Entry{Message: "oh hai"})
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !(strings.Contains(s, "message") && strings.Contains(s, "oh hai")) {
-		t.Fatal("Expected JSON to format message key")
-	}
-}
-
-func TestJSONLevelKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyLevel: "somelevel",
-		},
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, "somelevel") {
-		t.Fatal("Expected JSON to format level key")
-	}
-}
-
-func TestJSONTimeKey(t *testing.T) {
-	formatter := &JSONFormatter{
-		FieldMap: FieldMap{
-			FieldKeyTime: "timeywimey",
-		},
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, "timeywimey") {
-		t.Fatal("Expected JSON to format time key")
-	}
-}
-
-func TestJSONDisableTimestamp(t *testing.T) {
-	formatter := &JSONFormatter{
-		DisableTimestamp: true,
-	}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if strings.Contains(s, FieldKeyTime) {
-		t.Error("Did not prevent timestamp", s)
-	}
-}
-
-func TestJSONEnableTimestamp(t *testing.T) {
-	formatter := &JSONFormatter{}
-
-	b, err := formatter.Format(WithField("level", "something"))
-	if err != nil {
-		t.Fatal("Unable to format entry: ", err)
-	}
-	s := string(b)
-	if !strings.Contains(s, FieldKeyTime) {
-		t.Error("Timestamp not present", s)
-	}
-}

gateway/vendor/github.com/Sirupsen/logrus/logger_bench_test.go

@@ -1,61 +0,0 @@
-package logrus
-
-import (
-	"os"
-	"testing"
-)
-
-// smallFields is a small size data set for benchmarking
-var loggerFields = Fields{
-	"foo":   "bar",
-	"baz":   "qux",
-	"one":   "two",
-	"three": "four",
-}
-
-func BenchmarkDummyLogger(b *testing.B) {
-	nullf, err := os.OpenFile("/dev/null", os.O_WRONLY, 0666)
-	if err != nil {
-		b.Fatalf("%v", err)
-	}
-	defer nullf.Close()
-	doLoggerBenchmark(b, nullf, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func BenchmarkDummyLoggerNoLock(b *testing.B) {
-	nullf, err := os.OpenFile("/dev/null", os.O_WRONLY|os.O_APPEND, 0666)
-	if err != nil {
-		b.Fatalf("%v", err)
-	}
-	defer nullf.Close()
-	doLoggerBenchmarkNoLock(b, nullf, &TextFormatter{DisableColors: true}, smallFields)
-}
-
-func doLoggerBenchmark(b *testing.B, out *os.File, formatter Formatter, fields Fields) {
-	logger := Logger{
-		Out:       out,
-		Level:     InfoLevel,
-		Formatter: formatter,
-	}
-	entry := logger.WithFields(fields)
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			entry.Info("aaa")
-		}
-	})
-}
-
-func doLoggerBenchmarkNoLock(b *testing.B, out *os.File, formatter Formatter, fields Fields) {
-	logger := Logger{
-		Out:       out,
-		Level:     InfoLevel,
-		Formatter: formatter,
-	}
-	logger.SetNoLock()
-	entry := logger.WithFields(fields)
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			entry.Info("aaa")
-		}
-	})
-}