diff --git a/internal/params/dns.go b/internal/params/dns.go index db9b9af5..7c287ae5 100644 --- a/internal/params/dns.go +++ b/internal/params/dns.go @@ -13,14 +13,14 @@ import ( // GetDNSOverTLS obtains if the DNS over TLS should be enabled // from the environment variable DOT -func (p *reader) GetDNSOverTLS() (DNSOverTLS bool, err error) { //nolint:gocritic - return p.envParams.GetOnOff("DOT", libparams.Default("on")) +func (r *reader) GetDNSOverTLS() (DNSOverTLS bool, err error) { //nolint:gocritic + return r.envParams.GetOnOff("DOT", libparams.Default("on")) } // GetDNSOverTLSProviders obtains the DNS over TLS providers to use // from the environment variable DOT_PROVIDERS -func (p *reader) GetDNSOverTLSProviders() (providers []models.DNSProvider, err error) { - s, err := p.envParams.GetEnv("DOT_PROVIDERS", libparams.Default("cloudflare")) +func (r *reader) GetDNSOverTLSProviders() (providers []models.DNSProvider, err error) { + s, err := r.envParams.GetEnv("DOT_PROVIDERS", libparams.Default("cloudflare")) if err != nil { return nil, err } @@ -38,56 +38,56 @@ func (p *reader) GetDNSOverTLSProviders() (providers []models.DNSProvider, err e // GetDNSOverTLSVerbosity obtains the verbosity level to use for Unbound // from the environment variable DOT_VERBOSITY -func (p *reader) GetDNSOverTLSVerbosity() (verbosityLevel uint8, err error) { - n, err := p.envParams.GetEnvIntRange("DOT_VERBOSITY", 0, 5, libparams.Default("1")) +func (r *reader) GetDNSOverTLSVerbosity() (verbosityLevel uint8, err error) { + n, err := r.envParams.GetEnvIntRange("DOT_VERBOSITY", 0, 5, libparams.Default("1")) return uint8(n), err } // GetDNSOverTLSVerbosityDetails obtains the log level to use for Unbound // from the environment variable DOT_VERBOSITY_DETAILS -func (p *reader) GetDNSOverTLSVerbosityDetails() (verbosityDetailsLevel uint8, err error) { - n, err := p.envParams.GetEnvIntRange("DOT_VERBOSITY_DETAILS", 0, 4, libparams.Default("0")) +func (r *reader) GetDNSOverTLSVerbosityDetails() (verbosityDetailsLevel uint8, err error) { + n, err := r.envParams.GetEnvIntRange("DOT_VERBOSITY_DETAILS", 0, 4, libparams.Default("0")) return uint8(n), err } // GetDNSOverTLSValidationLogLevel obtains the log level to use for Unbound DOT validation // from the environment variable DOT_VALIDATION_LOGLEVEL -func (p *reader) GetDNSOverTLSValidationLogLevel() (validationLogLevel uint8, err error) { - n, err := p.envParams.GetEnvIntRange("DOT_VALIDATION_LOGLEVEL", 0, 2, libparams.Default("0")) +func (r *reader) GetDNSOverTLSValidationLogLevel() (validationLogLevel uint8, err error) { + n, err := r.envParams.GetEnvIntRange("DOT_VALIDATION_LOGLEVEL", 0, 2, libparams.Default("0")) return uint8(n), err } // GetDNSMaliciousBlocking obtains if malicious hostnames/IPs should be blocked // from being resolved by Unbound, using the environment variable BLOCK_MALICIOUS -func (p *reader) GetDNSMaliciousBlocking() (blocking bool, err error) { - return p.envParams.GetOnOff("BLOCK_MALICIOUS", libparams.Default("on")) +func (r *reader) GetDNSMaliciousBlocking() (blocking bool, err error) { + return r.envParams.GetOnOff("BLOCK_MALICIOUS", libparams.Default("on")) } // GetDNSSurveillanceBlocking obtains if surveillance hostnames/IPs should be blocked // from being resolved by Unbound, using the environment variable BLOCK_SURVEILLANCE // and BLOCK_NSA for retrocompatibility -func (p *reader) GetDNSSurveillanceBlocking() (blocking bool, err error) { +func (r *reader) GetDNSSurveillanceBlocking() (blocking bool, err error) { // Retro-compatibility - s, err := p.envParams.GetEnv("BLOCK_NSA") + s, err := r.envParams.GetEnv("BLOCK_NSA") if err != nil { return false, err } else if len(s) != 0 { - p.logger.Warn("You are using the old environment variable BLOCK_NSA, please consider changing it to BLOCK_SURVEILLANCE") - return p.envParams.GetOnOff("BLOCK_NSA", libparams.Compulsory()) + r.logger.Warn("You are using the old environment variable BLOCK_NSA, please consider changing it to BLOCK_SURVEILLANCE") + return r.envParams.GetOnOff("BLOCK_NSA", libparams.Compulsory()) } - return p.envParams.GetOnOff("BLOCK_SURVEILLANCE", libparams.Default("off")) + return r.envParams.GetOnOff("BLOCK_SURVEILLANCE", libparams.Default("off")) } // GetDNSAdsBlocking obtains if ads hostnames/IPs should be blocked // from being resolved by Unbound, using the environment variable BLOCK_ADS -func (p *reader) GetDNSAdsBlocking() (blocking bool, err error) { - return p.envParams.GetOnOff("BLOCK_ADS", libparams.Default("off")) +func (r *reader) GetDNSAdsBlocking() (blocking bool, err error) { + return r.envParams.GetOnOff("BLOCK_ADS", libparams.Default("off")) } // GetDNSUnblockedHostnames obtains a list of hostnames to unblock from block lists // from the comma separated list for the environment variable UNBLOCK -func (p *reader) GetDNSUnblockedHostnames() (hostnames []string, err error) { - s, err := p.envParams.GetEnv("UNBLOCK") +func (r *reader) GetDNSUnblockedHostnames() (hostnames []string, err error) { + s, err := r.envParams.GetEnv("UNBLOCK") if err != nil { return nil, err } else if len(s) == 0 { @@ -95,7 +95,7 @@ func (p *reader) GetDNSUnblockedHostnames() (hostnames []string, err error) { } hostnames = strings.Split(s, ",") for _, hostname := range hostnames { - if !p.verifier.MatchHostname(hostname) { + if !r.verifier.MatchHostname(hostname) { return nil, fmt.Errorf("hostname %q does not seem valid", hostname) } } @@ -104,14 +104,14 @@ func (p *reader) GetDNSUnblockedHostnames() (hostnames []string, err error) { // GetDNSOverTLSCaching obtains if Unbound caching should be enable or not // from the environment variable DOT_CACHING -func (p *reader) GetDNSOverTLSCaching() (caching bool, err error) { - return p.envParams.GetOnOff("DOT_CACHING") +func (r *reader) GetDNSOverTLSCaching() (caching bool, err error) { + return r.envParams.GetOnOff("DOT_CACHING") } // GetDNSOverTLSPrivateAddresses obtains if Unbound caching should be enable or not // from the environment variable DOT_PRIVATE_ADDRESS -func (p *reader) GetDNSOverTLSPrivateAddresses() (privateAddresses []string, err error) { - s, err := p.envParams.GetEnv("DOT_PRIVATE_ADDRESS") +func (r *reader) GetDNSOverTLSPrivateAddresses() (privateAddresses []string, err error) { + s, err := r.envParams.GetEnv("DOT_PRIVATE_ADDRESS") if err != nil { return nil, err } else if len(s) == 0 { @@ -130,14 +130,14 @@ func (p *reader) GetDNSOverTLSPrivateAddresses() (privateAddresses []string, err // GetDNSOverTLSIPv6 obtains if Unbound should resolve ipv6 addresses using ipv6 DNS over TLS // servers from the environment variable DOT_IPV6 -func (p *reader) GetDNSOverTLSIPv6() (ipv6 bool, err error) { - return p.envParams.GetOnOff("DOT_IPV6", libparams.Default("off")) +func (r *reader) GetDNSOverTLSIPv6() (ipv6 bool, err error) { + return r.envParams.GetOnOff("DOT_IPV6", libparams.Default("off")) } // GetDNSUpdatePeriod obtains the period to use to update the block lists and cryptographic files // and restart Unbound from the environment variable DNS_UPDATE_PERIOD -func (p *reader) GetDNSUpdatePeriod() (period time.Duration, err error) { - s, err := p.envParams.GetEnv("DNS_UPDATE_PERIOD", libparams.Default("24h")) +func (r *reader) GetDNSUpdatePeriod() (period time.Duration, err error) { + s, err := r.envParams.GetEnv("DNS_UPDATE_PERIOD", libparams.Default("24h")) if err != nil { return period, err } diff --git a/internal/params/firewall.go b/internal/params/firewall.go index aa260a00..984bef3b 100644 --- a/internal/params/firewall.go +++ b/internal/params/firewall.go @@ -8,8 +8,8 @@ import ( // GetExtraSubnets obtains the CIDR subnets from the comma separated list of the // environment variable EXTRA_SUBNETS -func (p *reader) GetExtraSubnets() (extraSubnets []net.IPNet, err error) { - s, err := p.envParams.GetEnv("EXTRA_SUBNETS") +func (r *reader) GetExtraSubnets() (extraSubnets []net.IPNet, err error) { + s, err := r.envParams.GetEnv("EXTRA_SUBNETS") if err != nil { return nil, err } else if s == "" { diff --git a/internal/params/mullvad.go b/internal/params/mullvad.go index f2e18396..aba58d13 100644 --- a/internal/params/mullvad.go +++ b/internal/params/mullvad.go @@ -10,31 +10,31 @@ import ( // GetMullvadCountry obtains the country for the Mullvad server from the // environment variable COUNTRY -func (p *reader) GetMullvadCountry() (country models.MullvadCountry, err error) { +func (r *reader) GetMullvadCountry() (country models.MullvadCountry, err error) { choices := append(constants.MullvadCountryChoices(), "") - s, err := p.envParams.GetValueIfInside("COUNTRY", choices) + s, err := r.envParams.GetValueIfInside("COUNTRY", choices) return models.MullvadCountry(strings.ToLower(s)), err } // GetMullvadCity obtains the city for the Mullvad server from the // environment variable CITY -func (p *reader) GetMullvadCity() (country models.MullvadCity, err error) { +func (r *reader) GetMullvadCity() (country models.MullvadCity, err error) { choices := append(constants.MullvadCityChoices(), "") - s, err := p.envParams.GetValueIfInside("CITY", choices) + s, err := r.envParams.GetValueIfInside("CITY", choices) return models.MullvadCity(strings.ToLower(s)), err } // GetMullvadISP obtains the ISP for the Mullvad server from the // environment variable ISP -func (p *reader) GetMullvadISP() (country models.MullvadProvider, err error) { +func (r *reader) GetMullvadISP() (country models.MullvadProvider, err error) { choices := append(constants.MullvadProviderChoices(), "") - s, err := p.envParams.GetValueIfInside("ISP", choices) + s, err := r.envParams.GetValueIfInside("ISP", choices) return models.MullvadProvider(strings.ToLower(s)), err } // GetMullvadPort obtains the port to reach the Mullvad server on from the // environment variable PORT -func (p *reader) GetMullvadPort() (port uint16, err error) { - n, err := p.envParams.GetEnvIntRange("PORT", 0, 65535, libparams.Default("0")) +func (r *reader) GetMullvadPort() (port uint16, err error) { + n, err := r.envParams.GetEnvIntRange("PORT", 0, 65535, libparams.Default("0")) return uint16(n), err } diff --git a/internal/params/openvpn.go b/internal/params/openvpn.go index cd872337..4d6d813a 100644 --- a/internal/params/openvpn.go +++ b/internal/params/openvpn.go @@ -10,51 +10,51 @@ import ( ) // GetUser obtains the user to use to connect to the VPN servers -func (p *reader) GetUser() (s string, err error) { +func (r *reader) GetUser() (s string, err error) { defer func() { - unsetenvErr := p.unsetEnv("USER") + unsetenvErr := r.unsetEnv("USER") if err == nil { err = unsetenvErr } }() - return p.envParams.GetEnv("USER", libparams.CaseSensitiveValue(), libparams.Compulsory()) + return r.envParams.GetEnv("USER", libparams.CaseSensitiveValue(), libparams.Compulsory()) } // GetPassword obtains the password to use to connect to the VPN servers -func (p *reader) GetPassword() (s string, err error) { +func (r *reader) GetPassword() (s string, err error) { defer func() { - unsetenvErr := p.unsetEnv("PASSWORD") + unsetenvErr := r.unsetEnv("PASSWORD") if err == nil { err = unsetenvErr } }() - return p.envParams.GetEnv("PASSWORD", libparams.CaseSensitiveValue(), libparams.Compulsory()) + return r.envParams.GetEnv("PASSWORD", libparams.CaseSensitiveValue(), libparams.Compulsory()) } // GetNetworkProtocol obtains the network protocol to use to connect to the // VPN servers from the environment variable PROTOCOL -func (p *reader) GetNetworkProtocol() (protocol models.NetworkProtocol, err error) { - s, err := p.envParams.GetValueIfInside("PROTOCOL", []string{"tcp", "udp"}, libparams.Default("udp")) +func (r *reader) GetNetworkProtocol() (protocol models.NetworkProtocol, err error) { + s, err := r.envParams.GetValueIfInside("PROTOCOL", []string{"tcp", "udp"}, libparams.Default("udp")) return models.NetworkProtocol(s), err } // GetOpenVPNVerbosity obtains the verbosity level for verbosity between 0 and 6 // from the environment variable OPENVPN_VERBOSITY -func (p *reader) GetOpenVPNVerbosity() (verbosity int, err error) { - return p.envParams.GetEnvIntRange("OPENVPN_VERBOSITY", 0, 6, libparams.Default("1")) +func (r *reader) GetOpenVPNVerbosity() (verbosity int, err error) { + return r.envParams.GetEnvIntRange("OPENVPN_VERBOSITY", 0, 6, libparams.Default("1")) } // GetOpenVPNRoot obtains if openvpn should be run as root // from the environment variable OPENVPN_ROOT -func (p *reader) GetOpenVPNRoot() (root bool, err error) { - return p.envParams.GetYesNo("OPENVPN_ROOT", libparams.Default("no")) +func (r *reader) GetOpenVPNRoot() (root bool, err error) { + return r.envParams.GetYesNo("OPENVPN_ROOT", libparams.Default("no")) } // GetTargetIP obtains the IP address to choose from the list of IP addresses // available for a particular region, from the environment variable // OPENVPN_TARGET_IP -func (p *reader) GetTargetIP() (ip net.IP, err error) { - s, err := p.envParams.GetEnv("OPENVPN_TARGET_IP") +func (r *reader) GetTargetIP() (ip net.IP, err error) { + s, err := r.envParams.GetEnv("OPENVPN_TARGET_IP") if len(s) == 0 { return nil, nil } else if err != nil { @@ -69,14 +69,14 @@ func (p *reader) GetTargetIP() (ip net.IP, err error) { // GetOpenVPNCipher obtains a custom cipher to use with OpenVPN // from the environment variable OPENVPN_CIPHER -func (p *reader) GetOpenVPNCipher() (cipher string, err error) { - cipher, err = p.envParams.GetEnv("OPENVPN_CIPHER") +func (r *reader) GetOpenVPNCipher() (cipher string, err error) { + cipher, err = r.envParams.GetEnv("OPENVPN_CIPHER") return strings.ToLower(cipher), err } // GetOpenVPNAuth obtains a custom auth algorithm to use with OpenVPN // from the environment variable OPENVPN_AUTH -func (p *reader) GetOpenVPNAuth() (auth string, err error) { - auth, err = p.envParams.GetEnv("OPENVPN_AUTH") +func (r *reader) GetOpenVPNAuth() (auth string, err error) { + auth, err = r.envParams.GetEnv("OPENVPN_AUTH") return strings.ToLower(auth), err } diff --git a/internal/params/params.go b/internal/params/params.go index a020d5a7..d75c030b 100644 --- a/internal/params/params.go +++ b/internal/params/params.go @@ -107,8 +107,8 @@ func NewReader(logger logging.Logger) Reader { } // GetVPNSP obtains the VPN service provider to use from the environment variable VPNSP -func (p *reader) GetVPNSP() (vpnServiceProvider models.VPNProvider, err error) { - s, err := p.envParams.GetValueIfInside("VPNSP", []string{"pia", "private internet access", "mullvad", "windscribe", "surfshark"}) +func (r *reader) GetVPNSP() (vpnServiceProvider models.VPNProvider, err error) { + s, err := r.envParams.GetValueIfInside("VPNSP", []string{"pia", "private internet access", "mullvad", "windscribe", "surfshark"}) if s == "pia" { s = "private internet access" } diff --git a/internal/params/pia.go b/internal/params/pia.go index 0d5c0105..4ddd17c3 100644 --- a/internal/params/pia.go +++ b/internal/params/pia.go @@ -11,8 +11,8 @@ import ( // GetPortForwarding obtains if port forwarding on the VPN provider server // side is enabled or not from the environment variable PORT_FORWARDING -func (p *reader) GetPortForwarding() (activated bool, err error) { - s, err := p.envParams.GetEnv("PORT_FORWARDING", libparams.Default("off")) +func (r *reader) GetPortForwarding() (activated bool, err error) { + s, err := r.envParams.GetEnv("PORT_FORWARDING", libparams.Default("off")) if err != nil { return false, err } @@ -27,32 +27,32 @@ func (p *reader) GetPortForwarding() (activated bool, err error) { // GetPortForwardingStatusFilepath obtains the port forwarding status file path // from the environment variable PORT_FORWARDING_STATUS_FILE -func (p *reader) GetPortForwardingStatusFilepath() (filepath models.Filepath, err error) { - filepathStr, err := p.envParams.GetPath("PORT_FORWARDING_STATUS_FILE", libparams.Default("/forwarded_port"), libparams.CaseSensitiveValue()) +func (r *reader) GetPortForwardingStatusFilepath() (filepath models.Filepath, err error) { + filepathStr, err := r.envParams.GetPath("PORT_FORWARDING_STATUS_FILE", libparams.Default("/forwarded_port"), libparams.CaseSensitiveValue()) return models.Filepath(filepathStr), err } // GetPIAEncryption obtains the encryption level for the PIA connection // from the environment variable PIA_ENCRYPTION, and using ENCRYPTION for // retro compatibility -func (p *reader) GetPIAEncryption() (models.PIAEncryption, error) { +func (r *reader) GetPIAEncryption() (models.PIAEncryption, error) { // Retro-compatibility - s, err := p.envParams.GetValueIfInside("ENCRYPTION", []string{"normal", "strong", ""}) + s, err := r.envParams.GetValueIfInside("ENCRYPTION", []string{"normal", "strong", ""}) if err != nil { return "", err } else if len(s) != 0 { - p.logger.Warn("You are using the old environment variable ENCRYPTION, please consider changing it to PIA_ENCRYPTION") + r.logger.Warn("You are using the old environment variable ENCRYPTION, please consider changing it to PIA_ENCRYPTION") return models.PIAEncryption(s), nil } - s, err = p.envParams.GetValueIfInside("PIA_ENCRYPTION", []string{"normal", "strong"}, libparams.Default("strong")) + s, err = r.envParams.GetValueIfInside("PIA_ENCRYPTION", []string{"normal", "strong"}, libparams.Default("strong")) return models.PIAEncryption(s), err } // GetPIARegion obtains the region for the PIA server from the // environment variable REGION -func (p *reader) GetPIARegion() (region models.PIARegion, err error) { +func (r *reader) GetPIARegion() (region models.PIARegion, err error) { choices := append(constants.PIAGeoChoices(), "") - s, err := p.envParams.GetValueIfInside("REGION", choices) + s, err := r.envParams.GetValueIfInside("REGION", choices) if len(s) == 0 { // Suggestion by @rorph https://github.com/rorph s = choices[rand.Int()%len(choices)] //nolint:gosec } diff --git a/internal/params/shadowsocks.go b/internal/params/shadowsocks.go index 012478a6..f0c4e9f1 100644 --- a/internal/params/shadowsocks.go +++ b/internal/params/shadowsocks.go @@ -8,24 +8,24 @@ import ( // GetShadowSocks obtains if ShadowSocks is on from the environment variable // SHADOWSOCKS -func (p *reader) GetShadowSocks() (activated bool, err error) { - return p.envParams.GetOnOff("SHADOWSOCKS", libparams.Default("off")) +func (r *reader) GetShadowSocks() (activated bool, err error) { + return r.envParams.GetOnOff("SHADOWSOCKS", libparams.Default("off")) } // GetShadowSocksLog obtains the ShadowSocks log level from the environment variable // SHADOWSOCKS_LOG -func (p *reader) GetShadowSocksLog() (activated bool, err error) { - return p.envParams.GetOnOff("SHADOWSOCKS_LOG", libparams.Default("off")) +func (r *reader) GetShadowSocksLog() (activated bool, err error) { + return r.envParams.GetOnOff("SHADOWSOCKS_LOG", libparams.Default("off")) } // GetShadowSocksPort obtains the ShadowSocks listening port from the environment variable // SHADOWSOCKS_PORT -func (p *reader) GetShadowSocksPort() (port uint16, err error) { - portStr, err := p.envParams.GetEnv("SHADOWSOCKS_PORT", libparams.Default("8388")) +func (r *reader) GetShadowSocksPort() (port uint16, err error) { + portStr, err := r.envParams.GetEnv("SHADOWSOCKS_PORT", libparams.Default("8388")) if err != nil { return 0, err } - if err := p.verifier.VerifyPort(portStr); err != nil { + if err := r.verifier.VerifyPort(portStr); err != nil { return 0, err } portUint64, err := strconv.ParseUint(portStr, 10, 16) @@ -34,18 +34,18 @@ func (p *reader) GetShadowSocksPort() (port uint16, err error) { // GetShadowSocksPassword obtains the ShadowSocks server password from the environment variable // SHADOWSOCKS_PASSWORD -func (p *reader) GetShadowSocksPassword() (password string, err error) { +func (r *reader) GetShadowSocksPassword() (password string, err error) { defer func() { - unsetErr := p.unsetEnv("SHADOWSOCKS_PASSWORD") + unsetErr := r.unsetEnv("SHADOWSOCKS_PASSWORD") if err == nil { err = unsetErr } }() - return p.envParams.GetEnv("SHADOWSOCKS_PASSWORD", libparams.CaseSensitiveValue()) + return r.envParams.GetEnv("SHADOWSOCKS_PASSWORD", libparams.CaseSensitiveValue()) } // GetShadowSocksMethod obtains the ShadowSocks method to use from the environment variable // SHADOWSOCKS_METHOD -func (p *reader) GetShadowSocksMethod() (method string, err error) { - return p.envParams.GetEnv("SHADOWSOCKS_METHOD", libparams.Default("chacha20-ietf-poly1305")) +func (r *reader) GetShadowSocksMethod() (method string, err error) { + return r.envParams.GetEnv("SHADOWSOCKS_METHOD", libparams.Default("chacha20-ietf-poly1305")) } diff --git a/internal/params/surfshark.go b/internal/params/surfshark.go index 5905bee6..30dda280 100644 --- a/internal/params/surfshark.go +++ b/internal/params/surfshark.go @@ -9,7 +9,7 @@ import ( // GetSurfsharkRegion obtains the region for the Surfshark server from the // environment variable REGION -func (p *reader) GetSurfsharkRegion() (region models.SurfsharkRegion, err error) { - s, err := p.envParams.GetValueIfInside("REGION", constants.SurfsharkRegionChoices()) +func (r *reader) GetSurfsharkRegion() (region models.SurfsharkRegion, err error) { + s, err := r.envParams.GetValueIfInside("REGION", constants.SurfsharkRegionChoices()) return models.SurfsharkRegion(strings.ToLower(s)), err } diff --git a/internal/params/system.go b/internal/params/system.go index 71bf3725..0cb82cfb 100644 --- a/internal/params/system.go +++ b/internal/params/system.go @@ -6,23 +6,23 @@ import ( ) // GetUID obtains the user ID to use from the environment variable UID -func (p *reader) GetUID() (uid int, err error) { - return p.envParams.GetEnvIntRange("UID", 0, 65535, libparams.Default("1000")) +func (r *reader) GetUID() (uid int, err error) { + return r.envParams.GetEnvIntRange("UID", 0, 65535, libparams.Default("1000")) } // GetGID obtains the group ID to use from the environment variable GID -func (p *reader) GetGID() (gid int, err error) { - return p.envParams.GetEnvIntRange("GID", 0, 65535, libparams.Default("1000")) +func (r *reader) GetGID() (gid int, err error) { + return r.envParams.GetEnvIntRange("GID", 0, 65535, libparams.Default("1000")) } // GetTZ obtains the timezone from the environment variable TZ -func (p *reader) GetTimezone() (timezone string, err error) { - return p.envParams.GetEnv("TZ") +func (r *reader) GetTimezone() (timezone string, err error) { + return r.envParams.GetEnv("TZ") } // GetIPStatusFilepath obtains the IP status file path // from the environment variable IP_STATUS_FILE -func (p *reader) GetIPStatusFilepath() (filepath models.Filepath, err error) { - filepathStr, err := p.envParams.GetPath("IP_STATUS_FILE", libparams.Default("/ip"), libparams.CaseSensitiveValue()) +func (r *reader) GetIPStatusFilepath() (filepath models.Filepath, err error) { + filepathStr, err := r.envParams.GetPath("IP_STATUS_FILE", libparams.Default("/ip"), libparams.CaseSensitiveValue()) return models.Filepath(filepathStr), err } diff --git a/internal/params/tinyproxy.go b/internal/params/tinyproxy.go index fcc11590..22ab9260 100644 --- a/internal/params/tinyproxy.go +++ b/internal/params/tinyproxy.go @@ -9,51 +9,51 @@ import ( // GetTinyProxy obtains if TinyProxy is on from the environment variable // TINYPROXY, and using PROXY as a retro-compatibility name -func (p *reader) GetTinyProxy() (activated bool, err error) { +func (r *reader) GetTinyProxy() (activated bool, err error) { // Retro-compatibility - s, err := p.envParams.GetEnv("PROXY") + s, err := r.envParams.GetEnv("PROXY") if err != nil { return false, err } else if len(s) != 0 { - p.logger.Warn("You are using the old environment variable PROXY, please consider changing it to TINYPROXY") - return p.envParams.GetOnOff("PROXY", libparams.Compulsory()) + r.logger.Warn("You are using the old environment variable PROXY, please consider changing it to TINYPROXY") + return r.envParams.GetOnOff("PROXY", libparams.Compulsory()) } - return p.envParams.GetOnOff("TINYPROXY", libparams.Default("off")) + return r.envParams.GetOnOff("TINYPROXY", libparams.Default("off")) } // GetTinyProxyLog obtains the TinyProxy log level from the environment variable // TINYPROXY_LOG, and using PROXY_LOG_LEVEL as a retro-compatibility name -func (p *reader) GetTinyProxyLog() (models.TinyProxyLogLevel, error) { +func (r *reader) GetTinyProxyLog() (models.TinyProxyLogLevel, error) { // Retro-compatibility - s, err := p.envParams.GetEnv("PROXY_LOG_LEVEL") + s, err := r.envParams.GetEnv("PROXY_LOG_LEVEL") if err != nil { return models.TinyProxyLogLevel(s), err } else if len(s) != 0 { - p.logger.Warn("You are using the old environment variable PROXY_LOG_LEVEL, please consider changing it to TINYPROXY_LOG") - s, err = p.envParams.GetValueIfInside("PROXY_LOG_LEVEL", []string{"Info", "Connect", "Notice", "Warning", "Error", "Critical"}, libparams.Compulsory()) + r.logger.Warn("You are using the old environment variable PROXY_LOG_LEVEL, please consider changing it to TINYPROXY_LOG") + s, err = r.envParams.GetValueIfInside("PROXY_LOG_LEVEL", []string{"Info", "Connect", "Notice", "Warning", "Error", "Critical"}, libparams.Compulsory()) return models.TinyProxyLogLevel(s), err } - s, err = p.envParams.GetValueIfInside("TINYPROXY_LOG", []string{"Info", "Connect", "Notice", "Warning", "Error", "Critical"}, libparams.Default("Connect")) + s, err = r.envParams.GetValueIfInside("TINYPROXY_LOG", []string{"Info", "Connect", "Notice", "Warning", "Error", "Critical"}, libparams.Default("Connect")) return models.TinyProxyLogLevel(s), err } // GetTinyProxyPort obtains the TinyProxy listening port from the environment variable // TINYPROXY_PORT, and using PROXY_PORT as a retro-compatibility name -func (p *reader) GetTinyProxyPort() (port uint16, err error) { +func (r *reader) GetTinyProxyPort() (port uint16, err error) { // Retro-compatibility - portStr, err := p.envParams.GetEnv("PROXY_PORT") + portStr, err := r.envParams.GetEnv("PROXY_PORT") switch { case err != nil: return 0, err case len(portStr) != 0: - p.logger.Warn("You are using the old environment variable PROXY_PORT, please consider changing it to TINYPROXY_PORT") + r.logger.Warn("You are using the old environment variable PROXY_PORT, please consider changing it to TINYPROXY_PORT") default: - portStr, err = p.envParams.GetEnv("TINYPROXY_PORT", libparams.Default("8888")) + portStr, err = r.envParams.GetEnv("TINYPROXY_PORT", libparams.Default("8888")) if err != nil { return 0, err } } - if err := p.verifier.VerifyPort(portStr); err != nil { + if err := r.verifier.VerifyPort(portStr); err != nil { return 0, err } portUint64, err := strconv.ParseUint(portStr, 10, 16) @@ -62,55 +62,55 @@ func (p *reader) GetTinyProxyPort() (port uint16, err error) { // GetTinyProxyUser obtains the TinyProxy server user from the environment variable // TINYPROXY_USER, and using PROXY_USER as a retro-compatibility name -func (p *reader) GetTinyProxyUser() (user string, err error) { +func (r *reader) GetTinyProxyUser() (user string, err error) { defer func() { - unsetErr := p.unsetEnv("PROXY_USER") + unsetErr := r.unsetEnv("PROXY_USER") if err == nil { err = unsetErr } }() defer func() { - unsetErr := p.unsetEnv("TINYPROXY_USER") + unsetErr := r.unsetEnv("TINYPROXY_USER") if err == nil { err = unsetErr } }() // Retro-compatibility - user, err = p.envParams.GetEnv("PROXY_USER", libparams.CaseSensitiveValue()) + user, err = r.envParams.GetEnv("PROXY_USER", libparams.CaseSensitiveValue()) if err != nil { return user, err } if len(user) != 0 { - p.logger.Warn("You are using the old environment variable PROXY_USER, please consider changing it to TINYPROXY_USER") + r.logger.Warn("You are using the old environment variable PROXY_USER, please consider changing it to TINYPROXY_USER") return user, nil } - return p.envParams.GetEnv("TINYPROXY_USER", libparams.CaseSensitiveValue()) + return r.envParams.GetEnv("TINYPROXY_USER", libparams.CaseSensitiveValue()) } // GetTinyProxyPassword obtains the TinyProxy server password from the environment variable // TINYPROXY_PASSWORD, and using PROXY_PASSWORD as a retro-compatibility name -func (p *reader) GetTinyProxyPassword() (password string, err error) { +func (r *reader) GetTinyProxyPassword() (password string, err error) { defer func() { - unsetErr := p.unsetEnv("PROXY_PASSWORD") + unsetErr := r.unsetEnv("PROXY_PASSWORD") if err == nil { err = unsetErr } }() defer func() { - unsetErr := p.unsetEnv("TINYPROXY_PASSWORD") + unsetErr := r.unsetEnv("TINYPROXY_PASSWORD") if err == nil { err = unsetErr } }() // Retro-compatibility - password, err = p.envParams.GetEnv("PROXY_PASSWORD", libparams.CaseSensitiveValue()) + password, err = r.envParams.GetEnv("PROXY_PASSWORD", libparams.CaseSensitiveValue()) if err != nil { return password, err } if len(password) != 0 { - p.logger.Warn("You are using the old environment variable PROXY_PASSWORD, please consider changing it to TINYPROXY_PASSWORD") + r.logger.Warn("You are using the old environment variable PROXY_PASSWORD, please consider changing it to TINYPROXY_PASSWORD") return password, nil } - return p.envParams.GetEnv("TINYPROXY_PASSWORD", libparams.CaseSensitiveValue()) + return r.envParams.GetEnv("TINYPROXY_PASSWORD", libparams.CaseSensitiveValue()) } diff --git a/internal/params/version.go b/internal/params/version.go index 596fa64a..079b4f17 100644 --- a/internal/params/version.go +++ b/internal/params/version.go @@ -4,17 +4,17 @@ import ( libparams "github.com/qdm12/golibs/params" ) -func (p *reader) GetVersion() string { - version, _ := p.envParams.GetEnv("VERSION", libparams.Default("?"), libparams.CaseSensitiveValue()) +func (r *reader) GetVersion() string { + version, _ := r.envParams.GetEnv("VERSION", libparams.Default("?"), libparams.CaseSensitiveValue()) return version } -func (p *reader) GetBuildDate() string { - buildDate, _ := p.envParams.GetEnv("BUILD_DATE", libparams.Default("?"), libparams.CaseSensitiveValue()) +func (r *reader) GetBuildDate() string { + buildDate, _ := r.envParams.GetEnv("BUILD_DATE", libparams.Default("?"), libparams.CaseSensitiveValue()) return buildDate } -func (p *reader) GetVcsRef() string { - buildDate, _ := p.envParams.GetEnv("VCS_REF", libparams.Default("?"), libparams.CaseSensitiveValue()) +func (r *reader) GetVcsRef() string { + buildDate, _ := r.envParams.GetEnv("VCS_REF", libparams.Default("?"), libparams.CaseSensitiveValue()) return buildDate } diff --git a/internal/params/windscribe.go b/internal/params/windscribe.go index 95f8af68..102bb16b 100644 --- a/internal/params/windscribe.go +++ b/internal/params/windscribe.go @@ -11,15 +11,15 @@ import ( // GetWindscribeRegion obtains the region for the Windscribe server from the // environment variable REGION -func (p *reader) GetWindscribeRegion() (region models.WindscribeRegion, err error) { - s, err := p.envParams.GetValueIfInside("REGION", constants.WindscribeRegionChoices()) +func (r *reader) GetWindscribeRegion() (region models.WindscribeRegion, err error) { + s, err := r.envParams.GetValueIfInside("REGION", constants.WindscribeRegionChoices()) return models.WindscribeRegion(strings.ToLower(s)), err } // GetMullvadPort obtains the port to reach the Mullvad server on from the // environment variable PORT -func (p *reader) GetWindscribePort(protocol models.NetworkProtocol) (port uint16, err error) { - n, err := p.envParams.GetEnvIntRange("PORT", 0, 65535, libparams.Default("0")) +func (r *reader) GetWindscribePort(protocol models.NetworkProtocol) (port uint16, err error) { + n, err := r.envParams.GetEnvIntRange("PORT", 0, 65535, libparams.Default("0")) if err != nil { return 0, err }