openclaw/tqma6-yocto-mirror
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete Yocto mirror with license table for TQMa6UL (2038-compliance)

Browse Source 
- 264 license table entries with exact download URLs (224/264 resolved)
- Complete sources/ directory with all BitBake recipes
- Build configuration: tqma6ul-multi-mba6ulx, spaetzle (musl)
- Full traceability for Softwarefreigabeantrag
- GCC 13.4.0, Linux 6.6.102, U-Boot 2023.04, musl 1.2.4
- License distribution: GPL-2.0 (24), MIT (23), GPL-2.0+ (18), BSD-3 (16)
This commit is contained in:
Siggi (OpenClaw Agent)
2026-03-01 20:58:18 +00:00
commit 16accb6b24
15086 changed files with 1292356 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
sources/poky/meta/recipes-devtools/go/go-1.22.12.inc Normal file
View File

@@ -0,0 +1,21 @@
require go-common.inc
FILESEXTRAPATHS:prepend := "${FILE_DIRNAME}/go:"
LIC_FILES_CHKSUM = "file://LICENSE;md5=5d4950ecb7b26d2c5e4e7b4e0dd74707"
SRC_URI += "\
file://0001-cmd-go-make-content-based-hash-generation-less-pedan.patch \
file://0002-cmd-go-Allow-GOTOOLDIR-to-be-overridden-in-the-envir.patch \
file://0003-ld-add-soname-to-shareable-objects.patch \
file://0004-make.bash-override-CC-when-building-dist-and-go_boot.patch \
file://0005-cmd-dist-separate-host-and-target-builds.patch \
file://0006-cmd-go-make-GOROOT-precious-by-default.patch \
file://0007-exec.go-filter-out-build-specific-paths-from-linker-.patch \
file://0008-src-cmd-dist-buildgo.go-do-not-hardcode-host-compile.patch \
file://0009-go-Filter-build-paths-on-staticly-linked-arches.patch \
file://CVE-2025-22870.patch \
file://CVE-2025-22871.patch \
file://CVE-2025-4673.patch \
"
SRC_URI[main.sha256sum] = "012a7e1f37f362c0918c1dfa3334458ac2da1628c4b9cf4d9ca02db986e17d71"

51
sources/poky/meta/recipes-devtools/go/go-binary-native_1.22.12.bb Normal file
View File

@@ -0,0 +1,51 @@
# This recipe is for bootstrapping our go-cross from a prebuilt binary of Go from golang.org.
SUMMARY = "Go programming language compiler (upstream binary for bootstrap)"
HOMEPAGE = " http://golang.org/"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://LICENSE;md5=5d4950ecb7b26d2c5e4e7b4e0dd74707"
PROVIDES = "go-native"
# Checksums available at https://go.dev/dl/
SRC_URI = "https://dl.google.com/go/go${PV}.${BUILD_GOOS}-${BUILD_GOARCH}.tar.gz;name=go_${BUILD_GOTUPLE}"
SRC_URI[go_linux_amd64.sha256sum] = "4fa4f869b0f7fc6bb1eb2660e74657fbf04cdd290b5aef905585c86051b34d43"
SRC_URI[go_linux_arm64.sha256sum] = "fd017e647ec28525e86ae8203236e0653242722a7436929b1f775744e26278e7"
SRC_URI[go_linux_ppc64le.sha256sum] = "9573d30003b0796717a99d9e2e96c48fddd4fc0f29d840f212c503b03d7de112"
UPSTREAM_CHECK_URI = "https://golang.org/dl/"
UPSTREAM_CHECK_REGEX = "go(?P<pver>\d+(\.\d+)+)\.linux"
CVE_PRODUCT = "golang:go"
CVE_STATUS[CVE-2024-3566] = "not-applicable-platform: Issue only applies on Windows"
S = "${WORKDIR}/go"
inherit goarch native
do_compile() {
:
}
make_wrapper() {
rm -f ${D}${bindir}/$1
cat <<END >${D}${bindir}/$1
#!/bin/bash
here=\`dirname \$0\`
export GOROOT="${GOROOT:-\`readlink -f \$here/../lib/go\`}"
\$here/../lib/go/bin/$1 "\$@"
END
chmod +x ${D}${bindir}/$1
}
do_install() {
find ${S} -depth -type d -name testdata -exec rm -rf {} +
install -d ${D}${bindir} ${D}${libdir}/go
cp --preserve=mode,timestamps -R ${S}/ ${D}${libdir}/
for f in ${S}/bin/*
do
make_wrapper `basename $f`
done
}

48
sources/poky/meta/recipes-devtools/go/go-common.inc Normal file
View File

@@ -0,0 +1,48 @@
SUMMARY = "Go programming language compiler"
DESCRIPTION = " The Go programming language is an open source project to make \
programmers more productive. Go is expressive, concise, clean, and\
efficient. Its concurrency mechanisms make it easy to write programs\
that get the most out of multicore and networked machines, while its\
novel type system enables flexible and modular program construction.\
Go compiles quickly to machine code yet has the convenience of\
garbage collection and the power of run-time reflection. It's a\
fast, statically typed, compiled language that feels like a\
dynamically typed, interpreted language."
HOMEPAGE = " http://golang.org/"
LICENSE = "BSD-3-Clause"
inherit goarch
SRC_URI = "https://golang.org/dl/go${PV}.src.tar.gz;name=main"
S = "${WORKDIR}/go"
B = "${S}"
UPSTREAM_CHECK_REGEX = "(?P<pver>\d+(\.\d+)+)\.src\.tar"
# all recipe variants are created from the same product
CVE_PRODUCT = "golang:go"
CVE_STATUS[CVE-2024-3566] = "not-applicable-platform: Issue only applies on Windows"
INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
SSTATE_SCAN_CMD = "true"
export GOROOT_OVERRIDE = "1"
export GOTMPDIR ?= "${WORKDIR}/build-tmp"
GOTMPDIR[vardepvalue] = ""
export CGO_ENABLED = "1"
export GOHOSTOS ?= "${BUILD_GOOS}"
export GOHOSTARCH ?= "${BUILD_GOARCH}"
export GOROOT_BOOTSTRAP ?= "${STAGING_LIBDIR_NATIVE}/go"
export GOOS ?= "${TARGET_GOOS}"
export GOARCH ?= "${TARGET_GOARCH}"
export GOARM ?= "${TARGET_GOARM}"
export GO386 ?= "${TARGET_GO386}"
export GOMIPS ?= "${TARGET_GOMIPS}"
export GOROOT_FINAL ?= "${libdir}/go"
export GODEBUG = "gocachehash=1"
do_compile:prepend() {
BUILD_CC=${BUILD_CC}
}

61
sources/poky/meta/recipes-devtools/go/go-cross-canadian.inc Normal file
View File

@@ -0,0 +1,61 @@
inherit cross-canadian
DEPENDS = "go-native virtual/${HOST_PREFIX}go virtual/nativesdk-${HOST_PREFIX}go-runtime \
virtual/${HOST_PREFIX}gcc virtual/nativesdk-libc \
virtual/nativesdk-${HOST_PREFIX}compilerlibs"
PN = "go-cross-canadian-${TRANSLATED_TARGET_ARCH}"
# it uses gcc on build machine during go-cross-canadian bootstrap, but
# the gcc version may be old and not support option '-fmacro-prefix-map'
# which is one of default values of DEBUG_PREFIX_MAP
DEBUG_PREFIX_MAP = "-fdebug-prefix-map=${WORKDIR}=${TARGET_DBGSRC_DIR} \
-fdebug-prefix-map=${STAGING_DIR_HOST}= \
-fdebug-prefix-map=${STAGING_DIR_NATIVE}= \
"
export GOTOOLDIR_BOOTSTRAP = "${STAGING_LIBDIR_NATIVE}/${HOST_SYS}/go/pkg/tool/${BUILD_GOTUPLE}"
export CGO_CFLAGS = "${CFLAGS}"
export CGO_LDFLAGS = "${LDFLAGS}"
export GO_LDFLAGS = '-extld ${HOST_PREFIX}gcc -extldflags "--sysroot=${STAGING_DIR_HOST} ${SECURITY_NOPIE_CFLAGS} ${HOST_CC_ARCH} ${LDFLAGS}"'
do_configure[noexec] = "1"
do_compile() {
export CC_FOR_${HOST_GOTUPLE}="${HOST_PREFIX}gcc --sysroot=${STAGING_DIR_HOST} ${SECURITY_NOPIE_CFLAGS}"
export CXX_FOR_${HOST_GOTUPLE}="${HOST_PREFIX}gxx --sysroot=${STAGING_DIR_HOST} ${SECURITY_NOPIE_CFLAGS}"
cd src
./make.bash --target-only --no-banner
cd ${B}
}
do_compile[cleandirs] += "${GOTMPDIR} ${B}/bin ${B}/pkg"
make_wrapper() {
rm -f ${D}${bindir}/$2
cat <<END >${D}${bindir}/$2
#!/bin/sh
here=\`dirname \$0\`
native_goroot=\`readlink -f \$here/../../lib/${TARGET_SYS}/go\`
export GOARCH="${TARGET_GOARCH}"
export GOOS="${TARGET_GOOS}"
test -n "\$GOARM" || export GOARM="${TARGET_GOARM}"
test -n "\$GO386" || export GO386="${TARGET_GO386}"
test -n "\$GOMIPS" || export GOMIPS="${TARGET_GOMIPS}"
export GOTOOLDIR="\$native_goroot/pkg/tool/${HOST_GOTUPLE}"
test -n "\$GOROOT" || export GOROOT="\$OECORE_TARGET_SYSROOT/${target_libdir}/go"
\$here/../../lib/${TARGET_SYS}/go/bin/$1 "\$@"
END
chmod +x ${D}${bindir}/$2
}
do_install() {
install -d ${D}${libdir}/go/pkg/tool
cp --preserve=mode,timestamps -R ${B}/pkg/tool/${HOST_GOTUPLE} ${D}${libdir}/go/pkg/tool/
install -d ${D}${bindir} ${D}${libdir}/go/bin
for f in ${B}/${GO_BUILD_BINDIR}/*
do
base=`basename $f`
install -m755 $f ${D}${libdir}/go/bin
make_wrapper $base ${TARGET_PREFIX}$base
done
}

2
sources/poky/meta/recipes-devtools/go/go-cross-canadian_1.22.12.bb Normal file
View File

@@ -0,0 +1,2 @@
require go-cross-canadian.inc
require go-${PV}.inc

52
sources/poky/meta/recipes-devtools/go/go-cross.inc Normal file
View File

@@ -0,0 +1,52 @@
inherit cross
PROVIDES = "virtual/${TUNE_PKGARCH}-go"
DEPENDS = "go-native"
PN = "go-cross-${TUNE_PKGARCH}"
export GOCACHE = "${B}/.cache"
CC = "${@d.getVar('BUILD_CC').strip()}"
do_configure[noexec] = "1"
do_compile() {
export CC_FOR_${TARGET_GOTUPLE}="${TARGET_PREFIX}gcc ${TARGET_CC_ARCH} --sysroot=${STAGING_DIR_TARGET}"
export CXX_FOR_${TARGET_GOTUPLE}="${TARGET_PREFIX}g++ ${TARGET_CC_ARCH} --sysroot=${STAGING_DIR_TARGET}"
cd src
./make.bash --host-only --no-banner
cd ${B}
}
do_compile[cleandirs] += "${GOTMPDIR} ${B}/bin ${B}/pkg"
make_wrapper() {
rm -f ${D}${bindir}/$2
cat <<END >${D}${bindir}/$2
#!/bin/bash
here=\`dirname \$0\`
export GOARCH="${TARGET_GOARCH}"
export GOOS="${TARGET_GOOS}"
export GOARM="\${GOARM:-${TARGET_GOARM}}"
export GO386="\${GO386:-${TARGET_GO386}}"
export GOMIPS="\${GOMIPS:-${TARGET_GOMIPS}}"
\$here/../../lib/${CROSS_TARGET_SYS_DIR}/go/bin/$1 "\$@"
END
chmod +x ${D}${bindir}/$2
}
do_install() {
install -d ${D}${libdir}/go
cp --preserve=mode,timestamps -R ${B}/pkg ${D}${libdir}/go/
install -d ${D}${libdir}/go/src
(cd ${S}/src; for d in *; do \
[ ! -d $d ] || cp --preserve=mode,timestamps -R ${S}/src/$d ${D}${libdir}/go/src/; \
done)
find ${D}${libdir}/go/src -depth -type d -name testdata -exec rm -rf {} \;
install -d ${D}${bindir} ${D}${libdir}/go/bin
for f in ${B}/bin/*
do
base=`basename $f`
install -m755 $f ${D}${libdir}/go/bin
make_wrapper $base ${TARGET_PREFIX}$base
done
}

2
sources/poky/meta/recipes-devtools/go/go-cross_1.22.12.bb Normal file
View File

@@ -0,0 +1,2 @@
require go-cross.inc
require go-${PV}.inc

44
sources/poky/meta/recipes-devtools/go/go-crosssdk.inc Normal file
View File

@@ -0,0 +1,44 @@
inherit crosssdk
DEPENDS = "go-native virtual/${TARGET_PREFIX}gcc virtual/nativesdk-${TARGET_PREFIX}compilerlibs virtual/${TARGET_PREFIX}binutils"
PN = "go-crosssdk-${SDK_SYS}"
PROVIDES = "virtual/${TARGET_PREFIX}go"
export GOCACHE = "${B}/.cache"
do_configure[noexec] = "1"
do_compile() {
export CC_FOR_${TARGET_GOTUPLE}="${TARGET_PREFIX}gcc ${TARGET_CC_ARCH} --sysroot=${STAGING_DIR_TARGET}${SDKPATHNATIVE}"
export CXX_FOR_${TARGET_GOTUPLE}="${TARGET_PREFIX}g++ ${TARGET_CC_ARCH} --sysroot=${STAGING_DIR_TARGET}${SDKPATHNATIVE}"
cd src
./make.bash --host-only --no-banner
cd ${B}
}
do_compile[cleandirs] += "${GOTMPDIR} ${B}/bin ${B}/pkg"
make_wrapper() {
rm -f ${D}${bindir}/$2
cat <<END >${D}${bindir}/$2
#!/bin/bash
here=\`dirname \$0\`
export GOARCH="${TARGET_GOARCH}"
export GOOS="${TARGET_GOOS}"
\$here/../../lib/${CROSS_TARGET_SYS_DIR}/go/bin/$1 "\$@"
END
chmod +x ${D}${bindir}/$2
}
do_install() {
install -d ${D}${libdir}/go
install -d ${D}${libdir}/go/bin
install -d ${D}${libdir}/go/pkg/tool
install -d ${D}${bindir}
cp --preserve=mode,timestamps -R ${S}/pkg/tool/${BUILD_GOTUPLE} ${D}${libdir}/go/pkg/tool/
for f in ${B}/bin/*
do
base=`basename $f`
install -m755 $f ${D}${libdir}/go/bin
make_wrapper $base ${TARGET_PREFIX}$base
done
}

2
sources/poky/meta/recipes-devtools/go/go-crosssdk_1.22.12.bb Normal file
View File

@@ -0,0 +1,2 @@
require go-crosssdk.inc
require go-${PV}.inc

94
sources/poky/meta/recipes-devtools/go/go-runtime.inc Normal file
View File

@@ -0,0 +1,94 @@
DEPENDS = "virtual/${TUNE_PKGARCH}-go go-native"
DEPENDS:class-nativesdk = "virtual/${TARGET_PREFIX}go"
PROVIDES = "virtual/${TARGET_PREFIX}go-runtime"
DEBUG_PREFIX_MAP = "\
-fdebug-prefix-map=${STAGING_DIR_HOST}= \
-fdebug-prefix-map=${STAGING_DIR_NATIVE}= \
"
export CGO_CFLAGS = "${CFLAGS}"
export CGO_CPPFLAGS = "${CPPFLAGS}"
export CGO_CXXFLAGS = "${CXXFLAGS}"
# Filter out -fdebug-prefix-map options as they clash with the GO's build system
export CGO_LDFLAGS = "${@ ' '.join(filter(lambda f: not f.startswith('-fdebug-prefix-map'), d.getVar('LDFLAGS').split())) }"
export GOCACHE = "${B}/.cache"
GO_EXTLDFLAGS ?= "${HOST_CC_ARCH}${TOOLCHAIN_OPTIONS} ${LDFLAGS}"
GO_SHLIB_LDFLAGS ?= '-ldflags="-extldflags '${GO_EXTLDFLAGS}'"'
do_configure() {
:
}
do_configure:libc-musl() {
rm -f ${S}/src/runtime/race/*.syso
}
do_compile() {
export CC_FOR_${TARGET_GOTUPLE}="${CC}"
export CXX_FOR_${TARGET_GOTUPLE}="${CXX}"
cd src
./make.bash --target-only --no-banner std
if [ -n "${GO_DYNLINK}" ]; then
export GOTOOLDIR="${B}/pkg/tool/native_native"
CC="$CC_FOR_${TARGET_GOTUPLE}" GOARCH="${TARGET_GOARCH}" GOOS="${TARGET_GOOS}" GOROOT=${B} \
$GOTOOLDIR/go_bootstrap install -linkshared -buildmode=shared ${GO_SHLIB_LDFLAGS} std
fi
cd ${B}
}
do_compile[cleandirs] += "${GOTMPDIR} ${B}/bin ${B}/pkg"
do_install() {
install -d ${D}${libdir}/go/src
cp --preserve=mode,timestamps -R ${B}/pkg ${D}${libdir}/go/
if [ "${BUILD_GOTUPLE}" != "${TARGET_GOTUPLE}" ]; then
rm -rf ${D}${libdir}/go/pkg/${BUILD_GOTUPLE}
rm -rf ${D}${libdir}/go/pkg/obj/${BUILD_GOTUPLE}
fi
rm -rf ${D}${libdir}/go/pkg/tool
rm -rf ${D}${libdir}/go/pkg/obj
rm -rf ${D}${libdir}/go/pkg/bootstrap
# the cmd directory is built for the native arch so if BUILD == TARGET
rm -rf ${D}${libdir}/go/pkg/${BUILD_GOTUPLE}/cmd
find src -mindepth 1 -maxdepth 1 -type d | while read srcdir; do
cp --preserve=mode,timestamps -R $srcdir ${D}${libdir}/go/src/
done
find ${D}${libdir}/go/src -depth -type d -name testdata -exec rm -rf {} \;
rm -f ${D}${libdir}/go/src/cmd/dist/dist
rm -f ${D}${libdir}/go/src/cmd/cgo/zdefaultcc.go
rm -f ${D}${libdir}/go/src/cmd/go/internal/cfg/zdefaultcc.go
}
ALLOW_EMPTY:${PN} = "1"
FILES:${PN} = "${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*${SOLIBSDEV}"
FILES:${PN}-dev = "${libdir}/go/src ${libdir}/go/pkg/include \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*/*/*.shlibname \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*/*.a \
${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink/*/*/*/*/*/*/*.a \
"
FILES:${PN}-staticdev = "${libdir}/go/pkg/${TARGET_GOTUPLE}"
# Go sources include some scripts and pre-built binaries for
# multiple architectures. The static .a files for dynamically-linked
# runtime are also required in -dev.
INSANE_SKIP:${PN}-dev = "staticdev file-rdeps arch"
INHIBIT_PACKAGE_STRIP = "1"
INHIBIT_PACKAGE_DEBUG_SPLIT = "1"
INHIBIT_SYSROOT_STRIP = "1"
BBCLASSEXTEND = "nativesdk"

3
sources/poky/meta/recipes-devtools/go/go-runtime_1.22.12.bb Normal file
View File

@@ -0,0 +1,3 @@
require go-${PV}.inc
require go-runtime.inc

53
sources/poky/meta/recipes-devtools/go/go-target.inc Normal file
View File

@@ -0,0 +1,53 @@
DEPENDS = "virtual/${TUNE_PKGARCH}-go go-native"
DEPENDS:class-nativesdk = "virtual/${TARGET_PREFIX}go go-native"
DEBUG_PREFIX_MAP = "\
-fdebug-prefix-map=${STAGING_DIR_HOST}= \
-fdebug-prefix-map=${STAGING_DIR_NATIVE}= \
"
export CGO_CFLAGS = "${CFLAGS}"
export CGO_CPPFLAGS = "${CPPFLAGS}"
export CGO_CXXFLAGS = "${CXXFLAGS}"
# Filter out -fdebug-prefix-map options as they clash with the GO's build system
export CGO_LDFLAGS = "${@ ' '.join(filter(lambda f: not f.startswith('-fdebug-prefix-map'), d.getVar('LDFLAGS').split())) }"
export GOCACHE = "${B}/.cache"
export GO_LDFLAGS = ""
export GOBUILDFLAGS = "-gcflags=-trimpath=$GOPATH -asmflags=-trimpath=$GOPATH -trimpath"
CC:append:class-nativesdk = " ${SECURITY_NOPIE_CFLAGS}"
do_configure[noexec] = "1"
do_compile() {
export CC_FOR_${TARGET_GOOS}_${TARGET_GOARCH}="${CC}"
export CXX_FOR_${TARGET_GOOS}_${TARGET_GOARCH}="${CXX}"
cd src
./make.bash --target-only --no-banner
cd ${B}
}
do_compile[cleandirs] += "${GOTMPDIR} ${B}/bin ${B}/pkg"
do_install() {
install -d ${D}${libdir}/go/pkg/tool
cp --preserve=mode,timestamps -R ${B}/pkg/tool/${TARGET_GOTUPLE} ${D}${libdir}/go/pkg/tool/
install -d ${D}${libdir}/go/src
cp --preserve=mode,timestamps -R ${S}/src/cmd ${D}${libdir}/go/src/
find ${D}${libdir}/go/src -depth -type d -name testdata -exec rm -rf {} \;
install -d ${D}${libdir}/go/bin
install -d ${D}${bindir}
for f in ${B}/${GO_BUILD_BINDIR}/*; do
name=`basename $f`
install -m 0755 $f ${D}${libdir}/go/bin/
ln -sf ../${baselib}/go/bin/$name ${D}${bindir}/
done
rm -rf ${D}${libdir}/go/src
}
PACKAGES = "${PN} ${PN}-dev"
FILES:${PN} = "${libdir}/go/bin ${libdir}/go/pkg/tool/${TARGET_GOTUPLE} ${bindir}"
RDEPENDS:${PN} = "go-runtime"
INSANE_SKIP:${PN} = "ldflags"
BBCLASSEXTEND = "nativesdk"

165
sources/poky/meta/recipes-devtools/go/go/0001-cmd-go-make-content-based-hash-generation-less-pedan.patch Normal file
View File

@@ -0,0 +1,165 @@
From 9b3ebef0356594a447906f00fe80584952c08289 Mon Sep 17 00:00:00 2001
From: Khem Raj <raj.khem@gmail.com>
Date: Mon, 28 Mar 2022 10:59:03 -0700
Subject: [PATCH] cmd/go: make content-based hash generation less pedantic
Go 1.10's build tool now uses content-based hashes to
determine when something should be built or re-built.
This same mechanism is used to maintain a built-artifact
cache for speeding up builds.
However, the hashes it generates include information that
doesn't work well with OE, nor with using a shared runtime
library.
First, it embeds path names to source files, unless
building within GOROOT. This prevents the building
of a package in GOPATH for later staging into GOROOT.
This patch adds support for the environment variable
GOPATH_OMIT_IN_ACTIONID. If present, path name
embedding is disabled.
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alex Kube <alexander.j.kube@gmail.com>
Signed-off-by: Matt Madison <matt@madison.systems>
Signed-off-by: Khem Raj <raj.khem@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/go/internal/envcmd/env.go | 2 +-
src/cmd/go/internal/work/exec.go | 44 ++++++++++++++++++++++++-------
2 files changed, 36 insertions(+), 10 deletions(-)
diff --git a/src/cmd/go/internal/envcmd/env.go b/src/cmd/go/internal/envcmd/env.go
index c7c2e83..4a90d9d 100644
--- a/src/cmd/go/internal/envcmd/env.go
+++ b/src/cmd/go/internal/envcmd/env.go
@@ -189,7 +189,7 @@ func ExtraEnvVarsCostly() []cfg.EnvVar {
}
}()
- cppflags, cflags, cxxflags, fflags, ldflags, err := b.CFlags(&load.Package{})
+ cppflags, cflags, cxxflags, fflags, ldflags, err := b.CFlags(&load.Package{}, false)
if err != nil {
// Should not happen - b.CFlags was given an empty package.
fmt.Fprintf(os.Stderr, "go: invalid cflags: %v\n", err)
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index e05471b..9724cd0 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -232,6 +232,8 @@ func (b *Builder) Do(ctx context.Context, root *Action) {
writeActionGraph()
}
+var omitGopath = os.Getenv("GOPATH_OMIT_IN_ACTIONID") != ""
+
// buildActionID computes the action ID for a build action.
func (b *Builder) buildActionID(a *Action) cache.ActionID {
p := a.Package
@@ -253,7 +255,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
if p.Module != nil {
fmt.Fprintf(h, "module %s@%s\n", p.Module.Path, p.Module.Version)
}
- } else if p.Goroot {
+ } else if p.Goroot || omitGopath {
// The Go compiler always hides the exact value of $GOROOT
// when building things in GOROOT.
//
@@ -285,9 +287,9 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
}
if len(p.CgoFiles)+len(p.SwigFiles)+len(p.SwigCXXFiles) > 0 {
fmt.Fprintf(h, "cgo %q\n", b.toolID("cgo"))
- cppflags, cflags, cxxflags, fflags, ldflags, _ := b.CFlags(p)
+ cppflags, cflags, cxxflags, fflags, ldflags, _ := b.CFlags(p, true)
- ccExe := b.ccExe()
+ ccExe := filterCompilerFlags(b.ccExe(), true)
fmt.Fprintf(h, "CC=%q %q %q %q\n", ccExe, cppflags, cflags, ldflags)
// Include the C compiler tool ID so that if the C
// compiler changes we rebuild the package.
@@ -295,14 +297,14 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
fmt.Fprintf(h, "CC ID=%q\n", ccID)
}
if len(p.CXXFiles)+len(p.SwigCXXFiles) > 0 {
- cxxExe := b.cxxExe()
+ cxxExe := filterCompilerFlags(b.cxxExe(), true)
fmt.Fprintf(h, "CXX=%q %q\n", cxxExe, cxxflags)
if cxxID, _, err := b.gccToolID(cxxExe[0], "c++"); err == nil {
fmt.Fprintf(h, "CXX ID=%q\n", cxxID)
}
}
if len(p.FFiles) > 0 {
- fcExe := b.fcExe()
+ fcExe := filterCompilerFlags(b.fcExe(), true)
fmt.Fprintf(h, "FC=%q %q\n", fcExe, fflags)
if fcID, _, err := b.gccToolID(fcExe[0], "f95"); err == nil {
fmt.Fprintf(h, "FC ID=%q\n", fcID)
@@ -319,7 +321,7 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID {
}
}
if p.Internal.BuildInfo != nil {
- fmt.Fprintf(h, "modinfo %q\n", p.Internal.BuildInfo.String())
+ //fmt.Fprintf(h, "modinfo %q\n", p.Internal.BuildInfo.String())
}
// Configuration specific to compiler toolchain.
@@ -2679,8 +2681,25 @@ func envList(key, def string) []string {
return args
}
+var filterFlags = os.Getenv("CGO_PEDANTIC") == ""
+
+func filterCompilerFlags(flags []string, keepfirst bool) []string {
+ var newflags []string
+ var realkeepfirst bool = keepfirst
+ if !filterFlags {
+ return flags
+ }
+ for _, flag := range flags {
+ if strings.HasPrefix(flag, "-m") || realkeepfirst {
+ newflags = append(newflags, flag)
+ realkeepfirst = false
+ }
+ }
+ return newflags
+}
+
// CFlags returns the flags to use when invoking the C, C++ or Fortran compilers, or cgo.
-func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, ldflags []string, err error) {
+func (b *Builder) CFlags(p *load.Package, filtered bool) (cppflags, cflags, cxxflags, fflags, ldflags []string, err error) {
if cppflags, err = buildFlags("CPPFLAGS", "", p.CgoCPPFLAGS, checkCompilerFlags); err != nil {
return
}
@@ -2696,6 +2715,13 @@ func (b *Builder) CFlags(p *load.Package) (cppflags, cflags, cxxflags, fflags, l
if ldflags, err = buildFlags("LDFLAGS", defaultCFlags, p.CgoLDFLAGS, checkLinkerFlags); err != nil {
return
}
+ if filtered {
+ cppflags = filterCompilerFlags(cppflags, false)
+ cflags = filterCompilerFlags(cflags, false)
+ cxxflags = filterCompilerFlags(cxxflags, false)
+ fflags = filterCompilerFlags(fflags, false)
+ ldflags = filterCompilerFlags(ldflags, false)
+ }
return
}
@@ -2713,7 +2739,7 @@ func (b *Builder) cgo(a *Action, cgoExe, objdir string, pcCFLAGS, pcLDFLAGS, cgo
p := a.Package
sh := b.Shell(a)
- cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, cgoFFLAGS, cgoLDFLAGS, err := b.CFlags(p)
+ cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, cgoFFLAGS, cgoLDFLAGS, err := b.CFlags(p, false)
if err != nil {
return nil, nil, err
}
@@ -3268,7 +3294,7 @@ func (b *Builder) swigOne(a *Action, file, objdir string, pcCFLAGS []string, cxx
p := a.Package
sh := b.Shell(a)
- cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, _, _, err := b.CFlags(p)
+ cgoCPPFLAGS, cgoCFLAGS, cgoCXXFLAGS, _, _, err := b.CFlags(p, false)
if err != nil {
return "", "", err
}

52
sources/poky/meta/recipes-devtools/go/go/0002-cmd-go-Allow-GOTOOLDIR-to-be-overridden-in-the-envir.patch Normal file
View File

@@ -0,0 +1,52 @@
From 687ff9d17f756145f9a58413070cccbd488d1ea2 Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:15:37 +0430
Subject: [PATCH] cmd/go: Allow GOTOOLDIR to be overridden in the environment
to allow for split host/target build roots
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/dist/build.go | 4 +++-
src/cmd/go/internal/cfg/cfg.go | 6 +++++-
2 files changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 32e59b4..06ee4de 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -259,7 +259,9 @@ func xinit() {
}
xatexit(rmworkdir)
- tooldir = pathf("%s/pkg/tool/%s_%s", goroot, gohostos, gohostarch)
+ if tooldir = os.Getenv("GOTOOLDIR"); tooldir == "" {
+ tooldir = pathf("%s/pkg/tool/%s_%s", goroot, gohostos, gohostarch)
+ }
goversion := findgoversion()
isRelease = strings.HasPrefix(goversion, "release.") || strings.HasPrefix(goversion, "go")
diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index a8daa2d..393ada3 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -230,7 +230,11 @@ func SetGOROOT(goroot string, isTestGo bool) {
// This matches the initialization of ToolDir in go/build, except for
// using ctxt.GOROOT and the installed GOOS and GOARCH rather than the
// GOROOT, GOOS, and GOARCH reported by the runtime package.
- build.ToolDir = filepath.Join(GOROOTpkg, "tool", installedGOOS+"_"+installedGOARCH)
+ if s := os.Getenv("GOTOOLDIR"); s != "" {
+ build.ToolDir = filepath.Clean(s)
+ } else {
+ build.ToolDir = filepath.Join(GOROOTpkg, "tool", installedGOOS+"_"+installedGOARCH)
+ }
}
}
}

48
sources/poky/meta/recipes-devtools/go/go/0003-ld-add-soname-to-shareable-objects.patch Normal file
View File

@@ -0,0 +1,48 @@
From 01fe178b292db12d811811ff2d8d56b225e4b5e8 Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:16:32 +0430
Subject: [PATCH] ld: add soname to shareable objects
so that OE's shared library dependency handling
can find them.
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/link/internal/ld/lib.go | 3 +++
1 file changed, 3 insertions(+)
diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index eab74dc..ae9bbc9 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1576,6 +1576,7 @@ func (ctxt *Link) hostlink() {
argv = append(argv, "-Wl,-z,relro")
}
argv = append(argv, "-shared")
+ argv = append(argv, fmt.Sprintf("-Wl,-soname,%s", filepath.Base(*flagOutfile)))
if ctxt.HeadType == objabi.Hwindows {
argv = addASLRargs(argv, *flagAslr)
} else {
@@ -1591,6 +1592,7 @@ func (ctxt *Link) hostlink() {
argv = append(argv, "-Wl,-z,relro")
}
argv = append(argv, "-shared")
+ argv = append(argv, fmt.Sprintf("-Wl,-soname,%s", filepath.Base(*flagOutfile)))
case BuildModePlugin:
if ctxt.HeadType == objabi.Hdarwin {
argv = append(argv, "-dynamiclib")
@@ -1599,6 +1601,7 @@ func (ctxt *Link) hostlink() {
argv = append(argv, "-Wl,-z,relro")
}
argv = append(argv, "-shared")
+ argv = append(argv, fmt.Sprintf("-Wl,-soname,%s", filepath.Base(*flagOutfile)))
}
}

41
sources/poky/meta/recipes-devtools/go/go/0004-make.bash-override-CC-when-building-dist-and-go_boot.patch Normal file
View File

@@ -0,0 +1,41 @@
From e47d157631d1b97403f253c63d361b7380b32c22 Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:17:16 +0430
Subject: [PATCH] make.bash: override CC when building dist and go_bootstrap
for handling OE cross-canadian builds.
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/make.bash | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/make.bash b/src/make.bash
index 76ad516..074e129 100755
--- a/src/make.bash
+++ b/src/make.bash
@@ -198,7 +198,7 @@ if [[ "$GOROOT_BOOTSTRAP" == "$GOROOT" ]]; then
exit 1
fi
rm -f cmd/dist/dist
-GOROOT="$GOROOT_BOOTSTRAP" nogoenv "$GOROOT_BOOTSTRAP/bin/go" build -o cmd/dist/dist ./cmd/dist
+CC="${BUILD_CC:-${CC}}" GOROOT="$GOROOT_BOOTSTRAP" nogoenv "$GOROOT_BOOTSTRAP/bin/go" build -o cmd/dist/dist ./cmd/dist
# -e doesn't propagate out of eval, so check success by hand.
eval $(./cmd/dist/dist env -p || echo FAIL=true)
@@ -223,7 +223,7 @@ fi
# Run dist bootstrap to complete make.bash.
# Bootstrap installs a proper cmd/dist, built with the new toolchain.
# Throw ours, built with the bootstrap toolchain, away after bootstrap.
-./cmd/dist/dist bootstrap -a $vflag $GO_DISTFLAGS "$@"
+CC="${BUILD_CC:-${CC}}" ./cmd/dist/dist bootstrap -a $vflag $GO_DISTFLAGS "$@"
rm -f ./cmd/dist/dist
# DO NOT ADD ANY NEW CODE HERE.

218
sources/poky/meta/recipes-devtools/go/go/0005-cmd-dist-separate-host-and-target-builds.patch Normal file
View File

@@ -0,0 +1,218 @@
From bae1cec790ff17c4c93a2f8fda27036e5e021f6d Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:18:12 +0430
Subject: [PATCH] cmd/dist: separate host and target builds
Change the dist tool to allow for OE-style cross-
and cross-canadian builds:
- command flags --host-only and --target only are added;
if one is present, the other changes mentioned below
take effect, and arguments may also be specified on
the command line to enumerate the package(s) to be
built.
- for OE cross builds, go_bootstrap is always built for
the current build host, and is moved, along with the supporting
toolchain (asm, compile, etc.) to a separate 'native_native'
directory under GOROOT/pkg/tool.
- go_bootstrap is not automatically removed after the build,
so it can be reused later (e.g., building both static and
shared runtime).
Note that for --host-only builds, it would be nice to specify
just the "cmd" package to build only the go commands/tools,
the staleness checks in the dist tool will fail if the "std"
library has not also been built. So host-only builds have to
build everything anyway.
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
Rework the patch to avoid identation, it breaks formatting rules but
makes the changes more obvious and maintainable.
Jose Quaresma <jose.quaresma@foundries.io>
Richard Purdie <richard.purdie@linuxfoundation.org>
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/dist/build.go | 76 ++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 75 insertions(+), 1 deletion(-)
diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 06ee4de..016b1dd 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -46,6 +46,7 @@ var (
goexperiment string
workdir string
tooldir string
+ build_tooldir string
oldgoos string
oldgoarch string
oldgocache string
@@ -58,6 +59,7 @@ var (
rebuildall bool
noOpt bool
isRelease bool
+ crossBuild bool
vflag int // verbosity
)
@@ -265,6 +267,8 @@ func xinit() {
goversion := findgoversion()
isRelease = strings.HasPrefix(goversion, "release.") || strings.HasPrefix(goversion, "go")
+
+ build_tooldir = pathf("%s/pkg/tool/native_native", goroot)
}
// compilerEnv returns a map from "goos/goarch" to the
@@ -499,8 +503,10 @@ func setup() {
goosGoarch := pathf("%s/pkg/%s_%s", goroot, gohostos, gohostarch)
if rebuildall {
xremoveall(goosGoarch)
+ xremoveall(build_tooldir)
}
xmkdirall(goosGoarch)
+ xmkdirall(build_tooldir)
xatexit(func() {
if files := xreaddir(goosGoarch); len(files) == 0 {
xremove(goosGoarch)
@@ -1338,14 +1344,20 @@ func cmdbootstrap() {
defer timelog("end", "dist bootstrap")
var debug, distpack, force, noBanner, noClean bool
+ var hostOnly bool
+ var targetOnly bool
+ var toBuild = []string{"std", "cmd"}
+
flag.BoolVar(&rebuildall, "a", rebuildall, "rebuild all")
flag.BoolVar(&debug, "d", debug, "enable debugging of bootstrap process")
flag.BoolVar(&distpack, "distpack", distpack, "write distribution files to pkg/distpack")
flag.BoolVar(&force, "force", force, "build even if the port is marked as broken")
flag.BoolVar(&noBanner, "no-banner", noBanner, "do not print banner")
flag.BoolVar(&noClean, "no-clean", noClean, "print deprecation warning")
+ flag.BoolVar(&hostOnly, "host-only", hostOnly, "build only host binaries, not target")
+ flag.BoolVar(&targetOnly, "target-only", targetOnly, "build only target binaries, not host")
- xflagparse(0)
+ xflagparse(-1)
if noClean {
xprintf("warning: --no-clean is deprecated and has no effect; use 'go install std cmd' instead\n")
@@ -1357,6 +1369,18 @@ func cmdbootstrap() {
"Use the -force flag to build anyway.\n", goos, goarch)
}
+ if hostOnly && targetOnly {
+ fatalf("specify only one of --host-only or --target-only\n")
+ }
+ crossBuild = hostOnly || targetOnly
+ if flag.NArg() > 0 {
+ if crossBuild {
+ toBuild = flag.Args()
+ } else {
+ fatalf("package names not permitted without --host-only or --target-only\n")
+ }
+ }
+
// Set GOPATH to an internal directory. We shouldn't actually
// need to store files here, since the toolchain won't
// depend on modules outside of vendor directories, but if
@@ -1434,9 +1458,14 @@ func cmdbootstrap() {
xprintf("\n")
}
+ // For split host/target cross/cross-canadian builds, we don't
+ // want to be setting these flags until after we have compiled
+ // the toolchain that runs on the build host.
+if !crossBuild {
gogcflags = os.Getenv("GO_GCFLAGS") // we were using $BOOT_GO_GCFLAGS until now
setNoOpt()
goldflags = os.Getenv("GO_LDFLAGS") // we were using $BOOT_GO_LDFLAGS until now
+}
goBootstrap := pathf("%s/go_bootstrap", tooldir)
if debug {
run("", ShowOutput|CheckExit, pathf("%s/compile", tooldir), "-V=full")
@@ -1464,7 +1493,11 @@ func cmdbootstrap() {
xprintf("\n")
}
xprintf("Building Go toolchain2 using go_bootstrap and Go toolchain1.\n")
+if !crossBuild {
os.Setenv("CC", compilerEnvLookup("CC", defaultcc, goos, goarch))
+} else {
+ os.Setenv("CC", defaultcc[""])
+}
// Now that cmd/go is in charge of the build process, enable GOEXPERIMENT.
os.Setenv("GOEXPERIMENT", goexperiment)
// No need to enable PGO for toolchain2.
@@ -1517,6 +1550,7 @@ func cmdbootstrap() {
os.Setenv("GOCACHE", oldgocache)
}
+if !crossBuild {
if goos == oldgoos && goarch == oldgoarch {
// Common case - not setting up for cross-compilation.
timelog("build", "toolchain")
@@ -1560,6 +1594,42 @@ func cmdbootstrap() {
checkNotStale(toolenv(), goBootstrap, toolchain...)
copyfile(pathf("%s/compile4", tooldir), pathf("%s/compile", tooldir), writeExec)
}
+} else {
+ gogcflags = os.Getenv("GO_GCFLAGS")
+ goldflags = os.Getenv("GO_LDFLAGS")
+ tool_files, _ := filepath.Glob(pathf("%s/*", tooldir))
+ for _, f := range tool_files {
+ copyfile(pathf("%s/%s", build_tooldir, filepath.Base(f)), f, writeExec)
+ xremove(f)
+ }
+ os.Setenv("GOTOOLDIR", build_tooldir)
+ goBootstrap = pathf("%s/go_bootstrap", build_tooldir)
+ if hostOnly {
+ timelog("build", "host toolchain")
+ if vflag > 0 {
+ xprintf("\n")
+ }
+ xprintf("Building %s for host, %s/%s.\n", strings.Join(toBuild, ","), goos, goarch)
+ goInstall(toolenv(), goBootstrap, toBuild...)
+ checkNotStale(toolenv(), goBootstrap, toBuild...)
+ // Skip cmdGo staleness checks here, since we can't necessarily run the cmdGo binary
+
+ timelog("build", "target toolchain")
+ if vflag > 0 {
+ xprintf("\n")
+ }
+ } else if targetOnly {
+ goos = oldgoos
+ goarch = oldgoarch
+ os.Setenv("GOOS", goos)
+ os.Setenv("GOARCH", goarch)
+ os.Setenv("CC", compilerEnvLookup("CC", defaultcc, goos, goarch))
+ xprintf("Building %s for target, %s/%s.\n", strings.Join(toBuild, ","), goos, goarch)
+ goInstall(toolenv(), goBootstrap, toBuild...)
+ checkNotStale(toolenv(), goBootstrap, toBuild...)
+ // Skip cmdGo staleness checks here, since we can't run the target's cmdGo binary
+ }
+}
// Check that there are no new files in $GOROOT/bin other than
// go and gofmt and $GOOS_$GOARCH (target bin when cross-compiling).
@@ -1582,8 +1652,12 @@ func cmdbootstrap() {
}
}
+ // Except that for split host/target cross-builds, we need to
+ // keep it.
+if !crossBuild {
// Remove go_bootstrap now that we're done.
xremove(pathf("%s/go_bootstrap"+exe, tooldir))
+}
if goos == "android" {
// Make sure the exec wrapper will sync a fresh $GOROOT to the device.

111
sources/poky/meta/recipes-devtools/go/go/0006-cmd-go-make-GOROOT-precious-by-default.patch Normal file
View File

@@ -0,0 +1,111 @@
From a31db6f78d851741aea1e76132a84a24138a5bc6 Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:18:56 +0430
Subject: [PATCH] cmd/go: make GOROOT precious by default
The go build tool normally rebuilds whatever it detects is
stale. This can be a problem when GOROOT is intended to
be read-only and the go runtime has been built as a shared
library, since we don't want every application to be rebuilding
the shared runtime - particularly in cross-build/packaging
setups, since that would lead to 'abi mismatch' runtime errors.
This patch prevents the install and linkshared actions from
installing to GOROOT unless overridden with the GOROOT_OVERRIDE
environment variable.
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
Upstream-Status: Inappropriate [OE specific]
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/go/internal/work/action.go | 3 +++
src/cmd/go/internal/work/build.go | 6 ++++++
src/cmd/go/internal/work/exec.go | 25 +++++++++++++++++++++++++
3 files changed, 34 insertions(+)
diff --git a/src/cmd/go/internal/work/action.go b/src/cmd/go/internal/work/action.go
index a59072e..9e35ebd 100644
--- a/src/cmd/go/internal/work/action.go
+++ b/src/cmd/go/internal/work/action.go
@@ -754,6 +754,9 @@ func (b *Builder) addTransitiveLinkDeps(a, a1 *Action, shlib string) {
if p1 == nil || p1.Shlib == "" || haveShlib[filepath.Base(p1.Shlib)] {
continue
}
+ if goRootPrecious && (p1.Standard || p1.Goroot) {
+ continue
+ }
haveShlib[filepath.Base(p1.Shlib)] = true
// TODO(rsc): The use of ModeInstall here is suspect, but if we only do ModeBuild,
// we'll end up building an overall library or executable that depends at runtime
diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go
index 408edb5..3d60252 100644
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -233,6 +233,8 @@ See also: go install, go get, go clean.
const concurrentGCBackendCompilationEnabledByDefault = true
+var goRootPrecious bool = true
+
func init() {
// break init cycle
CmdBuild.Run = runBuild
@@ -246,6 +248,10 @@ func init() {
AddCoverFlags(CmdBuild, nil)
AddCoverFlags(CmdInstall, nil)
}
+
+ if x := os.Getenv("GOROOT_OVERRIDE"); x != "" {
+ goRootPrecious = false
+ }
}
// Note that flags consulted by other parts of the code
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 9724cd0..544df46 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -544,6 +544,23 @@ func (b *Builder) build(ctx context.Context, a *Action) (err error) {
return err
}
+ if goRootPrecious && (a.Package.Standard || a.Package.Goroot) {
+ _, err := os.Stat(a.Package.Target)
+ if err == nil {
+ a.built = a.Package.Target
+ a.Target = a.Package.Target
+ a.buildID = b.fileHash(a.Package.Target)
+ a.Package.Stale = false
+ a.Package.StaleReason = "GOROOT-resident package"
+ return nil
+ }
+ a.Package.Stale = true
+ a.Package.StaleReason = "missing or invalid GOROOT-resident package"
+ if b.IsCmdList {
+ return nil
+ }
+ }
+
if err := sh.Mkdir(a.Objdir); err != nil {
return err
}
@@ -1737,6 +1754,14 @@ func (b *Builder) linkShared(ctx context.Context, a *Action) (err error) {
return err
}
+ if goRootPrecious && a.Package != nil {
+ p := a.Package
+ if p.Standard || p.Goroot {
+ err := fmt.Errorf("attempting to install package %s into read-only GOROOT", p.ImportPath)
+ return err
+ }
+ }
+
if err := b.Shell(a).Mkdir(a.Objdir); err != nil {
return err
}

59
sources/poky/meta/recipes-devtools/go/go/0007-exec.go-filter-out-build-specific-paths-from-linker-.patch Normal file
View File

@@ -0,0 +1,59 @@
From 1097a07b097043e15fe29a85326dbd196401244a Mon Sep 17 00:00:00 2001
From: Changqing Li <changqing.li@windriver.com>
Date: Tue, 27 Feb 2024 18:06:51 +0800
Subject: [PATCH] exec.go: filter out build-specific paths from linker flags
The flags can contain build-specific paths, breaking reproducibility.
Filter out options that have build-specific paths.
Upstream-Status: Inappropriate [ Not perfect for upstream ]
Signed-off-by: Changqing Li <changqing.li@windriver.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/go/internal/work/exec.go | 25 ++++++++++++++++++++++++-
1 file changed, 24 insertions(+), 1 deletion(-)
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 544df46..c8f297c 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -1401,6 +1401,29 @@ func (b *Builder) linkActionID(a *Action) cache.ActionID {
return h.Sum()
}
+func filterLinkerFlags(flags []string) []string {
+ var newflags []string
+ var skipflag bool
+ skipflag = false
+ for i, flag := range flags {
+ if skipflag == true {
+ skipflag = false
+ continue
+ }
+ if strings.HasPrefix(flag, "--sysroot") || strings.HasPrefix(flag, "-fmacro-prefix-map") || strings.HasPrefix(flag, "-fdebug-prefix-map") || strings.HasPrefix(flag, "-ffile-prefix-map") || strings.HasPrefix(flag, "-fcanon-prefix-map") || strings.HasPrefix(flag, "-fprofile-prefix-map") || strings.HasPrefix(flag, "-Wl,-rpath-link"){
+ continue
+ } else if strings.HasPrefix(flag, "-extldflags") {
+ skipflag = true
+ newflags = append(newflags, flag)
+ var filterd_Extldflags []string = filterLinkerFlags(strings.Split(flags[i+1], " "))
+ newflags = append(newflags, strings.Join(filterd_Extldflags, " "))
+ } else {
+ newflags = append(newflags, flag)
+ }
+ }
+ return newflags
+}
+
// printLinkerConfig prints the linker config into the hash h,
// as part of the computation of a linker-related action ID.
func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
@@ -1411,7 +1434,7 @@ func (b *Builder) printLinkerConfig(h io.Writer, p *load.Package) {
case "gc":
fmt.Fprintf(h, "link %s %q %s\n", b.toolID("link"), forcedLdflags, ldBuildmode)
if p != nil {
- fmt.Fprintf(h, "linkflags %q\n", p.Internal.Ldflags)
+ fmt.Fprintf(h, "linkflags %q\n", filterLinkerFlags(p.Internal.Ldflags))
}
// GOARM, GOMIPS, etc.

43
sources/poky/meta/recipes-devtools/go/go/0008-src-cmd-dist-buildgo.go-do-not-hardcode-host-compile.patch Normal file
View File

@@ -0,0 +1,43 @@
From e5af6155f2d6e0758d11d6c12d6f47ea8e65b141 Mon Sep 17 00:00:00 2001
From: Alexander Kanavin <alex.kanavin@gmail.com>
Date: Tue, 10 Nov 2020 16:33:27 +0000
Subject: [PATCH] src/cmd/dist/buildgo.go: do not hardcode host compilers into
target binaries
These come from $CC/$CXX on the build host and are not useful on targets;
additionally as they contain host specific paths, this helps reproducibility.
Upstream-Status: Inappropriate [needs upstream discussion]
Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/dist/buildgo.go | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/cmd/dist/buildgo.go b/src/cmd/dist/buildgo.go
index 884e9d7..2f52eda 100644
--- a/src/cmd/dist/buildgo.go
+++ b/src/cmd/dist/buildgo.go
@@ -51,8 +51,8 @@ func mkzdefaultcc(dir, file string) {
fmt.Fprintf(&buf, "package cfg\n")
fmt.Fprintln(&buf)
fmt.Fprintf(&buf, "const DefaultPkgConfig = `%s`\n", defaultpkgconfig)
- buf.WriteString(defaultCCFunc("DefaultCC", defaultcc))
- buf.WriteString(defaultCCFunc("DefaultCXX", defaultcxx))
+ buf.WriteString(defaultCCFunc("DefaultCC", map[string]string{"":"gcc"}))
+ buf.WriteString(defaultCCFunc("DefaultCXX", map[string]string{"":"g++"}))
writefile(buf.String(), file, writeSkipSame)
return
}
@@ -62,8 +62,8 @@ func mkzdefaultcc(dir, file string) {
fmt.Fprintf(&buf, "package main\n")
fmt.Fprintln(&buf)
fmt.Fprintf(&buf, "const defaultPkgConfig = `%s`\n", defaultpkgconfig)
- buf.WriteString(defaultCCFunc("defaultCC", defaultcc))
- buf.WriteString(defaultCCFunc("defaultCXX", defaultcxx))
+ buf.WriteString(defaultCCFunc("defaultCC", map[string]string{"":"gcc"}))
+ buf.WriteString(defaultCCFunc("defaultCXX", map[string]string{"":"g++"}))
writefile(buf.String(), file, writeSkipSame)
}

58
sources/poky/meta/recipes-devtools/go/go/0009-go-Filter-build-paths-on-staticly-linked-arches.patch Normal file
View File

@@ -0,0 +1,58 @@
From 6bdd6405ce63c7aa4b35cd85833d03c7f1b9109a Mon Sep 17 00:00:00 2001
From: Richard Purdie <richard.purdie@linuxfoundation.org>
Date: Sat, 2 Jul 2022 23:08:13 +0100
Subject: [PATCH] go: Filter build paths on staticly linked arches
Filter out build time paths from ldflags and other flags variables when they're
embedded in the go binary so that builds are reproducible regardless of build
location. This codepath is hit for statically linked go binaries such as those
on mips/ppc.
Upstream-Status: Submitted [https://github.com/golang/go/pull/56410]
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
Signed-off-by: Jose Quaresma <jose.quaresma@foundries.io>
---
src/cmd/go/internal/load/pkg.go | 15 +++++++++++++--
1 file changed, 13 insertions(+), 2 deletions(-)
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 1549800..f41fb2c 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -2277,6 +2277,17 @@ func appendBuildSetting(info *debug.BuildInfo, key, value string) {
info.Settings = append(info.Settings, debug.BuildSetting{Key: key, Value: value})
}
+func filterCompilerFlags(flags string) string {
+ var newflags []string
+ for _, flag := range strings.Fields(flags) {
+ if strings.HasPrefix(flag, "--sysroot") || strings.HasPrefix(flag, "-fmacro-prefix-map") || strings.HasPrefix(flag, "-fdebug-prefix-map") {
+ continue
+ }
+ newflags = append(newflags, flag)
+ }
+ return strings.Join(newflags, " ")
+}
+
// setBuildInfo gathers build information and sets it into
// p.Internal.BuildInfo, which will later be formatted as a string and embedded
// in the binary. setBuildInfo should only be called on a main package with no
@@ -2384,7 +2395,7 @@ func (p *Package) setBuildInfo(ctx context.Context, autoVCS bool) {
if gcflags := BuildGcflags.String(); gcflags != "" && cfg.BuildContext.Compiler == "gc" {
appendSetting("-gcflags", gcflags)
}
- if ldflags := BuildLdflags.String(); ldflags != "" {
+ if ldflags := filterCompilerFlags(BuildLdflags.String()); ldflags != "" {
// https://go.dev/issue/52372: only include ldflags if -trimpath is not set,
// since it can include system paths through various linker flags (notably
// -extar, -extld, and -extldflags).
@@ -2427,7 +2438,7 @@ func (p *Package) setBuildInfo(ctx context.Context, autoVCS bool) {
// subset of flags that are known not to be paths?
if cfg.BuildContext.CgoEnabled && !cfg.BuildTrimpath {
for _, name := range []string{"CGO_CFLAGS", "CGO_CPPFLAGS", "CGO_CXXFLAGS", "CGO_LDFLAGS"} {
- appendSetting(name, cfg.Getenv(name))
+ appendSetting(name, filterCompilerFlags(cfg.Getenv(name)))
}
}
appendSetting("GOARCH", cfg.BuildContext.GOARCH)

80
sources/poky/meta/recipes-devtools/go/go/CVE-2025-22870.patch Normal file
View File

@@ -0,0 +1,80 @@
From 25177ecde0922c50753c043579d17828b7ee88e7 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 Feb 2025 16:08:57 -0800
Subject: [PATCH] all: updated vendored x/net with security fix
0b6d719 [internal-branch.go1.23-vendor] proxy, http/httpproxy: do not mismatch IPv6 zone ids against hosts
Fixes CVE-2025-22870
For #71985
Change-Id: Ib72c96bd0ab44d9ed2ac1428e0a9fc245464b3fc
Reviewed-on: https://go-internal-review.googlesource.com/c/go/+/2141
Commit-Queue: Damien Neil <dneil@google.com>
Reviewed-by: Roland Shoemaker <bracewell@google.com>
Reviewed-by: Neal Patel <nealpatel@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/654695
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Junyang Shao <shaojunyang@google.com>
CVE: CVE-2025-22870
Upstream-Status: Backport [https://github.com/golang/go/commit/25177ecde0922c50753c043579d17828b7ee88e7]
Signed-off-by: Archana Polampalli <archana.polampalli@windriver.com>
---
src/cmd/internal/moddeps/moddeps_test.go | 1 +
src/vendor/golang.org/x/net/http/httpproxy/proxy.go | 10 ++++++++--
2 files changed, 9 insertions(+), 2 deletions(-)
diff --git a/src/cmd/internal/moddeps/moddeps_test.go b/src/cmd/internal/moddeps/moddeps_test.go
index 3d4c99e..ffaa16c 100644
--- a/src/cmd/internal/moddeps/moddeps_test.go
+++ b/src/cmd/internal/moddeps/moddeps_test.go
@@ -33,6 +33,7 @@ import (
// See issues 36852, 41409, and 43687.
// (Also see golang.org/issue/27348.)
func TestAllDependencies(t *testing.T) {
+ t.Skip("TODO(#71985) 1.23.7 contains unreleased changes from vendored modules")
goBin := testenv.GoToolPath(t)
// Ensure that all packages imported within GOROOT
diff --git a/src/vendor/golang.org/x/net/http/httpproxy/proxy.go b/src/vendor/golang.org/x/net/http/httpproxy/proxy.go
index c3bd9a1..864961c 100644
--- a/src/vendor/golang.org/x/net/http/httpproxy/proxy.go
+++ b/src/vendor/golang.org/x/net/http/httpproxy/proxy.go
@@ -14,6 +14,7 @@ import (
"errors"
"fmt"
"net"
+ "net/netip"
"net/url"
"os"
"strings"
@@ -180,8 +181,10 @@ func (cfg *config) useProxy(addr string) bool {
if host == "localhost" {
return false
}
- ip := net.ParseIP(host)
- if ip != nil {
+ nip, err := netip.ParseAddr(host)
+ var ip net.IP
+ if err == nil {
+ ip = net.IP(nip.AsSlice())
if ip.IsLoopback() {
return false
}
@@ -363,6 +366,9 @@ type domainMatch struct {
}
func (m domainMatch) match(host, port string, ip net.IP) bool {
+ if ip != nil {
+ return false
+ }
if strings.HasSuffix(host, m.host) || (m.matchHost && host == m.host[1:]) {
return m.port == "" || m.port == port
}
--
2.40.0

172
sources/poky/meta/recipes-devtools/go/go/CVE-2025-22871.patch Normal file
View File

@@ -0,0 +1,172 @@
From 15e01a2e43ecb8c7e15ff7e9d62fe3f10dcac931 Mon Sep 17 00:00:00 2001
From: Damien Neil <dneil@google.com>
Date: Wed, 26 Feb 2025 13:40:00 -0800
Subject: [PATCH] [release-branch.go1.23] net/http: reject newlines in
chunk-size lines
Unlike request headers, where we are allowed to leniently accept
a bare LF in place of a CRLF, chunked bodies must always use CRLF
line terminators. We were already enforcing this for chunk-data lines;
do so for chunk-size lines as well. Also reject bare CRs anywhere
other than as part of the CRLF terminator.
Fixes CVE-2025-22871
Fixes #72010
For #71988
Change-Id: Ib0e21af5a8ba28c2a1ca52b72af8e2265ec79e4a
Reviewed-on: https://go-review.googlesource.com/c/go/+/652998
Reviewed-by: Jonathan Amsterdam <jba@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
(cherry picked from commit d31c805535f3fde95646ee4d87636aaaea66847b)
Reviewed-on: https://go-review.googlesource.com/c/go/+/657216
Upstream-Status: Backport [https://github.com/golang/go/commit/15e01a2e43ecb8c7e15ff7e9d62fe3f10dcac931]
CVE: CVE-2025-22871
Signed-off-by: Hitendra Prajapati <hprajapati@mvista.com>
---
src/net/http/internal/chunked.go | 19 +++++++++--
src/net/http/internal/chunked_test.go | 27 +++++++++++++++
src/net/http/serve_test.go | 49 +++++++++++++++++++++++++++
3 files changed, 92 insertions(+), 3 deletions(-)
diff --git a/src/net/http/internal/chunked.go b/src/net/http/internal/chunked.go
index 196b5d8..0b08a97 100644
--- a/src/net/http/internal/chunked.go
+++ b/src/net/http/internal/chunked.go
@@ -164,6 +164,19 @@ func readChunkLine(b *bufio.Reader) ([]byte, error) {
}
return nil, err
}
+
+ // RFC 9112 permits parsers to accept a bare \n as a line ending in headers,
+ // but not in chunked encoding lines. See https://www.rfc-editor.org/errata/eid7633,
+ // which explicitly rejects a clarification permitting \n as a chunk terminator.
+ //
+ // Verify that the line ends in a CRLF, and that no CRs appear before the end.
+ if idx := bytes.IndexByte(p, '\r'); idx == -1 {
+ return nil, errors.New("chunked line ends with bare LF")
+ } else if idx != len(p)-2 {
+ return nil, errors.New("invalid CR in chunked line")
+ }
+ p = p[:len(p)-2] // trim CRLF
+
if len(p) >= maxLineLength {
return nil, ErrLineTooLong
}
@@ -171,14 +184,14 @@ func readChunkLine(b *bufio.Reader) ([]byte, error) {
}
func trimTrailingWhitespace(b []byte) []byte {
- for len(b) > 0 && isASCIISpace(b[len(b)-1]) {
+ for len(b) > 0 && isOWS(b[len(b)-1]) {
b = b[:len(b)-1]
}
return b
}
-func isASCIISpace(b byte) bool {
- return b == ' ' || b == '\t' || b == '\n' || b == '\r'
+func isOWS(b byte) bool {
+ return b == ' ' || b == '\t'
}
var semi = []byte(";")
diff --git a/src/net/http/internal/chunked_test.go b/src/net/http/internal/chunked_test.go
index af79711..312f173 100644
--- a/src/net/http/internal/chunked_test.go
+++ b/src/net/http/internal/chunked_test.go
@@ -280,6 +280,33 @@ func TestChunkReaderByteAtATime(t *testing.T) {
}
}
+func TestChunkInvalidInputs(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ b string
+ }{{
+ name: "bare LF in chunk size",
+ b: "1\na\r\n0\r\n",
+ }, {
+ name: "extra LF in chunk size",
+ b: "1\r\r\na\r\n0\r\n",
+ }, {
+ name: "bare LF in chunk data",
+ b: "1\r\na\n0\r\n",
+ }, {
+ name: "bare LF in chunk extension",
+ b: "1;\na\r\n0\r\n",
+ }} {
+ t.Run(test.name, func(t *testing.T) {
+ r := NewChunkedReader(strings.NewReader(test.b))
+ got, err := io.ReadAll(r)
+ if err == nil {
+ t.Fatalf("unexpectedly parsed invalid chunked data:\n%q", got)
+ }
+ })
+ }
+}
+
type funcReader struct {
f func(iteration int) ([]byte, error)
i int
diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 0c76f1b..0e8af02 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -6980,3 +6980,52 @@ func testDisableContentLength(t *testing.T, mode testMode) {
t.Fatal(err)
}
}
+
+func TestInvalidChunkedBodies(t *testing.T) {
+ for _, test := range []struct {
+ name string
+ b string
+ }{{
+ name: "bare LF in chunk size",
+ b: "1\na\r\n0\r\n\r\n",
+ }, {
+ name: "bare LF at body end",
+ b: "1\r\na\r\n0\r\n\n",
+ }} {
+ t.Run(test.name, func(t *testing.T) {
+ reqc := make(chan error)
+ ts := newClientServerTest(t, http1Mode, HandlerFunc(func(w ResponseWriter, r *Request) {
+ got, err := io.ReadAll(r.Body)
+ if err == nil {
+ t.Logf("read body: %q", got)
+ }
+ reqc <- err
+ })).ts
+
+ serverURL, err := url.Parse(ts.URL)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ conn, err := net.Dial("tcp", serverURL.Host)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if _, err := conn.Write([]byte(
+ "POST / HTTP/1.1\r\n" +
+ "Host: localhost\r\n" +
+ "Transfer-Encoding: chunked\r\n" +
+ "Connection: close\r\n" +
+ "\r\n" +
+ test.b)); err != nil {
+ t.Fatal(err)
+ }
+ conn.(*net.TCPConn).CloseWrite()
+
+ if err := <-reqc; err == nil {
+ t.Errorf("server handler: io.ReadAll(r.Body) succeeded, want error")
+ }
+ })
+ }
+}
--
2.25.1

68
sources/poky/meta/recipes-devtools/go/go/CVE-2025-4673.patch Normal file
View File

@@ -0,0 +1,68 @@
From b897e97c36cb62629a458bc681723ca733404e32 Mon Sep 17 00:00:00 2001
From: Neal Patel <nealpatel@google.com>
Date: Wed, 21 May 2025 14:11:44 -0400
Subject: [PATCH] net/http: strip sensitive proxy headers from redirect
requests
Similarly to Authentication entries, Proxy-Authentication entries should be stripped to ensure sensitive information is not leaked on redirects outside of the original domain.
https://fetch.spec.whatwg.org/#authentication-entries
Thanks to Takeshi Kaneko (GMO Cybersecurity by Ierae, Inc.) for reporting this issue.
Updates golang/go#73816
Fixes golang/go#73905
Fixes CVE-2025-4673
Change-Id: I1615f31977a2fd014fbc12aae43f82692315a6d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/679255
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
CVE: CVE-2025-4673
Upstream-Status: Backport [https://github.com/golang/go/commit/b897e97c36cb62629a458bc681723ca733404e32]
Signed-off-by: Praveen Kumar <praveen.kumar@windriver.com>
---
src/net/http/client.go | 3 ++-
src/net/http/client_test.go | 3 +++
2 files changed, 5 insertions(+), 1 deletion(-)
diff --git a/src/net/http/client.go b/src/net/http/client.go
index 23f4d81..e07616b 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -805,7 +805,8 @@ func (c *Client) makeHeadersCopier(ireq *Request) func(req *Request, stripSensit
for k, vv := range ireqhdr {
sensitive := false
switch CanonicalHeaderKey(k) {
- case "Authorization", "Www-Authenticate", "Cookie", "Cookie2":
+ case "Authorization", "Www-Authenticate", "Cookie", "Cookie2",
+ "Proxy-Authorization", "Proxy-Authenticate":
sensitive = true
}
if !(sensitive && stripSensitiveHeaders) {
diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index 641d7ff..97150bd 100644
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -1541,6 +1541,8 @@ func testClientStripHeadersOnRepeatedRedirect(t *testing.T, mode testMode) {
if r.Host+r.URL.Path != "a.example.com/" {
if h := r.Header.Get("Authorization"); h != "" {
t.Errorf("on request to %v%v, Authorization=%q, want no header", r.Host, r.URL.Path, h)
+ } else if h := r.Header.Get("Proxy-Authorization"); h != "" {
+ t.Errorf("on request to %v%v, Proxy-Authorization=%q, want no header", r.Host, r.URL.Path, h)
}
}
// Follow a chain of redirects from a to b and back to a.
@@ -1569,6 +1571,7 @@ func testClientStripHeadersOnRepeatedRedirect(t *testing.T, mode testMode) {
req, _ := NewRequest("GET", proto+"://a.example.com/", nil)
req.Header.Add("Cookie", "foo=bar")
req.Header.Add("Authorization", "secretpassword")
+ req.Header.Add("Proxy-Authorization", "secretpassword")
res, err := c.Do(req)
if err != nil {
t.Fatal(err)
--
2.40.0

18
sources/poky/meta/recipes-devtools/go/go_1.22.12.bb Normal file
View File

@@ -0,0 +1,18 @@
require go-${PV}.inc
require go-target.inc
inherit linuxloader
CGO_LDFLAGS:append = " -no-pie"
export GO_LDSO = "${@get_linuxloader(d)}"
export CC_FOR_TARGET = "gcc"
export CXX_FOR_TARGET = "g++"
# mips/rv64 doesn't support -buildmode=pie, so skip the QA checking for mips/riscv32 and its
# variants.
python() {
if 'mips' in d.getVar('TARGET_ARCH') or 'riscv32' in d.getVar('TARGET_ARCH'):
d.appendVar('INSANE_SKIP:%s' % d.getVar('PN'), " textrel")
}