# Issue #66456

[!cgo] skip
[GOOS:windows] skip
[GOOS:plan9] skip

# Generate a file with a very long #cgo LDFLAGS line.
# This used to cause "go build" to fail with "argument list too long".
go generate

# Build with the generated file.
go build

-- go.mod --
module cgolongcmd

go 1.22
-- generate.go --
//go:build ignore

package main

import (
	"fmt"
	"log"
	"os"
	"bytes"
)

  source "${version_file}"
}

# Prints the value that needs to be passed to the -ldflags parameter of go build
# in order to set the Kubernetes based on the git tree status.
# IMPORTANT: if you update any of these, also update the lists in
# hack/print-workspace-status.sh.
kube::version::ldflags() {
  kube::version::get_version_vars

  local -a ldflags
  function add_ldflag() {
    local key=${1}
    local val=${2}

env GOFLAGS='-m -v'
go version
stdout '^go version'
env GOFLAGS=

env GO111MODULE=on

# Check that very basic version lookup succeeds.
go build empty.go
go version empty$GOEXE
[cgo] go build -ldflags=-linkmode=external empty.go
[cgo] go version empty$GOEXE

# Skip the remaining builds if we are running in short mode.
[short] skip

# Check that 'go version' and 'go version -m' work on a binary built in module mode.

/*
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <arpa/nameser.h>
#include <resolv.h>

#cgo !android,!openbsd LDFLAGS: -lresolv
*/
import "C"

type _C_struct___res_state = struct{}

func _C_res_ninit(state *_C_struct___res_state) error {
	return nil
}

func _C_res_nclose(state *_C_struct___res_state) {
	return
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <arpa/nameser.h>
#include <resolv.h>

#cgo !aix,!dragonfly,!freebsd LDFLAGS: -lresolv
*/
import "C"

type _C_struct___res_state = C.struct___res_state

func _C_res_ninit(state *_C_struct___res_state) error {
	_, err := C.res_ninit(state)
	return err
}

#   limitations under the License.

# build a tcp-echo binary using the golang container
FROM golang:1.22 as builder
WORKDIR /go/src/istio.io/tcp-echo-server/
COPY main.go .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags '-extldflags -static -s -w' -o tcp-echo main.go

FROM scratch

WORKDIR /bin/
COPY --from=builder /go/src/istio.io/tcp-echo-server/tcp-echo .
ENTRYPOINT [ "/bin/tcp-echo" ]
CMD [ "9000", "hello" ]

          CGO_ENABLED: 0
          GO111MODULE: on
        run: |
          Set-MpPreference -DisableRealtimeMonitoring $true
          netsh int ipv4 set dynamicport tcp start=60000 num=61000
          go build --ldflags="-s -w" -o %GOPATH%\bin\minio.exe
          go test -v --timeout 120m ./...
      - name: Build on ${{ matrix.os }}
        if: matrix.os == 'ubuntu-latest'
        env:
          CGO_ENABLED: 0
          GO111MODULE: on

// allow CGO in tests. The build tag should ensure either way that these
// functions will not end up in the package.

// TODO: Ensure that the correct ICU version is set.

/*
#cgo LDFLAGS: -licui18n.57 -licuuc.57
#include <stdlib.h>
#include <unicode/ustring.h>
#include <unicode/utypes.h>
#include <unicode/localpointer.h>
#include <unicode/ucasemap.h>
*/
import "C"

import "unsafe"

	OperatorBinaryVersion pkgversion.Version
)

func init() {
	var err error
	OperatorVersionString = OperatorCodeBaseVersion
	// If dockerinfo has a tag (e.g., specified by LDFlags), we will use it as the version of operator
	tag := buildversion.DockerInfo.Tag
	if pkgversion.IsVersionString(tag) {
		OperatorVersionString = pkgversion.TagToVersionStringGrace(tag)
	}

ALL_OSVERSIONS.windows := 1809 ltsc2022
ALL_OS_ARCH.windows = $(foreach arch, $(ALL_ARCH.windows), $(foreach osversion, ${ALL_OSVERSIONS.windows}, windows-$(arch)-${osversion}))
ALL_OS_ARCH = $(foreach os, $(ALL_OS), ${ALL_OS_ARCH.${os}})

CFLAGS = -Os -Wall -Werror -static -DVERSION=v$(TAG)-$(REV)
KUBE_CROSS_IMAGE ?= registry.k8s.io/build-image/kube-cross
KUBE_CROSS_VERSION ?= $(shell cat ../build-image/cross/VERSION)