nat: ParsePortRange, ParsePortRangeToInt: reimplement with parsePortNumber

- Split the implementations from the exported ParsePortRange function.
- The implementation returns an int for ports (instead of an uint64),
  which we cast to the right type in ParsePortRange.
- The parsePortNumber gives more informative errors.

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

Author: thaJeztah

nat/nat.go

@@ -55,15 +55,12 @@ func ParsePort(rawPort string) (int, error) {
 }
 
 // ParsePortRangeToInt parses the port range string and returns start/end ints
-func ParsePortRangeToInt(rawPort string) (int, int, error) {
+func ParsePortRangeToInt(rawPort string) (startPort, endPort int, _ error) {
 	if rawPort == "" {
+		// TODO(thaJeztah): consider making this an error; this was kept to keep existing behavior.
 		return 0, 0, nil
 	}
-	start, end, err := ParsePortRange(rawPort)
-	if err != nil {
-		return 0, 0, err
-	}
-	return int(start), int(end), nil
+	return parsePortRange(rawPort)
 }
 
 // Proto returns the protocol of a Port

nat/parse.go

@@ -2,34 +2,40 @@ package nat
 
 import (
 	"errors"
+	"fmt"
 	"strconv"
 	"strings"
 )
 
-// ParsePortRange parses and validates the specified string as a port-range (8000-9000)
-func ParsePortRange(ports string) (uint64, uint64, error) {
+// ParsePortRange parses and validates the specified string as a port range (e.g., "8000-9000").
+func ParsePortRange(ports string) (startPort, endPort uint64, _ error) {
+	start, end, err := parsePortRange(ports)
+	return uint64(start), uint64(end), err
+}
+
+// parsePortRange parses and validates the specified string as a port range (e.g., "8000-9000").
+func parsePortRange(ports string) (startPort, endPort int, _ error) {
 	if ports == "" {
 		return 0, 0, errors.New("empty string specified for ports")
 	}
-	if !strings.Contains(ports, "-") {
-		start, err := strconv.ParseUint(ports, 10, 16)
-		end := start
-		return start, end, err
-	}
+	start, end, ok := strings.Cut(ports, "-")
 
-	parts := strings.Split(ports, "-")
-	start, err := strconv.ParseUint(parts[0], 10, 16)
+	startPort, err := parsePortNumber(start)
 	if err != nil {
-		return 0, 0, err
+		return 0, 0, fmt.Errorf("invalid start port '%s': %w", start, err)
 	}
-	end, err := strconv.ParseUint(parts[1], 10, 16)
+	if !ok || start == end {
+		return startPort, startPort, nil
+	}
+
+	endPort, err = parsePortNumber(end)
 	if err != nil {
-		return 0, 0, err
+		return 0, 0, fmt.Errorf("invalid end port '%s': %w", end, err)
 	}
-	if end < start {
-		return 0, 0, errors.New("invalid range specified for port: " + ports)
+	if endPort < startPort {
+		return 0, 0, errors.New("invalid port range: " + ports)
 	}
-	return start, end, nil
+	return startPort, endPort, nil
 }
 
 // parsePortNumber parses rawPort into an int, unwrapping strconv errors

nat/parse_test.go

@@ -50,52 +50,52 @@ func TestParsePortRange(t *testing.T) {
 		{
 			doc:    "non-numeric port",
 			input:  "asdf",
-			expErr: `strconv.ParseUint: parsing "asdf": invalid syntax`,
+			expErr: `invalid start port 'asdf': invalid syntax`,
 		},
 		{
 			doc:    "reversed range",
 			input:  "9000-8000",
-			expErr: `invalid range specified for port: 9000-8000`,
+			expErr: `invalid port range: 9000-8000`,
 		},
 		{
 			doc:    "range missing end",
 			input:  "8000-",
-			expErr: `strconv.ParseUint: parsing "": invalid syntax`,
+			expErr: `invalid end port '': value is empty`,
 		},
 		{
 			doc:    "range missing start",
 			input:  "-9000",
-			expErr: `strconv.ParseUint: parsing "": invalid syntax`,
+			expErr: `invalid start port '': value is empty`,
 		},
 		{
 			doc:    "invalid range end",
 			input:  "8000-a",
-			expErr: `strconv.ParseUint: parsing "a": invalid syntax`,
+			expErr: `invalid end port 'a': invalid syntax`,
 		},
 		{
 			doc:    "invalid range end port",
 			input:  "8000-9000a",
-			expErr: `strconv.ParseUint: parsing "9000a": invalid syntax`,
+			expErr: `invalid end port '9000a': invalid syntax`,
 		},
 		{
 			doc:    "range range start",
 			input:  "a-9000",
-			expErr: `strconv.ParseUint: parsing "a": invalid syntax`,
+			expErr: `invalid start port 'a': invalid syntax`,
 		},
 		{
 			doc:    "range range start port",
 			input:  "8000a-9000",
-			expErr: `strconv.ParseUint: parsing "8000a": invalid syntax`,
+			expErr: `invalid start port '8000a': invalid syntax`,
 		},
 		{
 			doc:    "range with trailing hyphen",
 			input:  "-8000-",
-			expErr: `strconv.ParseUint: parsing "": invalid syntax`,
+			expErr: `invalid start port '': value is empty`,
 		},
 		{
 			doc:    "range without ports",
 			input:  "-",
-			expErr: `strconv.ParseUint: parsing "": invalid syntax`,
+			expErr: `invalid start port '': value is empty`,
 		},
 	}