@@ -5,12 +5,12 @@ import (

 	"net/http"

 	"net/url"

 	"os"

-	"os/exec"

 	"path/filepath"

 	"strings"

 	"github.com/moby/sys/symlink"

 	"github.com/pkg/errors"

+	exec "golang.org/x/sys/execabs"

 )

 type gitRepo struct {

@@ -11,7 +11,6 @@ import (

 	"io"

 	"io/ioutil"

 	"os"

-	"os/exec"

 	"path/filepath"

 	"runtime"

 	"strconv"

@@ -25,6 +24,7 @@ import (

 	"github.com/docker/docker/pkg/pools"

 	"github.com/docker/docker/pkg/system"

 	"github.com/sirupsen/logrus"

+	exec "golang.org/x/sys/execabs"

 )

 type (

@@ -20,7 +20,7 @@ github.com/creack/pty                               2a38352e8b4d7ab6c336eef107e4

 github.com/sirupsen/logrus                          6699a89a232f3db797f2e280639854bbc4b89725 # v1.7.0

 github.com/tchap/go-patricia                        a7f0089c6f496e8e70402f61733606daa326cac5 # v2.3.0

 golang.org/x/net                                    ab34263943818b32f575efc978a3d24e80b04bd7

-golang.org/x/sys                                    eeed37f84f13f52d35e095e8023ba65671ff86a1

+golang.org/x/sys                                    b64e53b001e413bd5067f36d4e439eded3827374

 github.com/docker/go-units                          519db1ee28dcc9fd2474ae59fca29a810482bfb1 # v0.4.0

 github.com/docker/go-connections                    7395e3f8aa162843a74ed6d48e79627d9792ac55 # v0.4.0

 golang.org/x/text                                   23ae387dee1f90d29a23c0e87ee0b46038fbed0e # v0.3.3

@@ -1,5 +1,7 @@

 # sys

+[![Go Reference](https://pkg.go.dev/badge/golang.org/x/sys.svg)](https://pkg.go.dev/golang.org/x/sys)

+

 This repository holds supplemental Go packages for low-level interactions with

 the operating system.

@@ -2,7 +2,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !gccgo

+// +build gc

 #include "textflag.h"

@@ -39,34 +39,34 @@ func initOptions() {

 func archInit() {

 	switch runtime.GOOS {

-	case "android", "darwin", "ios", "netbsd", "openbsd":

-		// Android and iOS don't seem to allow reading these registers.

-		//

-		// NetBSD:

-		// ID_AA64ISAR0_EL1 is a privileged register and cannot be read from EL0.

-		// It can be read via sysctl(3). Example for future implementers:

-		// https://nxr.netbsd.org/xref/src/usr.sbin/cpuctl/arch/aarch64.c

+	case "freebsd":

+		readARM64Registers()

+	case "linux", "netbsd":

+		doinit()

+	default:

+		// Most platforms don't seem to allow reading these registers.

 		//

 		// OpenBSD:

 		// See https://golang.org/issue/31746

-		//

-		// Fake the minimal features expected by

-		// TestARM64minimalFeatures.

-		ARM64.HasASIMD = true

-		ARM64.HasFP = true

-	case "linux":

-		doinit()

-	default:

-		readARM64Registers()

+		setMinimalFeatures()

 	}

 }

+// setMinimalFeatures fakes the minimal ARM64 features expected by

+// TestARM64minimalFeatures.

+func setMinimalFeatures() {

+	ARM64.HasASIMD = true

+	ARM64.HasFP = true

+}

+

 func readARM64Registers() {

 	Initialized = true

-	// ID_AA64ISAR0_EL1

-	isar0 := getisar0()

+	parseARM64SystemRegisters(getisar0(), getisar1(), getpfr0())

+}

+func parseARM64SystemRegisters(isar0, isar1, pfr0 uint64) {

+	// ID_AA64ISAR0_EL1

 	switch extractBits(isar0, 4, 7) {

 	case 1:

 		ARM64.HasAES = true

@@ -124,8 +124,6 @@ func readARM64Registers() {

 	}

 	// ID_AA64ISAR1_EL1

-	isar1 := getisar1()

-

 	switch extractBits(isar1, 0, 3) {

 	case 1:

 		ARM64.HasDCPOP = true

@@ -147,8 +145,6 @@ func readARM64Registers() {

 	}

 	// ID_AA64PFR0_EL1

-	pfr0 := getpfr0()

-

 	switch extractBits(pfr0, 16, 19) {

 	case 0:

 		ARM64.HasFP = true

@@ -2,7 +2,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !gccgo

+// +build gc

 #include "textflag.h"

@@ -2,7 +2,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !gccgo

+// +build gc

 package cpu

@@ -2,7 +2,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !gccgo

+// +build gc

 package cpu

@@ -3,7 +3,7 @@

 // license that can be found in the LICENSE file.

 // +build 386 amd64 amd64p32

-// +build !gccgo

+// +build gc

 package cpu

@@ -17,86 +17,7 @@ const (

 	hwcap_VXE    = 8192

 )

-// bitIsSet reports whether the bit at index is set. The bit index

-// is in big endian order, so bit index 0 is the leftmost bit.

-func bitIsSet(bits []uint64, index uint) bool {

-	return bits[index/64]&((1<<63)>>(index%64)) != 0

-}

-

-// function is the code for the named cryptographic function.

-type function uint8

-

-const (

-	// KM{,A,C,CTR} function codes

-	aes128 function = 18 // AES-128

-	aes192 function = 19 // AES-192

-	aes256 function = 20 // AES-256

-

-	// K{I,L}MD function codes

-	sha1     function = 1  // SHA-1

-	sha256   function = 2  // SHA-256

-	sha512   function = 3  // SHA-512

-	sha3_224 function = 32 // SHA3-224

-	sha3_256 function = 33 // SHA3-256

-	sha3_384 function = 34 // SHA3-384

-	sha3_512 function = 35 // SHA3-512

-	shake128 function = 36 // SHAKE-128

-	shake256 function = 37 // SHAKE-256

-

-	// KLMD function codes

-	ghash function = 65 // GHASH

-)

-

-// queryResult contains the result of a Query function

-// call. Bits are numbered in big endian order so the

-// leftmost bit (the MSB) is at index 0.

-type queryResult struct {

-	bits [2]uint64

-}

-

-// Has reports whether the given functions are present.

-func (q *queryResult) Has(fns ...function) bool {

-	if len(fns) == 0 {

-		panic("no function codes provided")

-	}

-	for _, f := range fns {

-		if !bitIsSet(q.bits[:], uint(f)) {

-			return false

-		}

-	}

-	return true

-}

-

-// facility is a bit index for the named facility.

-type facility uint8

-

-const (

-	// cryptography facilities

-	msa4 facility = 77  // message-security-assist extension 4

-	msa8 facility = 146 // message-security-assist extension 8

-)

-

-// facilityList contains the result of an STFLE call.

-// Bits are numbered in big endian order so the

-// leftmost bit (the MSB) is at index 0.

-type facilityList struct {

-	bits [4]uint64

-}

-

-// Has reports whether the given facilities are present.

-func (s *facilityList) Has(fs ...facility) bool {

-	if len(fs) == 0 {

-		panic("no facility bits provided")

-	}

-	for _, f := range fs {

-		if !bitIsSet(s.bits[:], uint(f)) {

-			return false

-		}

-	}

-	return true

-}

-

-func doinit() {

+func initS390Xbase() {

 	// test HWCAP bit vector

 	has := func(featureMask uint) bool {

 		return hwCap&featureMask == featureMask

@@ -116,44 +37,4 @@ func doinit() {

 	if S390X.HasVX {

 		S390X.HasVXE = has(hwcap_VXE)

 	}

-

-	// We need implementations of stfle, km and so on

-	// to detect cryptographic features.

-	if !haveAsmFunctions() {

-		return

-	}

-

-	// optional cryptographic functions

-	if S390X.HasMSA {

-		aes := []function{aes128, aes192, aes256}

-

-		// cipher message

-		km, kmc := kmQuery(), kmcQuery()

-		S390X.HasAES = km.Has(aes...)

-		S390X.HasAESCBC = kmc.Has(aes...)

-		if S390X.HasSTFLE {

-			facilities := stfle()

-			if facilities.Has(msa4) {

-				kmctr := kmctrQuery()

-				S390X.HasAESCTR = kmctr.Has(aes...)

-			}

-			if facilities.Has(msa8) {

-				kma := kmaQuery()

-				S390X.HasAESGCM = kma.Has(aes...)

-			}

-		}

-

-		// compute message digest

-		kimd := kimdQuery() // intermediate (no padding)

-		klmd := klmdQuery() // last (padding)

-		S390X.HasSHA1 = kimd.Has(sha1) && klmd.Has(sha1)

-		S390X.HasSHA256 = kimd.Has(sha256) && klmd.Has(sha256)

-		S390X.HasSHA512 = kimd.Has(sha512) && klmd.Has(sha512)

-		S390X.HasGHASH = kimd.Has(ghash) // KLMD-GHASH does not exist

-		sha3 := []function{

-			sha3_224, sha3_256, sha3_384, sha3_512,

-			shake128, shake256,

-		}

-		S390X.HasSHA3 = kimd.Has(sha3...) && klmd.Has(sha3...)

-	}

 }

new file mode 100644

@@ -0,0 +1,173 @@

+// Copyright 2020 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 cpu

+

+import (

+	"syscall"

+	"unsafe"

+)

+

+// Minimal copy of functionality from x/sys/unix so the cpu package can call

+// sysctl without depending on x/sys/unix.

+

+const (

+	_CTL_QUERY = -2

+

+	_SYSCTL_VERS_1 = 0x1000000

+)

+

+var _zero uintptr

+

+func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {

+	var _p0 unsafe.Pointer

+	if len(mib) > 0 {

+		_p0 = unsafe.Pointer(&mib[0])

+	} else {

+		_p0 = unsafe.Pointer(&_zero)

+	}

+	_, _, errno := syscall.Syscall6(

+		syscall.SYS___SYSCTL,

+		uintptr(_p0),

+		uintptr(len(mib)),

+		uintptr(unsafe.Pointer(old)),

+		uintptr(unsafe.Pointer(oldlen)),

+		uintptr(unsafe.Pointer(new)),

+		uintptr(newlen))

+	if errno != 0 {

+		return errno

+	}

+	return nil

+}

+

+type sysctlNode struct {

+	Flags          uint32

+	Num            int32

+	Name           [32]int8

+	Ver            uint32

+	__rsvd         uint32

+	Un             [16]byte

+	_sysctl_size   [8]byte

+	_sysctl_func   [8]byte

+	_sysctl_parent [8]byte

+	_sysctl_desc   [8]byte

+}

+

+func sysctlNodes(mib []int32) ([]sysctlNode, error) {

+	var olen uintptr

+

+	// Get a list of all sysctl nodes below the given MIB by performing

+	// a sysctl for the given MIB with CTL_QUERY appended.

+	mib = append(mib, _CTL_QUERY)

+	qnode := sysctlNode{Flags: _SYSCTL_VERS_1}

+	qp := (*byte)(unsafe.Pointer(&qnode))

+	sz := unsafe.Sizeof(qnode)

+	if err := sysctl(mib, nil, &olen, qp, sz); err != nil {

+		return nil, err

+	}

+

+	// Now that we know the size, get the actual nodes.

+	nodes := make([]sysctlNode, olen/sz)

+	np := (*byte)(unsafe.Pointer(&nodes[0]))

+	if err := sysctl(mib, np, &olen, qp, sz); err != nil {

+		return nil, err

+	}

+

+	return nodes, nil

+}

+

+func nametomib(name string) ([]int32, error) {

+	// Split name into components.

+	var parts []string

+	last := 0

+	for i := 0; i < len(name); i++ {

+		if name[i] == '.' {

+			parts = append(parts, name[last:i])

+			last = i + 1

+		}

+	}

+	parts = append(parts, name[last:])

+

+	mib := []int32{}

+	// Discover the nodes and construct the MIB OID.

+	for partno, part := range parts {

+		nodes, err := sysctlNodes(mib)

+		if err != nil {

+			return nil, err

+		}

+		for _, node := range nodes {

+			n := make([]byte, 0)

+			for i := range node.Name {

+				if node.Name[i] != 0 {

+					n = append(n, byte(node.Name[i]))

+				}

+			}

+			if string(n) == part {

+				mib = append(mib, int32(node.Num))

+				break

+			}

+		}

+		if len(mib) != partno+1 {

+			return nil, err

+		}

+	}

+

+	return mib, nil

+}

+

+// aarch64SysctlCPUID is struct aarch64_sysctl_cpu_id from NetBSD's <aarch64/armreg.h>

+type aarch64SysctlCPUID struct {

+	midr      uint64 /* Main ID Register */

+	revidr    uint64 /* Revision ID Register */

+	mpidr     uint64 /* Multiprocessor Affinity Register */

+	aa64dfr0  uint64 /* A64 Debug Feature Register 0 */

+	aa64dfr1  uint64 /* A64 Debug Feature Register 1 */

+	aa64isar0 uint64 /* A64 Instruction Set Attribute Register 0 */

+	aa64isar1 uint64 /* A64 Instruction Set Attribute Register 1 */

+	aa64mmfr0 uint64 /* A64 Memory Model Feature Register 0 */

+	aa64mmfr1 uint64 /* A64 Memory Model Feature Register 1 */

+	aa64mmfr2 uint64 /* A64 Memory Model Feature Register 2 */

+	aa64pfr0  uint64 /* A64 Processor Feature Register 0 */

+	aa64pfr1  uint64 /* A64 Processor Feature Register 1 */

+	aa64zfr0  uint64 /* A64 SVE Feature ID Register 0 */

+	mvfr0     uint32 /* Media and VFP Feature Register 0 */

+	mvfr1     uint32 /* Media and VFP Feature Register 1 */

+	mvfr2     uint32 /* Media and VFP Feature Register 2 */

+	pad       uint32

+	clidr     uint64 /* Cache Level ID Register */

+	ctr       uint64 /* Cache Type Register */

+}

+

+func sysctlCPUID(name string) (*aarch64SysctlCPUID, error) {

+	mib, err := nametomib(name)

+	if err != nil {

+		return nil, err

+	}

+

+	out := aarch64SysctlCPUID{}

+	n := unsafe.Sizeof(out)

+	_, _, errno := syscall.Syscall6(

+		syscall.SYS___SYSCTL,

+		uintptr(unsafe.Pointer(&mib[0])),

+		uintptr(len(mib)),

+		uintptr(unsafe.Pointer(&out)),

+		uintptr(unsafe.Pointer(&n)),

+		uintptr(0),

+		uintptr(0))

+	if errno != 0 {

+		return nil, errno

+	}

+	return &out, nil

+}

+

+func doinit() {

+	cpuid, err := sysctlCPUID("machdep.cpu0.cpu_id")

+	if err != nil {

+		setMinimalFeatures()

+		return

+	}

+	parseARM64SystemRegisters(cpuid.aa64isar0, cpuid.aa64isar1, cpuid.aa64pfr0)

+

+	Initialized = true

+}

@@ -2,7 +2,8 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !linux,arm64

+// +build !linux,!netbsd

+// +build arm64

 package cpu

new file mode 100644

@@ -0,0 +1,12 @@

+// Copyright 2020 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

+// +build mips64 mips64le

+

+package cpu

+

+func archInit() {

+	Initialized = true

+}

@@ -8,10 +8,10 @@ const cacheLineSize = 256

 func initOptions() {

 	options = []option{

-		{Name: "zarch", Feature: &S390X.HasZARCH},

-		{Name: "stfle", Feature: &S390X.HasSTFLE},

-		{Name: "ldisp", Feature: &S390X.HasLDISP},

-		{Name: "eimm", Feature: &S390X.HasEIMM},

+		{Name: "zarch", Feature: &S390X.HasZARCH, Required: true},

+		{Name: "stfle", Feature: &S390X.HasSTFLE, Required: true},

+		{Name: "ldisp", Feature: &S390X.HasLDISP, Required: true},

+		{Name: "eimm", Feature: &S390X.HasEIMM, Required: true},

 		{Name: "dfp", Feature: &S390X.HasDFP},

 		{Name: "etf3eh", Feature: &S390X.HasETF3EH},

 		{Name: "msa", Feature: &S390X.HasMSA},

@@ -28,3 +28,145 @@ func initOptions() {

 		{Name: "vxe", Feature: &S390X.HasVXE},

 	}

 }

+

+// bitIsSet reports whether the bit at index is set. The bit index

+// is in big endian order, so bit index 0 is the leftmost bit.

+func bitIsSet(bits []uint64, index uint) bool {

+	return bits[index/64]&((1<<63)>>(index%64)) != 0

+}

+

+// facility is a bit index for the named facility.

+type facility uint8

+

+const (

+	// mandatory facilities

+	zarch  facility = 1  // z architecture mode is active

+	stflef facility = 7  // store-facility-list-extended

+	ldisp  facility = 18 // long-displacement

+	eimm   facility = 21 // extended-immediate

+

+	// miscellaneous facilities

+	dfp    facility = 42 // decimal-floating-point

+	etf3eh facility = 30 // extended-translation 3 enhancement

+

+	// cryptography facilities

+	msa  facility = 17  // message-security-assist

+	msa3 facility = 76  // message-security-assist extension 3

+	msa4 facility = 77  // message-security-assist extension 4

+	msa5 facility = 57  // message-security-assist extension 5

+	msa8 facility = 146 // message-security-assist extension 8

+	msa9 facility = 155 // message-security-assist extension 9

+

+	// vector facilities

+	vx   facility = 129 // vector facility

+	vxe  facility = 135 // vector-enhancements 1

+	vxe2 facility = 148 // vector-enhancements 2

+)

+

+// facilityList contains the result of an STFLE call.

+// Bits are numbered in big endian order so the

+// leftmost bit (the MSB) is at index 0.

+type facilityList struct {

+	bits [4]uint64

+}

+

+// Has reports whether the given facilities are present.

+func (s *facilityList) Has(fs ...facility) bool {

+	if len(fs) == 0 {

+		panic("no facility bits provided")

+	}

+	for _, f := range fs {

+		if !bitIsSet(s.bits[:], uint(f)) {

+			return false

+		}

+	}

+	return true

+}

+

+// function is the code for the named cryptographic function.

+type function uint8

+

+const (

+	// KM{,A,C,CTR} function codes

+	aes128 function = 18 // AES-128

+	aes192 function = 19 // AES-192

+	aes256 function = 20 // AES-256

+

+	// K{I,L}MD function codes

+	sha1     function = 1  // SHA-1

+	sha256   function = 2  // SHA-256

+	sha512   function = 3  // SHA-512

+	sha3_224 function = 32 // SHA3-224

+	sha3_256 function = 33 // SHA3-256

+	sha3_384 function = 34 // SHA3-384

+	sha3_512 function = 35 // SHA3-512

+	shake128 function = 36 // SHAKE-128

+	shake256 function = 37 // SHAKE-256

+

+	// KLMD function codes

+	ghash function = 65 // GHASH

+)

+

+// queryResult contains the result of a Query function

+// call. Bits are numbered in big endian order so the

+// leftmost bit (the MSB) is at index 0.

+type queryResult struct {

+	bits [2]uint64

+}

+

+// Has reports whether the given functions are present.

+func (q *queryResult) Has(fns ...function) bool {

+	if len(fns) == 0 {

+		panic("no function codes provided")

+	}

+	for _, f := range fns {

+		if !bitIsSet(q.bits[:], uint(f)) {

+			return false

+		}

+	}

+	return true

+}

+

+func doinit() {

+	initS390Xbase()

+

+	// We need implementations of stfle, km and so on

+	// to detect cryptographic features.

+	if !haveAsmFunctions() {

+		return

+	}

+

+	// optional cryptographic functions

+	if S390X.HasMSA {

+		aes := []function{aes128, aes192, aes256}

+

+		// cipher message

+		km, kmc := kmQuery(), kmcQuery()

+		S390X.HasAES = km.Has(aes...)

+		S390X.HasAESCBC = kmc.Has(aes...)

+		if S390X.HasSTFLE {

+			facilities := stfle()

+			if facilities.Has(msa4) {

+				kmctr := kmctrQuery()

+				S390X.HasAESCTR = kmctr.Has(aes...)

+			}

+			if facilities.Has(msa8) {

+				kma := kmaQuery()

+				S390X.HasAESGCM = kma.Has(aes...)

+			}

+		}

+

+		// compute message digest

+		kimd := kimdQuery() // intermediate (no padding)

+		klmd := klmdQuery() // last (padding)

+		S390X.HasSHA1 = kimd.Has(sha1) && klmd.Has(sha1)

+		S390X.HasSHA256 = kimd.Has(sha256) && klmd.Has(sha256)

+		S390X.HasSHA512 = kimd.Has(sha512) && klmd.Has(sha512)

+		S390X.HasGHASH = kimd.Has(ghash) // KLMD-GHASH does not exist

+		sha3 := []function{

+			sha3_224, sha3_256, sha3_384, sha3_512,

+			shake128, shake256,

+		}

+		S390X.HasSHA3 = kimd.Has(sha3...) && klmd.Has(sha3...)

+	}

+}

@@ -2,7 +2,7 @@

 // Use of this source code is governed by a BSD-style

 // license that can be found in the LICENSE file.

-// +build !gccgo

+// +build gc

 #include "textflag.h"

@@ -3,7 +3,7 @@

 // license that can be found in the LICENSE file.

 // +build 386 amd64 amd64p32

-// +build !gccgo

+// +build gc

 #include "textflag.h"

new file mode 100644

@@ -0,0 +1,10 @@

+// Copyright 2020 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 cpu

+

+func archInit() {

+	doinit()

+	Initialized = true

+}

new file mode 100644

@@ -0,0 +1,25 @@

+// Copyright 2020 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 cpu

+

+func initS390Xbase() {

+	// get the facilities list

+	facilities := stfle()

+

+	// mandatory

+	S390X.HasZARCH = facilities.Has(zarch)

+	S390X.HasSTFLE = facilities.Has(stflef)

+	S390X.HasLDISP = facilities.Has(ldisp)

+	S390X.HasEIMM = facilities.Has(eimm)

+

+	// optional

+	S390X.HasETF3EH = facilities.Has(etf3eh)

+	S390X.HasDFP = facilities.Has(dfp)

+	S390X.HasMSA = facilities.Has(msa)

+	S390X.HasVX = facilities.Has(vx)

+	if S390X.HasVX {

+		S390X.HasVXE = facilities.Has(vxe)

+	}

+}

@@ -7,7 +7,7 @@

 // (See golang.org/issue/32102)

 // +build aix,ppc64

-// +build !gccgo

+// +build gc

 package cpu

new file mode 100644

@@ -0,0 +1,102 @@

+// Copyright 2020 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 execabs is a drop-in replacement for os/exec

+// that requires PATH lookups to find absolute paths.

+// That is, execabs.Command("cmd") runs the same PATH lookup

+// as exec.Command("cmd"), but if the result is a path

+// which is relative, the Run and Start methods will report

+// an error instead of running the executable.

+//

+// See https://blog.golang.org/path-security for more information

+// about when it may be necessary or appropriate to use this package.

+package execabs

+

+import (

+	"context"

+	"fmt"

+	"os/exec"

+	"path/filepath"

+	"reflect"

+	"unsafe"

+)

+

+// ErrNotFound is the error resulting if a path search failed to find an executable file.

+// It is an alias for exec.ErrNotFound.

+var ErrNotFound = exec.ErrNotFound

+

+// Cmd represents an external command being prepared or run.

+// It is an alias for exec.Cmd.

+type Cmd = exec.Cmd

+

+// Error is returned by LookPath when it fails to classify a file as an executable.

+// It is an alias for exec.Error.

+type Error = exec.Error

+

+// An ExitError reports an unsuccessful exit by a command.

+// It is an alias for exec.ExitError.

+type ExitError = exec.ExitError

+

+func relError(file, path string) error {

+	return fmt.Errorf("%s resolves to executable in current directory (.%c%s)", file, filepath.Separator, path)

+}

+

+// LookPath searches for an executable named file in the directories

+// named by the PATH environment variable. If file contains a slash,

+// it is tried directly and the PATH is not consulted. The result will be

+// an absolute path.

+//

+// LookPath differs from exec.LookPath in its handling of PATH lookups,

+// which are used for file names without slashes. If exec.LookPath's

+// PATH lookup would have returned an executable from the current directory,

+// LookPath instead returns an error.

+func LookPath(file string) (string, error) {

+	path, err := exec.LookPath(file)

+	if err != nil {

+		return "", err

+	}

+	if filepath.Base(file) == file && !filepath.IsAbs(path) {

+		return "", relError(file, path)

+	}

+	return path, nil

+}