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)
 		}
 	}