chore(errors): review all errors in codebase

internal/configuration/settings/errors.go

@@ -4,19 +4,15 @@ import "errors"
 
 var (
 	ErrCityNotValid                    = errors.New("the city specified is not valid")
-	ErrControlServerAddress            = errors.New("listening address it not valid")
-	ErrControlServerPort               = errors.New("listening port it not valid")
 	ErrControlServerPrivilegedPort     = errors.New("cannot use privileged port without running as root")
 	ErrCountryNotValid                 = errors.New("the country specified is not valid")
+	ErrFilepathMissing                 = errors.New("filepath is missing")
 	ErrFirewallZeroPort                = errors.New("cannot have a zero port to block")
 	ErrHostnameNotValid                = errors.New("the hostname specified is not valid")
 	ErrISPNotValid                     = errors.New("the ISP specified is not valid")
+	ErrMissingValue                    = errors.New("missing value")
 	ErrNameNotValid                    = errors.New("the server name specified is not valid")
-	ErrOpenVPNClientCertMissing        = errors.New("client certificate is missing")
-	ErrOpenVPNClientCertNotValid       = errors.New("client certificate is not valid")
 	ErrOpenVPNClientKeyMissing         = errors.New("client key is missing")
-	ErrOpenVPNClientKeyNotValid        = errors.New("client key is not valid")
-	ErrOpenVPNConfigFile               = errors.New("custom configuration file error")
 	ErrOpenVPNCustomPortNotAllowed     = errors.New("custom endpoint port is not allowed")
 	ErrOpenVPNEncryptionPresetNotValid = errors.New("PIA encryption preset is not valid")
 	ErrOpenVPNInterfaceNotValid        = errors.New("interface name is not valid")
@@ -27,8 +23,6 @@ var (
 	ErrOpenVPNVerbosityIsOutOfBounds   = errors.New("verbosity value is out of bounds")
 	ErrOpenVPNVersionIsNotValid        = errors.New("version is not valid")
 	ErrPortForwardingEnabled           = errors.New("port forwarding cannot be enabled")
-	ErrPortForwardingFilepathNotValid  = errors.New("port forwarding filepath given is not valid")
-	ErrPublicIPFilepathNotValid        = errors.New("public IP address file path is not valid")
 	ErrPublicIPPeriodTooShort          = errors.New("public IP address check period is too short")
 	ErrRegionNotValid                  = errors.New("the region specified is not valid")
 	ErrServerAddressNotValid           = errors.New("server listening address is not valid")
@@ -44,9 +38,7 @@ var (
 	ErrWireguardInterfaceAddressNotSet = errors.New("interface address is not set")
 	ErrWireguardInterfaceNotValid      = errors.New("interface name is not valid")
 	ErrWireguardPreSharedKeyNotSet     = errors.New("pre-shared key is not set")
-	ErrWireguardPreSharedKeyNotValid   = errors.New("pre-shared key is not valid")
 	ErrWireguardPrivateKeyNotSet       = errors.New("private key is not set")
-	ErrWireguardPrivateKeyNotValid     = errors.New("private key is not valid")
 	ErrWireguardPublicKeyNotSet        = errors.New("public key is not set")
 	ErrWireguardPublicKeyNotValid      = errors.New("public key is not valid")
 )

internal/configuration/settings/health.go

@@ -27,13 +27,12 @@ func (h Health) Validate() (err error) {
 	_, err = address.Validate(h.ServerAddress,
 		address.OptionListening(uid))
 	if err != nil {
-		return fmt.Errorf("%w: %s",
-			ErrServerAddressNotValid, err)
+		return fmt.Errorf("server listening address is not valid: %w", err)
 	}
 
 	err = h.VPN.validate()
 	if err != nil {
-		return fmt.Errorf("health VPN settings validation failed: %w", err)
+		return fmt.Errorf("health VPN settings: %w", err)
 	}
 
 	return nil

internal/configuration/settings/httpproxy.go

@@ -41,8 +41,7 @@ func (h HTTPProxy) validate() (err error) {
 	uid := os.Getuid()
 	_, err = address.Validate(h.ListeningAddress, address.OptionListening(uid))
 	if err != nil {
-		return fmt.Errorf("%w: %s",
-			ErrServerAddressNotValid, h.ListeningAddress)
+		return fmt.Errorf("%w: %s", ErrServerAddressNotValid, h.ListeningAddress)
 	}
 
 	return nil

internal/configuration/settings/openvpn.go

@@ -93,17 +93,17 @@ func (o OpenVPN) validate(vpnProvider string) (err error) {
 
 	err = validateOpenVPNConfigFilepath(isCustom, *o.ConfFile)
 	if err != nil {
-		return err
+		return fmt.Errorf("custom configuration file: %w", err)
 	}
 
 	err = validateOpenVPNClientCertificate(vpnProvider, *o.ClientCrt)
 	if err != nil {
-		return err
+		return fmt.Errorf("client certificate: %w", err)
 	}
 
 	err = validateOpenVPNClientKey(vpnProvider, *o.ClientKey)
 	if err != nil {
-		return err
+		return fmt.Errorf("client key: %w", err)
 	}
 
 	const maxMSSFix = 10000
@@ -132,12 +132,12 @@ func validateOpenVPNConfigFilepath(isCustom bool,
 	}
 
 	if confFile == "" {
-		return fmt.Errorf("%w: no file path specified", ErrOpenVPNConfigFile)
+		return ErrFilepathMissing
 	}
 
 	err = helpers.FileExists(confFile)
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrOpenVPNConfigFile, err)
+		return err
 	}
 
 	return nil
@@ -150,7 +150,7 @@ func validateOpenVPNClientCertificate(vpnProvider,
 		constants.Cyberghost,
 		constants.VPNUnlimited:
 		if clientCert == "" {
-			return ErrOpenVPNClientCertMissing
+			return ErrMissingValue
 		}
 	}
 
@@ -160,7 +160,7 @@ func validateOpenVPNClientCertificate(vpnProvider,
 
 	_, err = parse.ExtractCert([]byte(clientCert))
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrOpenVPNClientCertNotValid, err)
+		return err
 	}
 	return nil
 }
@@ -172,7 +172,7 @@ func validateOpenVPNClientKey(vpnProvider, clientKey string) (err error) {
 		constants.VPNUnlimited,
 		constants.Wevpn:
 		if clientKey == "" {
-			return ErrOpenVPNClientKeyMissing
+			return ErrMissingValue
 		}
 	}
 
@@ -182,7 +182,7 @@ func validateOpenVPNClientKey(vpnProvider, clientKey string) (err error) {
 
 	_, err = parse.ExtractPrivateKey([]byte(clientKey))
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrOpenVPNClientKeyNotValid, err)
+		return err
 	}
 	return nil
 }

internal/configuration/settings/openvpnselection.go

@@ -33,14 +33,16 @@ func (o OpenVPNSelection) validate(vpnProvider string) (err error) {
 	if confFile := *o.ConfFile; confFile != "" {
 		err := helpers.FileExists(confFile)
 		if err != nil {
-			return fmt.Errorf("%w: %s", ErrOpenVPNConfigFile, err)
+			return fmt.Errorf("configuration file: %w", err)
 		}
 	}
 
 	// Validate TCP
 	if *o.TCP && helpers.IsOneOf(vpnProvider,
+		constants.Ipvanish,
 		constants.Perfectprivacy,
 		constants.Privado,
+		constants.VPNUnlimited,
 		constants.Vyprvpn,
 	) {
 		return fmt.Errorf("%w: for VPN service provider %s",

internal/configuration/settings/portforward.go

@@ -38,7 +38,7 @@ func (p PortForwarding) validate(vpnProvider string) (err error) {
 	if *p.Filepath != "" { // optional
 		_, err := filepath.Abs(*p.Filepath)
 		if err != nil {
-			return fmt.Errorf("%w: %s", ErrPortForwardingFilepathNotValid, err)
+			return fmt.Errorf("filepath is not valid: %w", err)
 		}
 	}
 

internal/configuration/settings/provider.go

@@ -43,12 +43,12 @@ func (p *Provider) validate(vpnType string, allServers models.AllServers) (err e
 
 	err = p.ServerSelection.validate(*p.Name, allServers)
 	if err != nil {
-		return fmt.Errorf("server selection settings validation failed: %w", err)
+		return fmt.Errorf("server selection: %w", err)
 	}
 
 	err = p.PortForwarding.validate(*p.Name)
 	if err != nil {
-		return fmt.Errorf("port forwarding settings validation failed: %w", err)
+		return fmt.Errorf("port forwarding: %w", err)
 	}
 
 	return nil

internal/configuration/settings/publicip.go

@@ -33,7 +33,7 @@ func (p PublicIP) validate() (err error) {
 	if *p.IPFilepath != "" { // optional
 		_, err := filepath.Abs(*p.IPFilepath)
 		if err != nil {
-			return fmt.Errorf("%w: %s", ErrPublicIPFilepathNotValid, err)
+			return fmt.Errorf("filepath is not valid: %w", err)
 		}
 	}
 

internal/configuration/settings/server.go

@@ -23,12 +23,12 @@ type ControlServer struct {
 func (c ControlServer) validate() (err error) {
 	_, portStr, err := net.SplitHostPort(*c.Address)
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrControlServerAddress, err)
+		return fmt.Errorf("listening address is not valid: %w", err)
 	}
 
 	port, err := strconv.Atoi(portStr)
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrControlServerPort, err)
+		return fmt.Errorf("listening port it not valid: %w", err)
 	}
 
 	uid := os.Getuid()

internal/configuration/settings/serverselection.go

@@ -116,18 +116,18 @@ func (ss *ServerSelection) validate(vpnServiceProvider string,
 	if *ss.MultiHopOnly &&
 		vpnServiceProvider != constants.Surfshark {
 		return fmt.Errorf("%w: for VPN service provider %s",
-			ErrStreamOnlyNotSupported, vpnServiceProvider)
+			ErrMultiHopOnlyNotSupported, vpnServiceProvider)
 	}
 
 	if ss.VPN == constants.OpenVPN {
 		err = ss.OpenVPN.validate(vpnServiceProvider)
 		if err != nil {
-			return fmt.Errorf("OpenVPN server selection settings validation failed: %w", err)
+			return fmt.Errorf("OpenVPN server selection settings: %w", err)
 		}
 	} else {
 		err = ss.Wireguard.validate(vpnServiceProvider)
 		if err != nil {
-			return fmt.Errorf("Wireguard server selection settings validation failed: %w", err)
+			return fmt.Errorf("Wireguard server selection settings: %w", err)
 		}
 	}
 

internal/configuration/settings/settings.go

@@ -49,7 +49,7 @@ func (s *Settings) Validate(allServers models.AllServers) (err error) {
 	for name, validation := range nameToValidation {
 		err = validation()
 		if err != nil {
-			return fmt.Errorf("failed validating %s settings: %w", name, err)
+			return fmt.Errorf("%s settings: %w", name, err)
 		}
 	}
 

internal/configuration/settings/vpn.go

@@ -31,18 +31,18 @@ func (v *VPN) validate(allServers models.AllServers) (err error) {
 
 	err = v.Provider.validate(v.Type, allServers)
 	if err != nil {
-		return fmt.Errorf("provider settings validation failed: %w", err)
+		return fmt.Errorf("provider settings: %w", err)
 	}
 
 	if v.Type == constants.OpenVPN {
 		err := v.OpenVPN.validate(*v.Provider.Name)
 		if err != nil {
-			return fmt.Errorf("OpenVPN settings validation failed: %w", err)
+			return fmt.Errorf("OpenVPN settings: %w", err)
 		}
 	} else {
 		err := v.Wireguard.validate(*v.Provider.Name)
 		if err != nil {
-			return fmt.Errorf("Wireguard settings validation failed: %w", err)
+			return fmt.Errorf("Wireguard settings: %w", err)
 		}
 	}
 

internal/configuration/settings/wireguard.go

@@ -50,14 +50,14 @@ func (w Wireguard) validate(vpnProvider string) (err error) {
 	}
 	_, err = wgtypes.ParseKey(*w.PrivateKey)
 	if err != nil {
-		return fmt.Errorf("%w: %s", ErrWireguardPrivateKeyNotValid, err)
+		return fmt.Errorf("private key is not valid: %w", err)
 	}
 
 	// Validate PreSharedKey
 	if *w.PreSharedKey != "" { // Note: this is optional
 		_, err = wgtypes.ParseKey(*w.PreSharedKey)
 		if err != nil {
-			return fmt.Errorf("%w: %s", ErrWireguardPreSharedKeyNotValid, err)
+			return fmt.Errorf("pre-shared key is not valid: %w", err)
 		}
 	}
 

internal/configuration/sources/env/dns.go

@@ -20,7 +20,7 @@ func (r *Reader) readDNS() (dns settings.DNS, err error) {
 
 	dns.DoT, err = r.readDoT()
 	if err != nil {
-		return dns, fmt.Errorf("cannot read DoT settings: %w", err)
+		return dns, fmt.Errorf("DoT settings: %w", err)
 	}
 
 	return dns, nil

internal/configuration/sources/env/firewall.go

@@ -55,8 +55,7 @@ func stringsToPorts(ss []string) (ports []uint16, err error) {
 	for i, s := range ss {
 		port, err := strconv.Atoi(s)
 		if err != nil {
-			return nil, fmt.Errorf("%w: %s: %s",
-				ErrPortParsing, s, err)
+			return nil, fmt.Errorf("%w: %s: %s", ErrPortParsing, s, err)
 		} else if port < 1 || port > 65535 {
 			return nil, fmt.Errorf("%w: must be between 1 and 65535: %d",
 				ErrPortValue, port)
@@ -66,10 +65,6 @@ func stringsToPorts(ss []string) (ports []uint16, err error) {
 	return ports, nil
 }
 
-var (
-	ErrIPNetParsing = errors.New("cannot parse IP network")
-)
-
 func stringsToIPNets(ss []string) (ipNets []net.IPNet, err error) {
 	if len(ss) == 0 {
 		return nil, nil
@@ -78,8 +73,7 @@ func stringsToIPNets(ss []string) (ipNets []net.IPNet, err error) {
 	for i, s := range ss {
 		ip, ipNet, err := net.ParseCIDR(s)
 		if err != nil {
-			return nil, fmt.Errorf("%w: %s: %s",
-				ErrIPNetParsing, s, err)
+			return nil, fmt.Errorf("cannot parse IP network %q: %w", s, err)
 		}
 		ipNet.IP = ip
 		ipNets[i] = *ipNet

internal/configuration/sources/env/health.go

@@ -38,9 +38,7 @@ func (r *Reader) readDurationWithRetro(envKey, retroEnvKey string) (d *time.Dura
 	d = new(time.Duration)
 	*d, err = time.ParseDuration(s)
 	if err != nil {
-		return nil, fmt.Errorf(
-			"environment variable %s: %w",
-			envKey, err)
+		return nil, fmt.Errorf("environment variable %s: %w", envKey, err)
 	}
 
 	return d, nil

internal/configuration/sources/env/helpers.go

@@ -2,7 +2,6 @@ package env
 
 import (
 	"encoding/base64"
-	"errors"
 	"fmt"
 	"os"
 	"strconv"
@@ -115,13 +114,11 @@ func lowerAndSplit(csv string) (values []string) {
 	return strings.Split(csv, ",")
 }
 
-var ErrDecodeBase64 = errors.New("cannot decode base64 string")
-
 func decodeBase64(b64String string) (decoded string, err error) {
 	b, err := base64.StdEncoding.DecodeString(b64String)
 	if err != nil {
-		return "", fmt.Errorf("%w: %s: %s",
-			ErrDecodeBase64, b64String, err)
+		return "", fmt.Errorf("cannot decode base64 string %q: %w",
+			b64String, err)
 	}
 	return string(b), nil
 }

internal/configuration/sources/env/log.go

@@ -48,7 +48,7 @@ func parseLogLevel(s string) (level logging.Level, err error) {
 		return logging.LevelError, nil
 	default:
 		return level, fmt.Errorf(
-			"%w: %s: can be one of: debug, info, warning or error",
+			"%w: %q is not valid and can be one of debug, info, warning or error",
 			ErrLogLevelUnknown, s)
 	}
 }

internal/configuration/sources/env/provider.go

@@ -18,12 +18,12 @@ func (r *Reader) readProvider(vpnType string) (provider settings.Provider, err e
 
 	provider.ServerSelection, err = r.readServerSelection(providerName, vpnType)
 	if err != nil {
-		return provider, fmt.Errorf("cannot read server selection settings: %w", err)
+		return provider, fmt.Errorf("server selection: %w", err)
 	}
 
 	provider.PortForwarding, err = r.readPortForward()
 	if err != nil {
-		return provider, fmt.Errorf("cannot read port forwarding settings: %w", err)
+		return provider, fmt.Errorf("port forwarding: %w", err)
 	}
 
 	return provider, nil

internal/configuration/sources/env/vpn.go

@@ -13,17 +13,17 @@ func (r *Reader) readVPN() (vpn settings.VPN, err error) {
 
 	vpn.Provider, err = r.readProvider(vpn.Type)
 	if err != nil {
-		return vpn, fmt.Errorf("cannot read provider settings: %w", err)
+		return vpn, fmt.Errorf("VPN provider: %w", err)
 	}
 
 	vpn.OpenVPN, err = r.readOpenVPN()
 	if err != nil {
-		return vpn, fmt.Errorf("cannot read OpenVPN settings: %w", err)
+		return vpn, fmt.Errorf("OpenVPN: %w", err)
 	}
 
 	vpn.Wireguard, err = r.readWireguard()
 	if err != nil {
-		return vpn, fmt.Errorf("cannot read Wireguard settings: %w", err)
+		return vpn, fmt.Errorf("wireguard: %w", err)
 	}
 
 	return vpn, nil

internal/configuration/sources/files/openvpn.go

@@ -16,12 +16,12 @@ const (
 func (r *Reader) readOpenVPN() (settings settings.OpenVPN, err error) {
 	settings.ClientKey, err = ReadFromFile(OpenVPNClientKeyPath)
 	if err != nil {
-		return settings, fmt.Errorf("cannot read client key: %w", err)
+		return settings, fmt.Errorf("client key: %w", err)
 	}
 
 	settings.ClientCrt, err = ReadFromFile(OpenVPNClientCertificatePath)
 	if err != nil {
-		return settings, fmt.Errorf("cannot read client certificate: %w", err)
+		return settings, fmt.Errorf("client certificate: %w", err)
 	}
 
 	return settings, nil

internal/configuration/sources/files/vpn.go

@@ -9,7 +9,7 @@ import (
 func (r *Reader) readVPN() (vpn settings.VPN, err error) {
 	vpn.OpenVPN, err = r.readOpenVPN()
 	if err != nil {
-		return vpn, fmt.Errorf("cannot read OpenVPN settings: %w", err)
+		return vpn, fmt.Errorf("OpenVPN: %w", err)
 	}
 
 	return vpn, nil

internal/configuration/sources/mux/reader.go

@@ -26,7 +26,7 @@ func (r *Reader) Read() (settings settings.Settings, err error) {
 	for _, source := range r.sources {
 		settingsFromSource, err := source.Read()
 		if err != nil {
-			return settings, fmt.Errorf("cannot read from source %T: %w", source, err)
+			return settings, fmt.Errorf("reading from source %T: %w", source, err)
 		}
 		settings.MergeWith(settingsFromSource)
 	}
@@ -42,7 +42,7 @@ func (r *Reader) ReadHealth() (settings settings.Health, err error) {
 	for _, source := range r.sources {
 		settingsFromSource, err := source.ReadHealth()
 		if err != nil {
-			return settings, fmt.Errorf("cannot read from source %T: %w", source, err)
+			return settings, fmt.Errorf("reading from source %T: %w", source, err)
 		}
 		settings.MergeWith(settingsFromSource)
 	}