all: cleanup unused code, part 2 (#10670)

And enable U1000 check in staticcheck.

Updates #cleanup

Signed-off-by: Andrew Lytvynov <awly@tailscale.com>

util/linuxfw/helpers.go

@@ -1,6 +1,8 @@
 // Copyright (c) Tailscale Inc & AUTHORS
 // SPDX-License-Identifier: BSD-3-Clause
 
+//go:build linux
+
 package linuxfw
 
 import (

util/linuxfw/linuxfw_unsupported.go

@@ -5,7 +5,7 @@
 // support in upstream dependencies.
 
 // TODO(#8502): add support for more architectures
-//go:build !linux || (linux && !(arm64 || amd64))
+//go:build linux && !(arm64 || amd64)
 
 package linuxfw
 

util/winutil/restartmgr_windows.go

@@ -112,6 +112,7 @@ const (
 type _RM_APP_STATUS uint32
 
 const (
+	//lint:ignore U1000 maps to a win32 API
 	_RmStatusUnknown        _RM_APP_STATUS = 0x0
 	_RmStatusRunning        _RM_APP_STATUS = 0x1
 	_RmStatusStopped        _RM_APP_STATUS = 0x2

util/winutil/subprocess_windows_test.go

@@ -12,11 +12,9 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"strconv"
 	"strings"
 	"sync"
 	"testing"
-	"time"
 )
 
 // The code in this file is adapted from internal/testenv in the Go source tree
@@ -52,15 +50,6 @@ func pathToTestProg(t *testing.T, binary string) string {
 	return exe
 }
 
-func runTestProg(t *testing.T, binary, name string, env ...string) string {
-	exe, err := buildTestProg(t, binary, "-buildvcs=false")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return runBuiltTestProg(t, exe, name, env...)
-}
-
 func startTestProg(t *testing.T, binary, name string, env ...string) {
 	exe, err := buildTestProg(t, binary, "-buildvcs=false")
 	if err != nil {
@@ -70,16 +59,6 @@ func startTestProg(t *testing.T, binary, name string, env ...string) {
 	startBuiltTestProg(t, exe, name, env...)
 }
 
-func runBuiltTestProg(t *testing.T, exe, name string, env ...string) string {
-	cmd := exec.Command(exe, name)
-	cmd.Env = append(cmd.Env, env...)
-	if testing.Short() {
-		cmd.Env = append(cmd.Env, "RUNTIME_TEST_SHORT=1")
-	}
-	out, _ := runWithTimeout(t, cmd)
-	return string(out)
-}
-
 func startBuiltTestProg(t *testing.T, exe, name string, env ...string) {
 	cmd := exec.Command(exe, name)
 	cmd.Env = append(cmd.Env, env...)
@@ -276,20 +255,6 @@ func mustHaveGoBuild(t testing.TB) {
 	}
 }
 
-// hasGoRun reports whether the current system can run programs with “go run.”
-func hasGoRun() bool {
-	// For now, having go run and having go build are the same.
-	return hasGoBuild()
-}
-
-// mustHaveGoRun checks that the current system can run programs with “go run.”
-// If not, mustHaveGoRun calls t.Skip with an explanation.
-func mustHaveGoRun(t testing.TB) {
-	if !hasGoRun() {
-		t.Skipf("skipping test: 'go run' not available on %s/%s", runtime.GOOS, runtime.GOARCH)
-	}
-}
-
 var (
 	gorootOnce sync.Once
 	gorootPath string
@@ -366,57 +331,6 @@ func findGOROOT() (string, error) {
 	return gorootPath, gorootErr
 }
 
-// runWithTimeout runs cmd and returns its combined output. If the
-// subprocess exits with a non-zero status, it will log that status
-// and return a non-nil error, but this is not considered fatal.
-func runWithTimeout(t testing.TB, cmd *exec.Cmd) ([]byte, error) {
-	args := cmd.Args
-	if args == nil {
-		args = []string{cmd.Path}
-	}
-
-	var b bytes.Buffer
-	cmd.Stdout = &b
-	cmd.Stderr = &b
-	if err := cmd.Start(); err != nil {
-		t.Fatalf("starting %s: %v", args, err)
-	}
-
-	// If the process doesn't complete within 1 minute,
-	// assume it is hanging and kill it to get a stack trace.
-	p := cmd.Process
-	done := make(chan bool)
-	go func() {
-		scale := 2
-		if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
-			if sc, err := strconv.Atoi(s); err == nil {
-				scale = sc
-			}
-		}
-
-		select {
-		case <-done:
-		case <-time.After(time.Duration(scale) * time.Minute):
-			p.Signal(os.Kill)
-			// If SIGQUIT doesn't do it after a little
-			// while, kill the process.
-			select {
-			case <-done:
-			case <-time.After(time.Duration(scale) * 30 * time.Second):
-				p.Signal(os.Kill)
-			}
-		}
-	}()
-
-	err := cmd.Wait()
-	if err != nil {
-		t.Logf("%s exit status: %v", args, err)
-	}
-	close(done)
-
-	return b.Bytes(), err
-}
-
 // start runs cmd asynchronously and returns immediately.
 func start(t testing.TB, cmd *exec.Cmd) {
 	args := cmd.Args

util/winutil/winutil_windows.go

@@ -382,26 +382,6 @@ func CreateAppMutex(name string) (windows.Handle, error) {
 	return windows.CreateMutex(nil, false, windows.StringToUTF16Ptr(name))
 }
 
-// getTokenInfoVariableLen obtains variable-length token information. Use
-// this function for information classes that output variable-length data.
-func getTokenInfoVariableLen[T any](token windows.Token, infoClass uint32) (*T, error) {
-	var buf []byte
-	var desiredLen uint32
-
-	err := windows.GetTokenInformation(token, infoClass, nil, 0, &desiredLen)
-
-	for err == windows.ERROR_INSUFFICIENT_BUFFER {
-		buf = make([]byte, desiredLen)
-		err = windows.GetTokenInformation(token, infoClass, unsafe.SliceData(buf), desiredLen, &desiredLen)
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return (*T)(unsafe.Pointer(unsafe.SliceData(buf))), nil
-}
-
 // getTokenInfoFixedLen obtains known fixed-length token information. Use this
 // function for information classes that output enumerations, BOOLs, integers etc.
 func getTokenInfoFixedLen[T any](token windows.Token, infoClass uint32) (result T, err error) {