Fix another set of lint errors

Author: lakshk98

pkg/plugin/common/common_windows.go

@@ -5,6 +5,9 @@
 package common
 
 import (
+	"errors"
+	"fmt"
+
 	"golang.org/x/sys/windows/registry"
 )
 
@@ -22,19 +25,19 @@ const (
 func IsCiliumOnWindowsEnabled() (bool, error) {
 	k, err := registry.OpenKey(registry.LOCAL_MACHINE, KeyPath, registry.QUERY_VALUE)
 	if err != nil {
-		if err == registry.ErrNotExist {
+		if errors.Is(err, registry.ErrNotExist) {
 			return false, nil
 		}
-		return false, err
+		return false, fmt.Errorf("opening registry key: %w", err)
 	}
 	defer k.Close()
 
 	val, _, err := k.GetIntegerValue(ValueName)
 	if err != nil {
-		if err == registry.ErrNotExist {
+		if errors.Is(err, registry.ErrNotExist) {
 			return false, nil
 		}
-		return false, err
+		return false, fmt.Errorf("reading registry value: %w", err)
 	}
 	return val == 1, nil
 }

pkg/plugin/ebpfwindows/datapath_drop_windows.go

@@ -170,7 +170,7 @@ func (n *DropNotify) decodeDropNotify(data []byte) error {
 	n.DstID = byteorder.Native.Uint32(data[24:28])
 	n.Line = byteorder.Native.Uint16(data[28:30])
 	n.File = data[30]
-	n.ExtError = int8(data[31])
+	n.ExtError = int8(data[31]) //nolint:gosec // data[31] is a bounded error code field that fits in int8
 	n.Ifindex = byteorder.Native.Uint32(data[32:36])
 
 	return nil

pkg/plugin/ebpfwindows/ebpf_windows.go

@@ -85,10 +85,9 @@ func (p *Plugin) Start(ctx context.Context) error {
 	p.l.Info("Start ebpfWindows plugin...")
 
 	ciliumEnabled, err := isCiliumOnWindowsEnabled()
-
 	if err != nil {
 		p.l.Error("Error while checking if Cilium is enabled on Windows", zap.Error(err))
-		return fmt.Errorf("Failed to check if Cilium is enabled on Windows: %w", err)
+		return fmt.Errorf("failed to check if Cilium is enabled on Windows: %w", err)
 	}
 
 	if !ciliumEnabled {
@@ -131,24 +130,26 @@ func (p *Plugin) metricsMapIterateCallback(key *MetricsKey, value *MetricsValue)
 	}
 	if key.IsDrop() {
 		p.l.Debug("MetricsMapIterateCallback Drop", zap.String("key", key.String()))
-		if key.IsEgress() {
+		switch {
+		case key.IsEgress():
 			metrics.DropBytesGauge.WithLabelValues(key.DropForwardReason(), egressLabel).Set(float64(value.Bytes))
 			metrics.DropPacketsGauge.WithLabelValues(key.DropForwardReason(), egressLabel).Set(float64(value.Count))
-		} else if key.IsIngress() {
+		case key.IsIngress():
 			metrics.DropBytesGauge.WithLabelValues(key.DropForwardReason(), ingressLabel).Set(float64(value.Bytes))
 			metrics.DropPacketsGauge.WithLabelValues(key.DropForwardReason(), ingressLabel).Set(float64(value.Count))
-		} else {
+		default:
 			p.l.Error("MetricsMapIterateCallback drop key is neither ingress nor egress", zap.String("key", key.String()))
 		}
 	} else {
 		p.l.Debug("MetricsMapIterateCallback Forward", zap.String("key", key.String()))
-		if key.IsEgress() {
+		switch {
+		case key.IsEgress():
 			metrics.ForwardPacketsGauge.WithLabelValues(egressLabel).Set(float64(value.Count))
 			metrics.ForwardBytesGauge.WithLabelValues(egressLabel).Set(float64(value.Bytes))
-		} else if key.IsIngress() {
+		case key.IsIngress():
 			metrics.ForwardPacketsGauge.WithLabelValues(ingressLabel).Set(float64(value.Count))
 			metrics.ForwardBytesGauge.WithLabelValues(ingressLabel).Set(float64(value.Bytes))
-		} else {
+		default:
 			p.l.Error("MetricsMapIterateCallback forward key is neither ingress nor egress", zap.String("key", key.String()))
 		}
 	}
@@ -216,16 +217,13 @@ func (p *Plugin) pullMetricsAndEvents(ctx context.Context) {
 			}
 
 			lostEventsCount, err := GetLostEventsCount()
-
 			if err != nil {
 				p.l.Error("Error getting lost events count", zap.Error(err))
-			} else {
+			} else if lostEventsCount > prevLostEventsCount {
 				// The lost events count is cumulative, so we need to calculate the difference
-				if lostEventsCount > prevLostEventsCount {
-					counterToAdd := lostEventsCount - prevLostEventsCount
-					metrics.LostEventsCounter.WithLabelValues(utils.Kernel, name).Add(float64(counterToAdd))
-					prevLostEventsCount = lostEventsCount
-				}
+				counterToAdd := lostEventsCount - prevLostEventsCount
+				metrics.LostEventsCounter.WithLabelValues(utils.Kernel, name).Add(float64(counterToAdd))
+				prevLostEventsCount = lostEventsCount
 			}
 
 		case <-ctx.Done():

pkg/plugin/ebpfwindows/ebpf_windows_test.go

@@ -34,6 +34,7 @@ const (
 )
 
 var errTestFailure = errors.New("test failure")
+var errModuleNotFound = errors.New("module not found")
 
 func makeMockEthernetIPv4TCPPacket() []byte {
 	eth := &layers.Ethernet{
@@ -762,7 +763,7 @@ func TestStart_GracefullySkipsWhenRetinaEbpfAPIMissing(t *testing.T) {
 		return true, nil
 	}
 	loadRetinaEbpfAPI = func() error {
-		return fmt.Errorf("module not found")
+		return errModuleNotFound
 	}
 	defer func() {
 		isCiliumOnWindowsEnabled = origIsCiliumOnWindowsEnabled

pkg/plugin/ebpfwindows/metricsmap_windows.go

@@ -1,6 +1,7 @@
 package ebpfwindows
 
 import (
+	"errors"
 	"fmt"
 	"syscall"
 	"unsafe"
@@ -70,7 +71,7 @@ var enumCallBack enumMetricsCallback
 // This function will be passed to the Windows API
 func enumMetricsSysCallCallback(key, value unsafe.Pointer) uintptr {
 	if enumCallBack != nil {
-		return uintptr(enumCallBack(key, value))
+		return uintptr(enumCallBack(key, value)) //nolint:gosec // callback return is a bounded status code
 	}
 
 	return 0
@@ -87,7 +88,7 @@ var callEnumMetricsMap = func(callback uintptr) (uintptr, uintptr, error) {
 
 var loadRetinaEbpfAPI = func() error {
 	if err := retinaEbpfAPI.Load(); err != nil {
-		return err
+		return fmt.Errorf("loading retinaEbpfAPI: %w", err)
 	}
 
 	for _, proc := range []*windows.LazyProc{
@@ -97,7 +98,7 @@ var loadRetinaEbpfAPI = func() error {
 		unregisterEventsMapCallback,
 	} {
 		if err := proc.Find(); err != nil {
-			return err
+			return fmt.Errorf("finding proc %s: %w", proc.Name, err)
 		}
 	}
 
@@ -195,7 +196,7 @@ func (k *MetricsKey) IsEgress() bool {
 
 func GetLostEventsCount() (uint64, error) {
 	ret, _, err := lostEventCount.Call()
-	if err != nil && err != syscall.Errno(0) {
+	if err != nil && !errors.Is(err, syscall.Errno(0)) {
 		return 0, fmt.Errorf("RetinaGetLostEventsCount call failed: %w", err)
 	}
 	return uint64(ret), nil

pkg/plugin/ebpfwindows/parser_windows.go

@@ -24,8 +24,10 @@ import (
 	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
-const MaxInt = int(^uint(0) >> 1)
-const MessageTypePktmonDrop = 100
+const (
+	MaxInt = int(^uint(0) >> 1)
+	MessageTypePktmonDrop = 100
+)
 
 type PktmonPacketType uint8
 
@@ -53,9 +55,11 @@ type Parser struct {
 }
 
 var (
-	errDataOffsetTooLarge = errorTypes.New("data offset too large")
-	errNotEnoughBytes     = errorTypes.New("not enough bytes to decode")
-	errDropReasonOverflow = errorTypes.New("drop reason exceeds int32 range")
+	errDataOffsetTooLarge        = errorTypes.New("data offset too large")
+	errNotEnoughBytes            = errorTypes.New("not enough bytes to decode")
+	errDropReasonOverflow        = errorTypes.New("drop reason exceeds int32 range")
+	errUnsupportedIPPacketType   = errorTypes.New("decode layers failed for unsupported IP packet type")
+	errUnsupportedPktmonPacketType = errorTypes.New("decode layers failed for unsupported packet type")
 )
 
 // re-usable packet to avoid reallocating gopacket datastructures
@@ -151,7 +155,7 @@ func (p *Parser) Decode(monitorEvent *observerTypes.MonitorEvent) (*v1.Event, er
 }
 
 // Decode decodes the data from 'data' into 'decoded'
-func (p *Parser) decode(data []byte, decoded *pb.Flow) error {
+func (p *Parser) decode(data []byte, decoded *pb.Flow) error { //nolint:gocyclo // complexity is inherent to protocol decoding logic
 	if len(data) == 0 {
 		return errors.ErrEmptyData
 	}
@@ -244,10 +248,10 @@ func (p *Parser) decode(data []byte, decoded *pb.Flow) error {
 				case 0x6:
 					err = p.packet.decLayerL3Dev.IPv6.DecodeLayers(data[packetOffset:], &p.packet.Layers)
 				default:
-					return fmt.Errorf("decode layers failed for unsupported IP packet type starting with %d, data: %v", data[packetOffset], data[packetOffset:])
+					return fmt.Errorf("%w: starting with %d, data: %v", errUnsupportedIPPacketType, data[packetOffset], data[packetOffset:])
 				}
 			default:
-				return fmt.Errorf("decode layers failed for unsupported packet type %d, data: %v", pdn.PktmonHeader.Metadata.PacketType, data[packetOffset:])
+				return fmt.Errorf("%w: %d, data: %v", errUnsupportedPktmonPacketType, pdn.PktmonHeader.Metadata.PacketType, data[packetOffset:])
 			}
 		} else {
 			var isL3Device, isIPv6 bool
@@ -536,7 +540,7 @@ func decodeIsReply(tn *TraceNotify) *wrapperspb.BoolValue {
 func decodeCiliumEventType(eventType uint8, eventSubType uint32) *pb.CiliumEventType {
 	return &pb.CiliumEventType{
 		Type:    int32(eventType),
-		SubType: int32(eventSubType),
+		SubType: int32(eventSubType), //nolint:gosec // eventSubType is a bounded event code that fits in int32
 	}
 }
 

pkg/plugin/hnsstats/hnsstats_windows.go

@@ -216,10 +216,9 @@ func (h *hnsstats) Start(ctx context.Context) error {
 	h.state = start
 
 	ciliumEnabled, err := plugincommon.IsCiliumOnWindowsEnabled()
-
 	if err != nil {
 		h.l.Error("Error while checking if Cilium is enabled on Windows", zap.Error(err))
-		return fmt.Errorf("Failed to check if Cilium is enabled on Windows: %w", err)
+		return fmt.Errorf("failed to check if Cilium is enabled on Windows: %w", err)
 	}
 
 	if ciliumEnabled {

test/e2e/framework/kubernetes/apply-yaml-config.go

@@ -60,8 +60,8 @@ func (a *ApplyYamlConfig) Run() error {
 	reader := bytes.NewReader(yamlFile)
 	decoder := yaml.NewYAMLOrJSONDecoder(reader, 100)
 	var rawObj unstructured.Unstructured
-	if err := decoder.Decode(&rawObj); err != nil {
-		return fmt.Errorf("error decoding YAML file: %w", err)
+	if decodeErr := decoder.Decode(&rawObj); decodeErr != nil {
+		return fmt.Errorf("error decoding YAML file: %w", decodeErr)
 	}
 
 	// Get GroupVersionResource to invoke the dynamic client
@@ -74,7 +74,7 @@ func (a *ApplyYamlConfig) Run() error {
 
 	// Apply the YAML document
 	namespace := rawObj.GetNamespace()
-	if len(namespace) == 0 {
+	if namespace == "" {
 		namespace = "default"
 	}
 	applyOpts := metav1.ApplyOptions{FieldManager: "kube-apply"}

test/e2e/framework/kubernetes/load-winbpf.go

@@ -2,6 +2,7 @@ package kubernetes
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"strings"
 	"time"
@@ -14,14 +15,19 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 )
 
+var (
+	ErrNoWindowsPodFound = errors.New("no Windows Pod found in label")
+	ErrNoCommandOutput   = errors.New("no output from command")
+	ErrLoadPinBPFFailed  = errors.New("error in loading and pinning BPF maps and program")
+)
+
 type LoadAndPinWinBPF struct {
 	KubeConfigFilePath                 string
 	LoadAndPinWinBPFDeamonSetNamespace string
 	LoadAndPinWinBPFDeamonSetName      string
 }
 
 func WaitForPodReadyWithTimeOut(ctx context.Context, kubeConfigFilePath, namespace, labelSelector string, timeout time.Duration) error {
-
 	config, _ := clientcmd.BuildConfigFromFlags("", kubeConfigFilePath)
 	clientset, _ := kubernetes.NewForConfig(config)
 
@@ -31,12 +37,12 @@ func WaitForPodReadyWithTimeOut(ctx context.Context, kubeConfigFilePath, namespa
 	return WaitForPodReady(timeoutCtx, clientset, namespace, labelSelector)
 }
 
-func ExecCommandInWinPod(KubeConfigFilePath string, cmd string, Namespace string, LabelSelector string, expecNonEmptyOutput bool) (string, error) {
+func ExecCommandInWinPod(kubeConfigFilePath, cmd, namespace, labelSelector string, expecNonEmptyOutput bool) (string, error) {
 	defaultRetrier = retry.Retrier{Attempts: 15, Delay: 5 * time.Second}
 	// Create a context with a timeout (e.g., 120 seconds)
 	ctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
 	defer cancel()
-	config, err := clientcmd.BuildConfigFromFlags("", KubeConfigFilePath)
+	config, err := clientcmd.BuildConfigFromFlags("", kubeConfigFilePath)
 	if err != nil {
 		return "", fmt.Errorf("error building kubeconfig: %w", err)
 	}
@@ -46,8 +52,8 @@ func ExecCommandInWinPod(KubeConfigFilePath string, cmd string, Namespace string
 		return "", fmt.Errorf("error creating Kubernetes client: %w", err)
 	}
 
-	pods, err := clientset.CoreV1().Pods(Namespace).List(ctx, metav1.ListOptions{
-		LabelSelector: LabelSelector,
+	pods, err := clientset.CoreV1().Pods(namespace).List(ctx, metav1.ListOptions{
+		LabelSelector: labelSelector,
 	})
 	if err != nil {
 		return "", fmt.Errorf("error listing pods: %w", err)
@@ -65,7 +71,7 @@ func ExecCommandInWinPod(KubeConfigFilePath string, cmd string, Namespace string
 	}
 
 	if windowsPod == nil {
-		return "", fmt.Errorf("no Windows Pod found in label %s", LabelSelector)
+		return "", fmt.Errorf("%w: %s", ErrNoWindowsPodFound, labelSelector)
 	}
 
 	var outputBytes []byte
@@ -77,12 +83,11 @@ func ExecCommandInWinPod(KubeConfigFilePath string, cmd string, Namespace string
 		}
 
 		if len(outputBytes) == 0 && expecNonEmptyOutput {
-			return fmt.Errorf("no output from command")
+			return ErrNoCommandOutput
 		}
 
 		return nil
 	})
-
 	if err != nil {
 		return "", err
 	}
@@ -92,7 +97,7 @@ func ExecCommandInWinPod(KubeConfigFilePath string, cmd string, Namespace string
 
 func (a *LoadAndPinWinBPF) Run() error {
 	// Copy Event Writer into Node
-	LoadAndPinWinBPFDLabelSelector := fmt.Sprintf("name=%s", a.LoadAndPinWinBPFDeamonSetName)
+	LoadAndPinWinBPFDLabelSelector := "name=" + a.LoadAndPinWinBPFDeamonSetName
 	_, err := ExecCommandInWinPod(a.KubeConfigFilePath, "copy /Y .\\event-writer-helper.bat C:\\event-writer-helper.bat", a.LoadAndPinWinBPFDeamonSetNamespace, LoadAndPinWinBPFDLabelSelector, true)
 	if err != nil {
 		return err
@@ -111,7 +116,7 @@ func (a *LoadAndPinWinBPF) Run() error {
 
 	fmt.Println(output)
 	if strings.Contains(output, "error") || strings.Contains(output, "failed") || strings.Contains(output, "existing") {
-		return fmt.Errorf("error in loading and pinning BPF maps and program: %s", output)
+		return fmt.Errorf("%w: %s", ErrLoadPinBPFFailed, output)
 	}
 	return nil
 }

test/e2e/framework/kubernetes/unload-winbpf.go

@@ -12,7 +12,7 @@ type UnLoadAndPinWinBPF struct {
 }
 
 func (a *UnLoadAndPinWinBPF) Run() error {
-	UnLoadAndPinWinBPFDLabelSelector := fmt.Sprintf("name=%s", a.UnLoadAndPinWinBPFDeamonSetName)
+	UnLoadAndPinWinBPFDLabelSelector := "name=" + a.UnLoadAndPinWinBPFDeamonSetName
 	output, err := ExecCommandInWinPod(a.KubeConfigFilePath, "C:\\event-writer-helper.bat EventWriter-UnPinPrgAndMaps", a.UnLoadAndPinWinBPFDeamonSetNamespace, UnLoadAndPinWinBPFDLabelSelector, false)
 	if err != nil {
 		return err