mirror of
https://github.com/juanfont/headscale.git
synced 2026-01-23 02:24:10 +00:00
25fdad3949
Add comprehensive sentinel errors for all error conditions in the policy
engine and use consistent error wrapping patterns with fmt.Errorf("%w: ...).
Update test expectations to match the new error message formats.
114 lines
3 KiB
Go
114 lines
3 KiB
Go
package v2
|
|
|
|
import (
|
|
"errors"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"tailscale.com/tailcfg"
|
|
)
|
|
|
|
// Sentinel errors for port and destination parsing.
|
|
var (
|
|
ErrInputMissingColon = errors.New("input must contain a colon character separating destination and port")
|
|
ErrInputStartsWithColon = errors.New("input cannot start with a colon character")
|
|
ErrInputEndsWithColon = errors.New("input cannot end with a colon character")
|
|
ErrInvalidPortRange = errors.New("invalid port range format")
|
|
ErrPortRangeInverted = errors.New("invalid port range: first port is greater than last port")
|
|
ErrPortMustBePositive = errors.New("first port must be >0, or use '*' for wildcard")
|
|
ErrInvalidPortNumber = errors.New("invalid port number")
|
|
ErrPortOutOfRange = errors.New("port number out of range")
|
|
)
|
|
|
|
// splitDestinationAndPort takes an input string and returns the destination and port as a tuple, or an error if the input is invalid.
|
|
func splitDestinationAndPort(input string) (string, string, error) {
|
|
// Find the last occurrence of the colon character
|
|
lastColonIndex := strings.LastIndex(input, ":")
|
|
|
|
// Check if the colon character is present and not at the beginning or end of the string
|
|
if lastColonIndex == -1 {
|
|
return "", "", ErrInputMissingColon
|
|
}
|
|
|
|
if lastColonIndex == 0 {
|
|
return "", "", ErrInputStartsWithColon
|
|
}
|
|
|
|
if lastColonIndex == len(input)-1 {
|
|
return "", "", ErrInputEndsWithColon
|
|
}
|
|
|
|
// Split the string into destination and port based on the last colon
|
|
destination := input[:lastColonIndex]
|
|
port := input[lastColonIndex+1:]
|
|
|
|
return destination, port, nil
|
|
}
|
|
|
|
// parsePortRange parses a port definition string and returns a slice of PortRange structs.
|
|
func parsePortRange(portDef string) ([]tailcfg.PortRange, error) {
|
|
if portDef == "*" {
|
|
return []tailcfg.PortRange{tailcfg.PortRangeAny}, nil
|
|
}
|
|
|
|
var portRanges []tailcfg.PortRange
|
|
|
|
parts := strings.SplitSeq(portDef, ",")
|
|
|
|
for part := range parts {
|
|
if strings.Contains(part, "-") {
|
|
rangeParts := strings.Split(part, "-")
|
|
|
|
rangeParts = slices.DeleteFunc(rangeParts, func(e string) bool {
|
|
return e == ""
|
|
})
|
|
if len(rangeParts) != 2 {
|
|
return nil, ErrInvalidPortRange
|
|
}
|
|
|
|
first, err := parsePort(rangeParts[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
last, err := parsePort(rangeParts[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if first > last {
|
|
return nil, ErrPortRangeInverted
|
|
}
|
|
|
|
portRanges = append(portRanges, tailcfg.PortRange{First: first, Last: last})
|
|
} else {
|
|
port, err := parsePort(part)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if port < 1 {
|
|
return nil, ErrPortMustBePositive
|
|
}
|
|
|
|
portRanges = append(portRanges, tailcfg.PortRange{First: port, Last: port})
|
|
}
|
|
}
|
|
|
|
return portRanges, nil
|
|
}
|
|
|
|
// parsePort parses a single port number from a string.
|
|
func parsePort(portStr string) (uint16, error) {
|
|
port, err := strconv.Atoi(portStr)
|
|
if err != nil {
|
|
return 0, ErrInvalidPortNumber
|
|
}
|
|
|
|
if port < 0 || port > 65535 {
|
|
return 0, ErrPortOutOfRange
|
|
}
|
|
|
|
return uint16(port), nil
|
|
}
|