nat: add parsePortNumber utility

Add a utility for parsing and validating port-numbers to reduce
repetition and improve errors.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

nat/nat.go

@@ -47,11 +47,11 @@ func ParsePort(rawPort string) (int, error) {
 	if rawPort == "" {
 		return 0, nil
 	}
-	port, err := strconv.ParseUint(rawPort, 10, 16)
+	port, err := parsePortNumber(rawPort)
 	if err != nil {
-		return 0, fmt.Errorf("invalid port '%s': %w", rawPort, errors.Unwrap(err))
+		return 0, fmt.Errorf("invalid port '%s': %w", rawPort, err)
 	}
-	return int(port), nil
+	return port, nil
 }
 
 // ParsePortRangeToInt parses the port range string and returns start/end ints

nat/nat_test.go

@@ -38,7 +38,7 @@ func TestParsePort(t *testing.T) {
 			doc:     "negative value",
 			input:   "-1",
 			expPort: 0,
-			expErr:  `invalid port '-1': invalid syntax`,
+			expErr:  `invalid port '-1': value out of range (0–65535)`,
 		},
 		// FIXME currently this is a valid port. I don't think it should be.
 		// I'm leaving this test until we make a decision.
@@ -57,7 +57,7 @@ func TestParsePort(t *testing.T) {
 			doc:     "value out of range",
 			input:   "65536",
 			expPort: 0,
-			expErr:  `invalid port '65536': value out of range`,
+			expErr:  `invalid port '65536': value out of range (0–65535)`,
 		},
 	}
 

nat/parse.go

@@ -31,3 +31,24 @@ func ParsePortRange(ports string) (uint64, uint64, error) {
 	}
 	return start, end, nil
 }
+
+// parsePortNumber parses rawPort into an int, unwrapping strconv errors
+// and returning a single "out of range" error for any value outside 0–65535.
+func parsePortNumber(rawPort string) (int, error) {
+	if rawPort == "" {
+		return 0, errors.New("value is empty")
+	}
+	port, err := strconv.ParseInt(rawPort, 10, 0)
+	if err != nil {
+		var numErr *strconv.NumError
+		if errors.As(err, &numErr) {
+			err = numErr.Err
+		}
+		return 0, err
+	}
+	if port < 0 || port > 65535 {
+		return 0, errors.New("value out of range (0–65535)")
+	}
+
+	return int(port), nil
+}

nat/parse_test.go

@@ -120,3 +120,85 @@ func TestParsePortRange(t *testing.T) {
 		})
 	}
 }
+
+func TestParsePortNumber(t *testing.T) {
+	tests := []struct {
+		doc    string
+		input  string
+		exp    int
+		expErr string
+	}{
+		{
+			doc:    "empty string",
+			input:  "",
+			expErr: "value is empty",
+		},
+		{
+			doc:    "whitespace only",
+			input:  "   ",
+			expErr: "invalid syntax",
+		},
+		{
+			doc:   "single valid port",
+			input: "1234",
+			exp:   1234,
+		},
+		{
+			doc:   "zero port",
+			input: "0",
+			exp:   0,
+		},
+		{
+			doc:   "max valid port",
+			input: "65535",
+			exp:   65535,
+		},
+		{
+			doc:    "leading/trailing spaces",
+			input:  "  42  ",
+			expErr: "invalid syntax",
+		},
+		{
+			doc:    "negative port",
+			input:  "-1",
+			expErr: "value out of range (0–65535)",
+		},
+		{
+			doc:    "too large port",
+			input:  "70000",
+			expErr: "value out of range (0–65535)",
+		},
+		{
+			doc:    "non-numeric",
+			input:  "foo",
+			expErr: "invalid syntax",
+		},
+		{
+			doc:    "trailing garbage",
+			input:  "1234abc",
+			expErr: "invalid syntax",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.doc, func(t *testing.T) {
+			got, err := parsePortNumber(tc.input)
+
+			if tc.expErr == "" {
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+				if got != tc.exp {
+					t.Errorf("expected %d, got %d", tc.exp, got)
+				}
+			} else {
+				if err == nil {
+					t.Fatalf("expected error %q, got nil", tc.expErr)
+				}
+				if err.Error() != tc.expErr {
+					t.Errorf("expected error %q, got %q", tc.expErr, err.Error())
+				}
+			}
+		})
+	}
+}