chore(config): upgrade to gosettings v0.4.0

- drop qdm12/govalid dependency
- upgrade qdm12/ss-server to v0.6.0
- do not unset sensitive config settings (makes no sense to me)

internal/configuration/settings/dns.go

@@ -5,6 +5,7 @@ import (
 	"net/netip"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -49,14 +50,6 @@ func (d *DNS) Copy() (copied DNS) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (d *DNS) mergeWith(other DNS) {
-	d.ServerAddress = gosettings.MergeWithValidator(d.ServerAddress, other.ServerAddress)
-	d.KeepNameserver = gosettings.MergeWithPointer(d.KeepNameserver, other.KeepNameserver)
-	d.DoT.mergeWith(other.DoT)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -87,3 +80,22 @@ func (d DNS) toLinesNode() (node *gotree.Node) {
 	node.AppendNode(d.DoT.toLinesNode())
 	return node
 }
+
+func (d *DNS) read(r *reader.Reader) (err error) {
+	d.ServerAddress, err = r.NetipAddr("DNS_ADDRESS", reader.RetroKeys("DNS_PLAINTEXT_ADDRESS"))
+	if err != nil {
+		return err
+	}
+
+	d.KeepNameserver, err = r.BoolPtr("DNS_KEEP_NAMESERVER")
+	if err != nil {
+		return err
+	}
+
+	err = d.DoT.read(r)
+	if err != nil {
+		return fmt.Errorf("DNS over TLS settings: %w", err)
+	}
+
+	return nil
+}

internal/configuration/settings/dnsblacklist.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/qdm12/dns/pkg/blacklist"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -63,16 +64,6 @@ func (b DNSBlacklist) copy() (copied DNSBlacklist) {
 	}
 }
 
-func (b *DNSBlacklist) mergeWith(other DNSBlacklist) {
-	b.BlockMalicious = gosettings.MergeWithPointer(b.BlockMalicious, other.BlockMalicious)
-	b.BlockAds = gosettings.MergeWithPointer(b.BlockAds, other.BlockAds)
-	b.BlockSurveillance = gosettings.MergeWithPointer(b.BlockSurveillance, other.BlockSurveillance)
-	b.AllowedHosts = gosettings.MergeWithSlice(b.AllowedHosts, other.AllowedHosts)
-	b.AddBlockedHosts = gosettings.MergeWithSlice(b.AddBlockedHosts, other.AddBlockedHosts)
-	b.AddBlockedIPs = gosettings.MergeWithSlice(b.AddBlockedIPs, other.AddBlockedIPs)
-	b.AddBlockedIPPrefixes = gosettings.MergeWithSlice(b.AddBlockedIPPrefixes, other.AddBlockedIPPrefixes)
-}
-
 func (b *DNSBlacklist) overrideWith(other DNSBlacklist) {
 	b.BlockMalicious = gosettings.OverrideWithPointer(b.BlockMalicious, other.BlockMalicious)
 	b.BlockAds = gosettings.OverrideWithPointer(b.BlockAds, other.BlockAds)
@@ -136,3 +127,66 @@ func (b DNSBlacklist) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (b *DNSBlacklist) read(r *reader.Reader) (err error) {
+	b.BlockMalicious, err = r.BoolPtr("BLOCK_MALICIOUS")
+	if err != nil {
+		return err
+	}
+
+	b.BlockSurveillance, err = r.BoolPtr("BLOCK_SURVEILLANCE",
+		reader.RetroKeys("BLOCK_NSA"))
+	if err != nil {
+		return err
+	}
+
+	b.BlockAds, err = r.BoolPtr("BLOCK_ADS")
+	if err != nil {
+		return err
+	}
+
+	b.AddBlockedIPs, b.AddBlockedIPPrefixes,
+		err = readDoTPrivateAddresses(r) // TODO v4 split in 2
+	if err != nil {
+		return err
+	}
+
+	b.AllowedHosts = r.CSV("UNBLOCK") // TODO v4 change name
+
+	return nil
+}
+
+var (
+	ErrPrivateAddressNotValid = errors.New("private address is not a valid IP or CIDR range")
+)
+
+func readDoTPrivateAddresses(reader *reader.Reader) (ips []netip.Addr,
+	ipPrefixes []netip.Prefix, err error) {
+	privateAddresses := reader.CSV("DOT_PRIVATE_ADDRESS")
+	if len(privateAddresses) == 0 {
+		return nil, nil, nil
+	}
+
+	ips = make([]netip.Addr, 0, len(privateAddresses))
+	ipPrefixes = make([]netip.Prefix, 0, len(privateAddresses))
+
+	for _, privateAddress := range privateAddresses {
+		ip, err := netip.ParseAddr(privateAddress)
+		if err == nil {
+			ips = append(ips, ip)
+			continue
+		}
+
+		ipPrefix, err := netip.ParsePrefix(privateAddress)
+		if err == nil {
+			ipPrefixes = append(ipPrefixes, ipPrefix)
+			continue
+		}
+
+		return nil, nil, fmt.Errorf(
+			"environment variable DOT_PRIVATE_ADDRESS: %w: %s",
+			ErrPrivateAddressNotValid, privateAddress)
+	}
+
+	return ips, ipPrefixes, nil
+}

internal/configuration/settings/dot.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -61,15 +62,6 @@ func (d *DoT) copy() (copied DoT) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (d *DoT) mergeWith(other DoT) {
-	d.Enabled = gosettings.MergeWithPointer(d.Enabled, other.Enabled)
-	d.UpdatePeriod = gosettings.MergeWithPointer(d.UpdatePeriod, other.UpdatePeriod)
-	d.Unbound.mergeWith(other.Unbound)
-	d.Blacklist.mergeWith(other.Blacklist)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -111,3 +103,27 @@ func (d DoT) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (d *DoT) read(reader *reader.Reader) (err error) {
+	d.Enabled, err = reader.BoolPtr("DOT")
+	if err != nil {
+		return err
+	}
+
+	d.UpdatePeriod, err = reader.DurationPtr("DNS_UPDATE_PERIOD")
+	if err != nil {
+		return err
+	}
+
+	err = d.Unbound.read(reader)
+	if err != nil {
+		return err
+	}
+
+	err = d.Blacklist.read(reader)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/errors.go

@@ -3,6 +3,7 @@ package settings
 import "errors"
 
 var (
+	ErrValueUnknown                    = errors.New("value is unknown")
 	ErrCityNotValid                    = errors.New("the city specified is not valid")
 	ErrControlServerPrivilegedPort     = errors.New("cannot use privileged port without running as root")
 	ErrCategoryNotValid                = errors.New("the category specified is not valid")

internal/configuration/settings/firewall.go

@@ -5,6 +5,7 @@ import (
 	"net/netip"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -54,18 +55,6 @@ func (f *Firewall) copy() (copied Firewall) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-// It merges values of slices together, even if they
-// are set in the receiver settings.
-func (f *Firewall) mergeWith(other Firewall) {
-	f.VPNInputPorts = gosettings.MergeWithSlice(f.VPNInputPorts, other.VPNInputPorts)
-	f.InputPorts = gosettings.MergeWithSlice(f.InputPorts, other.InputPorts)
-	f.OutboundSubnets = gosettings.MergeWithSlice(f.OutboundSubnets, other.OutboundSubnets)
-	f.Enabled = gosettings.MergeWithPointer(f.Enabled, other.Enabled)
-	f.Debug = gosettings.MergeWithPointer(f.Debug, other.Debug)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -122,3 +111,33 @@ func (f Firewall) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (f *Firewall) read(r *reader.Reader) (err error) {
+	f.VPNInputPorts, err = r.CSVUint16("FIREWALL_VPN_INPUT_PORTS")
+	if err != nil {
+		return err
+	}
+
+	f.InputPorts, err = r.CSVUint16("FIREWALL_INPUT_PORTS")
+	if err != nil {
+		return err
+	}
+
+	f.OutboundSubnets, err = r.CSVNetipPrefixes(
+		"FIREWALL_OUTBOUND_SUBNETS", reader.RetroKeys("EXTRA_SUBNETS"))
+	if err != nil {
+		return err
+	}
+
+	f.Enabled, err = r.BoolPtr("FIREWALL")
+	if err != nil {
+		return err
+	}
+
+	f.Debug, err = r.BoolPtr("FIREWALL_DEBUG")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/health.go

@@ -6,8 +6,9 @@ import (
 	"time"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
+	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
-	"github.com/qdm12/govalid/address"
 )
 
 // Health contains settings for the healthcheck and health server.
@@ -36,9 +37,7 @@ type Health struct {
 }
 
 func (h Health) Validate() (err error) {
-	uid := os.Getuid()
-	err = address.Validate(h.ServerAddress,
-		address.OptionListening(uid))
+	err = validate.ListeningAddress(h.ServerAddress, os.Getuid())
 	if err != nil {
 		return fmt.Errorf("server listening address is not valid: %w", err)
 	}
@@ -62,38 +61,27 @@ func (h *Health) copy() (copied Health) {
 	}
 }
 
-// MergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (h *Health) MergeWith(other Health) {
-	h.ServerAddress = gosettings.MergeWithString(h.ServerAddress, other.ServerAddress)
-	h.ReadHeaderTimeout = gosettings.MergeWithNumber(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
-	h.ReadTimeout = gosettings.MergeWithNumber(h.ReadTimeout, other.ReadTimeout)
-	h.TargetAddress = gosettings.MergeWithString(h.TargetAddress, other.TargetAddress)
-	h.SuccessWait = gosettings.MergeWithNumber(h.SuccessWait, other.SuccessWait)
-	h.VPN.mergeWith(other.VPN)
-}
-
 // OverrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
 func (h *Health) OverrideWith(other Health) {
-	h.ServerAddress = gosettings.OverrideWithString(h.ServerAddress, other.ServerAddress)
-	h.ReadHeaderTimeout = gosettings.OverrideWithNumber(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
-	h.ReadTimeout = gosettings.OverrideWithNumber(h.ReadTimeout, other.ReadTimeout)
-	h.TargetAddress = gosettings.OverrideWithString(h.TargetAddress, other.TargetAddress)
-	h.SuccessWait = gosettings.OverrideWithNumber(h.SuccessWait, other.SuccessWait)
+	h.ServerAddress = gosettings.OverrideWithComparable(h.ServerAddress, other.ServerAddress)
+	h.ReadHeaderTimeout = gosettings.OverrideWithComparable(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
+	h.ReadTimeout = gosettings.OverrideWithComparable(h.ReadTimeout, other.ReadTimeout)
+	h.TargetAddress = gosettings.OverrideWithComparable(h.TargetAddress, other.TargetAddress)
+	h.SuccessWait = gosettings.OverrideWithComparable(h.SuccessWait, other.SuccessWait)
 	h.VPN.overrideWith(other.VPN)
 }
 
 func (h *Health) SetDefaults() {
-	h.ServerAddress = gosettings.DefaultString(h.ServerAddress, "127.0.0.1:9999")
+	h.ServerAddress = gosettings.DefaultComparable(h.ServerAddress, "127.0.0.1:9999")
 	const defaultReadHeaderTimeout = 100 * time.Millisecond
-	h.ReadHeaderTimeout = gosettings.DefaultNumber(h.ReadHeaderTimeout, defaultReadHeaderTimeout)
+	h.ReadHeaderTimeout = gosettings.DefaultComparable(h.ReadHeaderTimeout, defaultReadHeaderTimeout)
 	const defaultReadTimeout = 500 * time.Millisecond
-	h.ReadTimeout = gosettings.DefaultNumber(h.ReadTimeout, defaultReadTimeout)
-	h.TargetAddress = gosettings.DefaultString(h.TargetAddress, "cloudflare.com:443")
+	h.ReadTimeout = gosettings.DefaultComparable(h.ReadTimeout, defaultReadTimeout)
+	h.TargetAddress = gosettings.DefaultComparable(h.TargetAddress, "cloudflare.com:443")
 	const defaultSuccessWait = 5 * time.Second
-	h.SuccessWait = gosettings.DefaultNumber(h.SuccessWait, defaultSuccessWait)
+	h.SuccessWait = gosettings.DefaultComparable(h.SuccessWait, defaultSuccessWait)
 	h.VPN.setDefaults()
 }
 
@@ -111,3 +99,21 @@ func (h Health) toLinesNode() (node *gotree.Node) {
 	node.AppendNode(h.VPN.toLinesNode("VPN"))
 	return node
 }
+
+func (h *Health) Read(r *reader.Reader) (err error) {
+	h.ServerAddress = r.String("HEALTH_SERVER_ADDRESS")
+	h.TargetAddress = r.String("HEALTH_TARGET_ADDRESS",
+		reader.RetroKeys("HEALTH_ADDRESS_TO_PING"))
+
+	h.SuccessWait, err = r.Duration("HEALTH_SUCCESS_WAIT_DURATION")
+	if err != nil {
+		return err
+	}
+
+	err = h.VPN.read(r)
+	if err != nil {
+		return fmt.Errorf("VPN health settings: %w", err)
+	}
+
+	return nil
+}

internal/configuration/settings/healthywait.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -23,8 +24,6 @@ func (h HealthyWait) validate() (err error) {
 	return nil
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
 func (h *HealthyWait) copy() (copied HealthyWait) {
 	return HealthyWait{
 		Initial:  gosettings.CopyPointer(h.Initial),
@@ -32,13 +31,6 @@ func (h *HealthyWait) copy() (copied HealthyWait) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (h *HealthyWait) mergeWith(other HealthyWait) {
-	h.Initial = gosettings.MergeWithPointer(h.Initial, other.Initial)
-	h.Addition = gosettings.MergeWithPointer(h.Addition, other.Addition)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -64,3 +56,21 @@ func (h HealthyWait) toLinesNode(kind string) (node *gotree.Node) {
 	node.Appendf("Additional duration: %s", *h.Addition)
 	return node
 }
+
+func (h *HealthyWait) read(r *reader.Reader) (err error) {
+	h.Initial, err = r.DurationPtr(
+		"HEALTH_VPN_DURATION_INITIAL",
+		reader.RetroKeys("HEALTH_OPENVPN_DURATION_INITIAL"))
+	if err != nil {
+		return err
+	}
+
+	h.Addition, err = r.DurationPtr(
+		"HEALTH_VPN_DURATION_ADDITION",
+		reader.RetroKeys("HEALTH_OPENVPN_DURATION_ADDITION"))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/helpers.go

@@ -0,0 +1,5 @@
+package settings
+
+func ptrTo[T any](value T) *T {
+	return &value
+}

internal/configuration/settings/httpproxy.go

@@ -3,11 +3,13 @@ package settings
 import (
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
+	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
-	"github.com/qdm12/govalid/address"
 )
 
 // HTTPProxy contains settings to configure the HTTP proxy.
@@ -44,9 +46,7 @@ type HTTPProxy struct {
 
 func (h HTTPProxy) validate() (err error) {
 	// Do not validate user and password
-
-	uid := os.Getuid()
-	err = address.Validate(h.ListeningAddress, address.OptionListening(uid))
+	err = validate.ListeningAddress(h.ListeningAddress, os.Getuid())
 	if err != nil {
 		return fmt.Errorf("%w: %s", ErrServerAddressNotValid, h.ListeningAddress)
 	}
@@ -67,44 +67,31 @@ func (h *HTTPProxy) copy() (copied HTTPProxy) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (h *HTTPProxy) mergeWith(other HTTPProxy) {
-	h.User = gosettings.MergeWithPointer(h.User, other.User)
-	h.Password = gosettings.MergeWithPointer(h.Password, other.Password)
-	h.ListeningAddress = gosettings.MergeWithString(h.ListeningAddress, other.ListeningAddress)
-	h.Enabled = gosettings.MergeWithPointer(h.Enabled, other.Enabled)
-	h.Stealth = gosettings.MergeWithPointer(h.Stealth, other.Stealth)
-	h.Log = gosettings.MergeWithPointer(h.Log, other.Log)
-	h.ReadHeaderTimeout = gosettings.MergeWithNumber(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
-	h.ReadTimeout = gosettings.MergeWithNumber(h.ReadTimeout, other.ReadTimeout)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
 func (h *HTTPProxy) overrideWith(other HTTPProxy) {
 	h.User = gosettings.OverrideWithPointer(h.User, other.User)
 	h.Password = gosettings.OverrideWithPointer(h.Password, other.Password)
-	h.ListeningAddress = gosettings.OverrideWithString(h.ListeningAddress, other.ListeningAddress)
+	h.ListeningAddress = gosettings.OverrideWithComparable(h.ListeningAddress, other.ListeningAddress)
 	h.Enabled = gosettings.OverrideWithPointer(h.Enabled, other.Enabled)
 	h.Stealth = gosettings.OverrideWithPointer(h.Stealth, other.Stealth)
 	h.Log = gosettings.OverrideWithPointer(h.Log, other.Log)
-	h.ReadHeaderTimeout = gosettings.OverrideWithNumber(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
-	h.ReadTimeout = gosettings.OverrideWithNumber(h.ReadTimeout, other.ReadTimeout)
+	h.ReadHeaderTimeout = gosettings.OverrideWithComparable(h.ReadHeaderTimeout, other.ReadHeaderTimeout)
+	h.ReadTimeout = gosettings.OverrideWithComparable(h.ReadTimeout, other.ReadTimeout)
 }
 
 func (h *HTTPProxy) setDefaults() {
 	h.User = gosettings.DefaultPointer(h.User, "")
 	h.Password = gosettings.DefaultPointer(h.Password, "")
-	h.ListeningAddress = gosettings.DefaultString(h.ListeningAddress, ":8888")
+	h.ListeningAddress = gosettings.DefaultComparable(h.ListeningAddress, ":8888")
 	h.Enabled = gosettings.DefaultPointer(h.Enabled, false)
 	h.Stealth = gosettings.DefaultPointer(h.Stealth, false)
 	h.Log = gosettings.DefaultPointer(h.Log, false)
 	const defaultReadHeaderTimeout = time.Second
-	h.ReadHeaderTimeout = gosettings.DefaultNumber(h.ReadHeaderTimeout, defaultReadHeaderTimeout)
+	h.ReadHeaderTimeout = gosettings.DefaultComparable(h.ReadHeaderTimeout, defaultReadHeaderTimeout)
 	const defaultReadTimeout = 3 * time.Second
-	h.ReadTimeout = gosettings.DefaultNumber(h.ReadTimeout, defaultReadTimeout)
+	h.ReadTimeout = gosettings.DefaultComparable(h.ReadTimeout, defaultReadTimeout)
 }
 
 func (h HTTPProxy) String() string {
@@ -128,3 +115,66 @@ func (h HTTPProxy) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (h *HTTPProxy) read(r *reader.Reader) (err error) {
+	h.User = r.Get("HTTPPROXY_USER",
+		reader.RetroKeys("PROXY_USER", "TINYPROXY_USER"),
+		reader.ForceLowercase(false))
+
+	h.Password = r.Get("HTTPPROXY_PASSWORD",
+		reader.RetroKeys("PROXY_PASSWORD", "TINYPROXY_PASSWORD"),
+		reader.ForceLowercase(false))
+
+	h.ListeningAddress, err = readHTTProxyListeningAddress(r)
+	if err != nil {
+		return err
+	}
+
+	h.Enabled, err = r.BoolPtr("HTTPPROXY", reader.RetroKeys("PROXY", "TINYPROXY"))
+	if err != nil {
+		return err
+	}
+
+	h.Stealth, err = r.BoolPtr("HTTPPROXY_STEALTH")
+	if err != nil {
+		return err
+	}
+
+	h.Log, err = readHTTProxyLog(r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func readHTTProxyListeningAddress(r *reader.Reader) (listeningAddress string, err error) {
+	// Retro-compatible keys using a port only
+	port, err := r.Uint16Ptr("",
+		reader.RetroKeys("HTTPPROXY_PORT", "TINYPROXY_PORT", "PROXY_PORT"))
+	if err != nil {
+		return "", err
+	} else if port != nil {
+		return fmt.Sprintf(":%d", *port), nil
+	}
+	const currentKey = "HTTPPROXY_LISTENING_ADDRESS"
+	return r.String(currentKey), nil
+}
+
+func readHTTProxyLog(r *reader.Reader) (enabled *bool, err error) {
+	// Retro-compatible keys using different boolean verbs
+	value := r.String("",
+		reader.RetroKeys("PROXY_LOG", "TINYPROXY_LOG", "HTTPPROXY_LOG"))
+	switch strings.ToLower(value) {
+	case "":
+		const currentKey = "HTTPPROXY_LOG"
+		return r.BoolPtr(currentKey)
+	case "on", "info", "connect", "notice":
+		return ptrTo(true), nil
+	case "disabled", "no", "off":
+		return ptrTo(false), nil
+	default:
+		return nil, fmt.Errorf("HTTP retro-compatible proxy log setting: %w: %s",
+			ErrValueUnknown, value)
+	}
+}

internal/configuration/settings/log.go

@@ -1,7 +1,10 @@
 package settings
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 	"github.com/qdm12/log"
 )
@@ -9,35 +12,33 @@ import (
 // Log contains settings to configure the logger.
 type Log struct {
 	// Level is the log level of the logger.
-	// It cannot be nil in the internal state.
-	Level *log.Level
+	// It cannot be empty in the internal state.
+	Level string
 }
 
 func (l Log) validate() (err error) {
+	_, err = log.ParseLevel(l.Level)
+	if err != nil {
+		return fmt.Errorf("level: %w", err)
+	}
 	return nil
 }
 
 func (l *Log) copy() (copied Log) {
 	return Log{
-		Level: gosettings.CopyPointer(l.Level),
+		Level: l.Level,
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (l *Log) mergeWith(other Log) {
-	l.Level = gosettings.MergeWithPointer(l.Level, other.Level)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
 func (l *Log) overrideWith(other Log) {
-	l.Level = gosettings.OverrideWithPointer(l.Level, other.Level)
+	l.Level = gosettings.OverrideWithComparable(l.Level, other.Level)
 }
 
 func (l *Log) setDefaults() {
-	l.Level = gosettings.DefaultPointer(l.Level, log.LevelInfo)
+	l.Level = gosettings.DefaultComparable(l.Level, log.LevelInfo.String())
 }
 
 func (l Log) String() string {
@@ -46,6 +47,11 @@ func (l Log) String() string {
 
 func (l Log) toLinesNode() (node *gotree.Node) {
 	node = gotree.New("Log settings:")
-	node.Appendf("Log level: %s", l.Level.String())
+	node.Appendf("Log level: %s", l.Level)
 	return node
 }
+
+func (l *Log) read(r *reader.Reader) (err error) {
+	l.Level = r.String("LOG_LEVEL")
+	return nil
+}

internal/configuration/settings/openvpn.go

@@ -4,12 +4,14 @@ import (
 	"encoding/base64"
 	"fmt"
 	"regexp"
+	"strings"
 
 	"github.com/qdm12/gluetun/internal/constants/openvpn"
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/openvpn/extract"
 	"github.com/qdm12/gluetun/internal/provider/privateinternetaccess/presets"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -261,32 +263,11 @@ func (o *OpenVPN) copy() (copied OpenVPN) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (o *OpenVPN) mergeWith(other OpenVPN) {
-	o.Version = gosettings.MergeWithString(o.Version, other.Version)
-	o.User = gosettings.MergeWithPointer(o.User, other.User)
-	o.Password = gosettings.MergeWithPointer(o.Password, other.Password)
-	o.ConfFile = gosettings.MergeWithPointer(o.ConfFile, other.ConfFile)
-	o.Ciphers = gosettings.MergeWithSlice(o.Ciphers, other.Ciphers)
-	o.Auth = gosettings.MergeWithPointer(o.Auth, other.Auth)
-	o.Cert = gosettings.MergeWithPointer(o.Cert, other.Cert)
-	o.Key = gosettings.MergeWithPointer(o.Key, other.Key)
-	o.EncryptedKey = gosettings.MergeWithPointer(o.EncryptedKey, other.EncryptedKey)
-	o.KeyPassphrase = gosettings.MergeWithPointer(o.KeyPassphrase, other.KeyPassphrase)
-	o.PIAEncPreset = gosettings.MergeWithPointer(o.PIAEncPreset, other.PIAEncPreset)
-	o.MSSFix = gosettings.MergeWithPointer(o.MSSFix, other.MSSFix)
-	o.Interface = gosettings.MergeWithString(o.Interface, other.Interface)
-	o.ProcessUser = gosettings.MergeWithString(o.ProcessUser, other.ProcessUser)
-	o.Verbosity = gosettings.MergeWithPointer(o.Verbosity, other.Verbosity)
-	o.Flags = gosettings.MergeWithSlice(o.Flags, other.Flags)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
 func (o *OpenVPN) overrideWith(other OpenVPN) {
-	o.Version = gosettings.OverrideWithString(o.Version, other.Version)
+	o.Version = gosettings.OverrideWithComparable(o.Version, other.Version)
 	o.User = gosettings.OverrideWithPointer(o.User, other.User)
 	o.Password = gosettings.OverrideWithPointer(o.Password, other.Password)
 	o.ConfFile = gosettings.OverrideWithPointer(o.ConfFile, other.ConfFile)
@@ -298,14 +279,14 @@ func (o *OpenVPN) overrideWith(other OpenVPN) {
 	o.KeyPassphrase = gosettings.OverrideWithPointer(o.KeyPassphrase, other.KeyPassphrase)
 	o.PIAEncPreset = gosettings.OverrideWithPointer(o.PIAEncPreset, other.PIAEncPreset)
 	o.MSSFix = gosettings.OverrideWithPointer(o.MSSFix, other.MSSFix)
-	o.Interface = gosettings.OverrideWithString(o.Interface, other.Interface)
-	o.ProcessUser = gosettings.OverrideWithString(o.ProcessUser, other.ProcessUser)
+	o.Interface = gosettings.OverrideWithComparable(o.Interface, other.Interface)
+	o.ProcessUser = gosettings.OverrideWithComparable(o.ProcessUser, other.ProcessUser)
 	o.Verbosity = gosettings.OverrideWithPointer(o.Verbosity, other.Verbosity)
 	o.Flags = gosettings.OverrideWithSlice(o.Flags, other.Flags)
 }
 
 func (o *OpenVPN) setDefaults(vpnProvider string) {
-	o.Version = gosettings.DefaultString(o.Version, openvpn.Openvpn25)
+	o.Version = gosettings.DefaultComparable(o.Version, openvpn.Openvpn25)
 	o.User = gosettings.DefaultPointer(o.User, "")
 	if vpnProvider == providers.Mullvad {
 		o.Password = gosettings.DefaultPointer(o.Password, "m")
@@ -326,8 +307,8 @@ func (o *OpenVPN) setDefaults(vpnProvider string) {
 	}
 	o.PIAEncPreset = gosettings.DefaultPointer(o.PIAEncPreset, defaultEncPreset)
 	o.MSSFix = gosettings.DefaultPointer(o.MSSFix, 0)
-	o.Interface = gosettings.DefaultString(o.Interface, "tun0")
-	o.ProcessUser = gosettings.DefaultString(o.ProcessUser, "root")
+	o.Interface = gosettings.DefaultComparable(o.Interface, "tun0")
+	o.ProcessUser = gosettings.DefaultComparable(o.ProcessUser, "root")
 	o.Verbosity = gosettings.DefaultPointer(o.Verbosity, 1)
 }
 
@@ -395,3 +376,58 @@ func (o OpenVPN) WithDefaults(provider string) OpenVPN {
 	o.setDefaults(provider)
 	return o
 }
+
+func (o *OpenVPN) read(r *reader.Reader) (err error) {
+	o.Version = r.String("OPENVPN_VERSION")
+	o.User = r.Get("OPENVPN_USER", reader.RetroKeys("USER"), reader.ForceLowercase(false))
+	o.Password = r.Get("OPENVPN_PASSWORD", reader.RetroKeys("PASSWORD"), reader.ForceLowercase(false))
+	o.ConfFile = r.Get("OPENVPN_CUSTOM_CONFIG", reader.ForceLowercase(false))
+	o.Ciphers = r.CSV("OPENVPN_CIPHERS", reader.RetroKeys("OPENVPN_CIPHER"))
+	o.Auth = r.Get("OPENVPN_AUTH")
+	o.Cert = r.Get("OPENVPN_CERT", reader.ForceLowercase(false))
+	o.Key = r.Get("OPENVPN_KEY", reader.ForceLowercase(false))
+	o.EncryptedKey = r.Get("OPENVPN_ENCRYPTED_KEY", reader.ForceLowercase(false))
+	o.KeyPassphrase = r.Get("OPENVPN_KEY_PASSPHRASE", reader.ForceLowercase(false))
+	o.PIAEncPreset = r.Get("PRIVATE_INTERNET_ACCESS_OPENVPN_ENCRYPTION_PRESET",
+		reader.RetroKeys("ENCRYPTION", "PIA_ENCRYPTION"))
+
+	o.MSSFix, err = r.Uint16Ptr("OPENVPN_MSSFIX")
+	if err != nil {
+		return err
+	}
+
+	o.Interface = r.String("VPN_INTERFACE",
+		reader.RetroKeys("OPENVPN_INTERFACE"), reader.ForceLowercase(false))
+
+	o.ProcessUser, err = readOpenVPNProcessUser(r)
+	if err != nil {
+		return err
+	}
+
+	o.Verbosity, err = r.IntPtr("OPENVPN_VERBOSITY")
+	if err != nil {
+		return err
+	}
+
+	flagsPtr := r.Get("OPENVPN_FLAGS", reader.ForceLowercase(false))
+	if flagsPtr != nil {
+		o.Flags = strings.Fields(*flagsPtr)
+	}
+
+	return nil
+}
+
+func readOpenVPNProcessUser(r *reader.Reader) (processUser string, err error) {
+	value, err := r.BoolPtr("OPENVPN_ROOT") // Retro-compatibility
+	if err != nil {
+		return "", err
+	} else if value != nil {
+		if *value {
+			return "root", nil
+		}
+		const defaultNonRootUser = "nonrootuser"
+		return defaultNonRootUser, nil
+	}
+
+	return r.String("OPENVPN_PROCESS_USER"), nil
+}

internal/configuration/settings/openvpnselection.go

@@ -9,6 +9,7 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/provider/privateinternetaccess/presets"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -146,23 +147,16 @@ func (o *OpenVPNSelection) copy() (copied OpenVPNSelection) {
 	}
 }
 
-func (o *OpenVPNSelection) mergeWith(other OpenVPNSelection) {
-	o.ConfFile = gosettings.MergeWithPointer(o.ConfFile, other.ConfFile)
-	o.Protocol = gosettings.MergeWithString(o.Protocol, other.Protocol)
-	o.CustomPort = gosettings.MergeWithPointer(o.CustomPort, other.CustomPort)
-	o.PIAEncPreset = gosettings.MergeWithPointer(o.PIAEncPreset, other.PIAEncPreset)
-}
-
 func (o *OpenVPNSelection) overrideWith(other OpenVPNSelection) {
 	o.ConfFile = gosettings.OverrideWithPointer(o.ConfFile, other.ConfFile)
-	o.Protocol = gosettings.OverrideWithString(o.Protocol, other.Protocol)
+	o.Protocol = gosettings.OverrideWithComparable(o.Protocol, other.Protocol)
 	o.CustomPort = gosettings.OverrideWithPointer(o.CustomPort, other.CustomPort)
 	o.PIAEncPreset = gosettings.OverrideWithPointer(o.PIAEncPreset, other.PIAEncPreset)
 }
 
 func (o *OpenVPNSelection) setDefaults(vpnProvider string) {
 	o.ConfFile = gosettings.DefaultPointer(o.ConfFile, "")
-	o.Protocol = gosettings.DefaultString(o.Protocol, constants.UDP)
+	o.Protocol = gosettings.DefaultComparable(o.Protocol, constants.UDP)
 	o.CustomPort = gosettings.DefaultPointer(o.CustomPort, 0)
 
 	var defaultEncPreset string
@@ -194,3 +188,23 @@ func (o OpenVPNSelection) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (o *OpenVPNSelection) read(r *reader.Reader) (err error) {
+	o.ConfFile = r.Get("OPENVPN_CUSTOM_CONFIG", reader.ForceLowercase(false))
+
+	o.Protocol = r.String("OPENVPN_PROTOCOL", reader.RetroKeys("PROTOCOL"))
+	if err != nil {
+		return err
+	}
+
+	o.CustomPort, err = r.Uint16Ptr("VPN_ENDPOINT_PORT",
+		reader.RetroKeys("PORT", "OPENVPN_PORT"))
+	if err != nil {
+		return err
+	}
+
+	o.PIAEncPreset = r.Get("PRIVATE_INTERNET_ACCESS_OPENVPN_ENCRYPTION_PRESET",
+		reader.RetroKeys("ENCRYPTION", "PIA_ENCRYPTION"))
+
+	return nil
+}

internal/configuration/settings/portforward.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -72,13 +73,6 @@ func (p *PortForwarding) Copy() (copied PortForwarding) {
 	}
 }
 
-func (p *PortForwarding) mergeWith(other PortForwarding) {
-	p.Enabled = gosettings.MergeWithPointer(p.Enabled, other.Enabled)
-	p.Provider = gosettings.MergeWithPointer(p.Provider, other.Provider)
-	p.Filepath = gosettings.MergeWithPointer(p.Filepath, other.Filepath)
-	p.ListeningPort = gosettings.MergeWithPointer(p.ListeningPort, other.ListeningPort)
-}
-
 func (p *PortForwarding) OverrideWith(other PortForwarding) {
 	p.Enabled = gosettings.OverrideWithPointer(p.Enabled, other.Enabled)
 	p.Provider = gosettings.OverrideWithPointer(p.Provider, other.Provider)
@@ -124,3 +118,30 @@ func (p PortForwarding) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (p *PortForwarding) read(r *reader.Reader) (err error) {
+	p.Enabled, err = r.BoolPtr("VPN_PORT_FORWARDING",
+		reader.RetroKeys(
+			"PORT_FORWARDING",
+			"PRIVATE_INTERNET_ACCESS_VPN_PORT_FORWARDING",
+		))
+	if err != nil {
+		return err
+	}
+
+	p.Provider = r.Get("VPN_PORT_FORWARDING_PROVIDER")
+
+	p.Filepath = r.Get("VPN_PORT_FORWARDING_STATUS_FILE",
+		reader.ForceLowercase(false),
+		reader.RetroKeys(
+			"PORT_FORWARDING_STATUS_FILE",
+			"PRIVATE_INTERNET_ACCESS_VPN_PORT_FORWARDING_STATUS_FILE",
+		))
+
+	p.ListeningPort, err = r.Uint16Ptr("VPN_PORT_FORWARDING_LISTENING_PORT")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/provider.go

@@ -2,10 +2,12 @@ package settings
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -65,20 +67,14 @@ func (p *Provider) copy() (copied Provider) {
 	}
 }
 
-func (p *Provider) mergeWith(other Provider) {
-	p.Name = gosettings.MergeWithString(p.Name, other.Name)
-	p.ServerSelection.mergeWith(other.ServerSelection)
-	p.PortForwarding.mergeWith(other.PortForwarding)
-}
-
 func (p *Provider) overrideWith(other Provider) {
-	p.Name = gosettings.OverrideWithString(p.Name, other.Name)
+	p.Name = gosettings.OverrideWithComparable(p.Name, other.Name)
 	p.ServerSelection.overrideWith(other.ServerSelection)
 	p.PortForwarding.OverrideWith(other.PortForwarding)
 }
 
 func (p *Provider) setDefaults() {
-	p.Name = gosettings.DefaultString(p.Name, providers.PrivateInternetAccess)
+	p.Name = gosettings.DefaultComparable(p.Name, providers.PrivateInternetAccess)
 	p.ServerSelection.setDefaults(p.Name)
 	p.PortForwarding.setDefaults()
 }
@@ -94,3 +90,37 @@ func (p Provider) toLinesNode() (node *gotree.Node) {
 	node.AppendNode(p.PortForwarding.toLinesNode())
 	return node
 }
+
+func (p *Provider) read(r *reader.Reader, vpnType string) (err error) {
+	p.Name = readVPNServiceProvider(r, vpnType)
+
+	err = p.ServerSelection.read(r, p.Name, vpnType)
+	if err != nil {
+		return fmt.Errorf("server selection: %w", err)
+	}
+
+	err = p.PortForwarding.read(r)
+	if err != nil {
+		return fmt.Errorf("port forwarding: %w", err)
+	}
+
+	return nil
+}
+
+func readVPNServiceProvider(r *reader.Reader, vpnType string) (vpnProvider string) {
+	vpnProvider = r.String("VPN_SERVICE_PROVIDER", reader.RetroKeys("VPNSP"))
+	if vpnProvider == "" {
+		if vpnType != vpn.Wireguard && r.Get("OPENVPN_CUSTOM_CONFIG") != nil {
+			// retro compatibility
+			return providers.Custom
+		}
+		return ""
+	}
+
+	vpnProvider = strings.ToLower(vpnProvider)
+	if vpnProvider == "pia" { // retro compatibility
+		return providers.PrivateInternetAccess
+	}
+
+	return vpnProvider
+}

internal/configuration/settings/publicip.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/qdm12/gluetun/internal/publicip/api"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -77,17 +78,10 @@ func (p *PublicIP) copy() (copied PublicIP) {
 	}
 }
 
-func (p *PublicIP) mergeWith(other PublicIP) {
-	p.Period = gosettings.MergeWithPointer(p.Period, other.Period)
-	p.IPFilepath = gosettings.MergeWithPointer(p.IPFilepath, other.IPFilepath)
-	p.API = gosettings.MergeWithString(p.API, other.API)
-	p.APIToken = gosettings.MergeWithPointer(p.APIToken, other.APIToken)
-}
-
 func (p *PublicIP) overrideWith(other PublicIP) {
 	p.Period = gosettings.OverrideWithPointer(p.Period, other.Period)
 	p.IPFilepath = gosettings.OverrideWithPointer(p.IPFilepath, other.IPFilepath)
-	p.API = gosettings.OverrideWithString(p.API, other.API)
+	p.API = gosettings.OverrideWithComparable(p.API, other.API)
 	p.APIToken = gosettings.OverrideWithPointer(p.APIToken, other.APIToken)
 }
 
@@ -95,7 +89,7 @@ func (p *PublicIP) setDefaults() {
 	const defaultPeriod = 12 * time.Hour
 	p.Period = gosettings.DefaultPointer(p.Period, defaultPeriod)
 	p.IPFilepath = gosettings.DefaultPointer(p.IPFilepath, "/tmp/gluetun/ip")
-	p.API = gosettings.DefaultString(p.API, "ipinfo")
+	p.API = gosettings.DefaultComparable(p.API, "ipinfo")
 	p.APIToken = gosettings.DefaultPointer(p.APIToken, "")
 }
 
@@ -129,3 +123,16 @@ func (p PublicIP) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (p *PublicIP) read(r *reader.Reader) (err error) {
+	p.Period, err = r.DurationPtr("PUBLICIP_PERIOD")
+	if err != nil {
+		return err
+	}
+
+	p.IPFilepath = r.Get("PUBLICIP_FILE",
+		reader.ForceLowercase(false), reader.RetroKeys("IP_STATUS_FILE"))
+	p.API = r.String("PUBLICIP_API")
+	p.APIToken = r.Get("PUBLICIP_API_TOKEN")
+	return nil
+}

internal/configuration/settings/server.go

@@ -7,6 +7,7 @@ import (
 	"strconv"
 
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -48,13 +49,6 @@ func (c *ControlServer) copy() (copied ControlServer) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (c *ControlServer) mergeWith(other ControlServer) {
-	c.Address = gosettings.MergeWithPointer(c.Address, other.Address)
-	c.Log = gosettings.MergeWithPointer(c.Log, other.Log)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -78,3 +72,12 @@ func (c ControlServer) toLinesNode() (node *gotree.Node) {
 	node.Appendf("Logging: %s", gosettings.BoolToYesNo(c.Log))
 	return node
 }
+
+func (c *ControlServer) read(r *reader.Reader) (err error) {
+	c.Log, err = r.BoolPtr("HTTP_CONTROL_SERVER_LOG")
+	if err != nil {
+		return err
+	}
+	c.Address = r.Get("HTTP_CONTROL_SERVER_ADDRESS")
+	return nil
+}

internal/configuration/settings/serverselection.go

@@ -12,6 +12,7 @@ import (
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -257,30 +258,8 @@ func (ss *ServerSelection) copy() (copied ServerSelection) {
 	}
 }
 
-func (ss *ServerSelection) mergeWith(other ServerSelection) {
-	ss.VPN = gosettings.MergeWithString(ss.VPN, other.VPN)
-	ss.TargetIP = gosettings.MergeWithValidator(ss.TargetIP, other.TargetIP)
-	ss.Countries = gosettings.MergeWithSlice(ss.Countries, other.Countries)
-	ss.Categories = gosettings.MergeWithSlice(ss.Categories, other.Categories)
-	ss.Regions = gosettings.MergeWithSlice(ss.Regions, other.Regions)
-	ss.Cities = gosettings.MergeWithSlice(ss.Cities, other.Cities)
-	ss.ISPs = gosettings.MergeWithSlice(ss.ISPs, other.ISPs)
-	ss.Hostnames = gosettings.MergeWithSlice(ss.Hostnames, other.Hostnames)
-	ss.Names = gosettings.MergeWithSlice(ss.Names, other.Names)
-	ss.Numbers = gosettings.MergeWithSlice(ss.Numbers, other.Numbers)
-	ss.OwnedOnly = gosettings.MergeWithPointer(ss.OwnedOnly, other.OwnedOnly)
-	ss.FreeOnly = gosettings.MergeWithPointer(ss.FreeOnly, other.FreeOnly)
-	ss.PremiumOnly = gosettings.MergeWithPointer(ss.PremiumOnly, other.PremiumOnly)
-	ss.StreamOnly = gosettings.MergeWithPointer(ss.StreamOnly, other.StreamOnly)
-	ss.MultiHopOnly = gosettings.MergeWithPointer(ss.MultiHopOnly, other.MultiHopOnly)
-	ss.PortForwardOnly = gosettings.MergeWithPointer(ss.PortForwardOnly, other.PortForwardOnly)
-
-	ss.OpenVPN.mergeWith(other.OpenVPN)
-	ss.Wireguard.mergeWith(other.Wireguard)
-}
-
 func (ss *ServerSelection) overrideWith(other ServerSelection) {
-	ss.VPN = gosettings.OverrideWithString(ss.VPN, other.VPN)
+	ss.VPN = gosettings.OverrideWithComparable(ss.VPN, other.VPN)
 	ss.TargetIP = gosettings.OverrideWithValidator(ss.TargetIP, other.TargetIP)
 	ss.Countries = gosettings.OverrideWithSlice(ss.Countries, other.Countries)
 	ss.Categories = gosettings.OverrideWithSlice(ss.Categories, other.Categories)
@@ -301,7 +280,7 @@ func (ss *ServerSelection) overrideWith(other ServerSelection) {
 }
 
 func (ss *ServerSelection) setDefaults(vpnProvider string) {
-	ss.VPN = gosettings.DefaultString(ss.VPN, vpn.OpenVPN)
+	ss.VPN = gosettings.DefaultComparable(ss.VPN, vpn.OpenVPN)
 	ss.TargetIP = gosettings.DefaultValidator(ss.TargetIP, netip.IPv4Unspecified())
 	ss.OwnedOnly = gosettings.DefaultPointer(ss.OwnedOnly, false)
 	ss.FreeOnly = gosettings.DefaultPointer(ss.FreeOnly, false)
@@ -394,3 +373,79 @@ func (ss ServerSelection) WithDefaults(provider string) ServerSelection {
 	ss.setDefaults(provider)
 	return ss
 }
+
+func (ss *ServerSelection) read(r *reader.Reader,
+	vpnProvider, vpnType string) (err error) {
+	ss.VPN = vpnType
+
+	ss.TargetIP, err = r.NetipAddr("VPN_ENDPOINT_IP",
+		reader.RetroKeys("OPENVPN_TARGET_IP"))
+	if err != nil {
+		return err
+	}
+
+	countriesRetroKeys := []string{"COUNTRY"}
+	if vpnProvider == providers.Cyberghost {
+		countriesRetroKeys = append(countriesRetroKeys, "REGION")
+	}
+	ss.Countries = r.CSV("SERVER_COUNTRIES", reader.RetroKeys(countriesRetroKeys...))
+
+	ss.Regions = r.CSV("SERVER_REGIONS", reader.RetroKeys("REGION"))
+	ss.Cities = r.CSV("SERVER_CITIES", reader.RetroKeys("CITY"))
+	ss.ISPs = r.CSV("ISP")
+	ss.Hostnames = r.CSV("SERVER_HOSTNAMES", reader.RetroKeys("SERVER_HOSTNAME"))
+	ss.Names = r.CSV("SERVER_NAMES", reader.RetroKeys("SERVER_NAME"))
+	ss.Numbers, err = r.CSVUint16("SERVER_NUMBER")
+	ss.Categories = r.CSV("SERVER_CATEGORIES")
+	if err != nil {
+		return err
+	}
+
+	// Mullvad only
+	ss.OwnedOnly, err = r.BoolPtr("OWNED_ONLY", reader.RetroKeys("OWNED"))
+	if err != nil {
+		return err
+	}
+
+	// VPNUnlimited and ProtonVPN only
+	ss.FreeOnly, err = r.BoolPtr("FREE_ONLY")
+	if err != nil {
+		return err
+	}
+
+	// VPNSecure only
+	ss.PremiumOnly, err = r.BoolPtr("PREMIUM_ONLY")
+	if err != nil {
+		return err
+	}
+
+	// Surfshark only
+	ss.MultiHopOnly, err = r.BoolPtr("MULTIHOP_ONLY")
+	if err != nil {
+		return err
+	}
+
+	// VPNUnlimited only
+	ss.StreamOnly, err = r.BoolPtr("STREAM_ONLY")
+	if err != nil {
+		return err
+	}
+
+	// PIA only
+	ss.PortForwardOnly, err = r.BoolPtr("PORT_FORWARD_ONLY")
+	if err != nil {
+		return err
+	}
+
+	err = ss.OpenVPN.read(r)
+	if err != nil {
+		return err
+	}
+
+	err = ss.Wireguard.read(r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/settings.go

@@ -2,12 +2,14 @@ package settings
 
 import (
 	"fmt"
+	"net/netip"
 
 	"github.com/qdm12/gluetun/internal/configuration/settings/helpers"
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/pprof"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -81,22 +83,6 @@ func (s *Settings) copy() (copied Settings) {
 	}
 }
 
-func (s *Settings) MergeWith(other Settings) {
-	s.ControlServer.mergeWith(other.ControlServer)
-	s.DNS.mergeWith(other.DNS)
-	s.Firewall.mergeWith(other.Firewall)
-	s.Health.MergeWith(other.Health)
-	s.HTTPProxy.mergeWith(other.HTTPProxy)
-	s.Log.mergeWith(other.Log)
-	s.PublicIP.mergeWith(other.PublicIP)
-	s.Shadowsocks.mergeWith(other.Shadowsocks)
-	s.System.mergeWith(other.System)
-	s.Updater.mergeWith(other.Updater)
-	s.Version.mergeWith(other.Version)
-	s.VPN.mergeWith(other.VPN)
-	s.Pprof.MergeWith(other.Pprof)
-}
-
 func (s *Settings) OverrideWith(other Settings,
 	storage Storage, ipv6Supported bool) (err error) {
 	patchedSettings := s.copy()
@@ -179,5 +165,41 @@ func (s Settings) Warnings() (warnings []string) {
 			"by creating an issue, attaching the new certificate and we will update Gluetun.")
 	}
 
+	// TODO remove in v4
+	if s.DNS.ServerAddress.Unmap().Compare(netip.AddrFrom4([4]byte{127, 0, 0, 1})) != 0 {
+		warnings = append(warnings, "DNS address is set to "+s.DNS.ServerAddress.String()+
+			" so the DNS over TLS (DoT) server will not be used."+
+			" The default value changed to 127.0.0.1 so it uses the internal DoT serves."+
+			" If the DoT server fails to start, the IPv4 address of the first plaintext DNS server"+
+			" corresponding to the first DoT provider chosen is used.")
+	}
+
 	return warnings
 }
+
+func (s *Settings) Read(r *reader.Reader) (err error) {
+	readFunctions := map[string]func(r *reader.Reader) error{
+		"control server": s.ControlServer.read,
+		"DNS":            s.DNS.read,
+		"firewall":       s.Firewall.read,
+		"health":         s.Health.Read,
+		"http proxy":     s.HTTPProxy.read,
+		"log":            s.Log.read,
+		"public ip":      s.PublicIP.read,
+		"shadowsocks":    s.Shadowsocks.read,
+		"system":         s.System.read,
+		"updater":        s.Updater.read,
+		"version":        s.Version.read,
+		"VPN":            s.VPN.read,
+		"profiling":      s.Pprof.Read,
+	}
+
+	for name, read := range readFunctions {
+		err = read(r)
+		if err != nil {
+			return fmt.Errorf("reading %s settings: %w", name, err)
+		}
+	}
+
+	return nil
+}

internal/configuration/settings/shadowsocks.go

@@ -1,7 +1,10 @@
 package settings
 
 import (
+	"fmt"
+
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 	"github.com/qdm12/ss-server/pkg/tcpudp"
 )
@@ -26,13 +29,6 @@ func (s *Shadowsocks) copy() (copied Shadowsocks) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (s *Shadowsocks) mergeWith(other Shadowsocks) {
-	s.Enabled = gosettings.MergeWithPointer(s.Enabled, other.Enabled)
-	s.Settings = s.Settings.MergeWith(other.Settings)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -59,10 +55,44 @@ func (s Shadowsocks) toLinesNode() (node *gotree.Node) {
 	}
 
 	// TODO have ToLinesNode in qdm12/ss-server
-	node.Appendf("Listening address: %s", *s.Address)
-	node.Appendf("Cipher: %s", s.CipherName)
-	node.Appendf("Password: %s", gosettings.ObfuscateKey(*s.Password))
-	node.Appendf("Log addresses: %s", gosettings.BoolToYesNo(s.LogAddresses))
+	node.Appendf("Listening address: %s", *s.Settings.Address)
+	node.Appendf("Cipher: %s", s.Settings.CipherName)
+	node.Appendf("Password: %s", gosettings.ObfuscateKey(*s.Settings.Password))
+	node.Appendf("Log addresses: %s", gosettings.BoolToYesNo(s.Settings.LogAddresses))
 
 	return node
 }
+
+func (s *Shadowsocks) read(r *reader.Reader) (err error) {
+	s.Enabled, err = r.BoolPtr("SHADOWSOCKS")
+	if err != nil {
+		return err
+	}
+
+	s.Settings.Address, err = readShadowsocksAddress(r)
+	if err != nil {
+		return err
+	}
+	s.Settings.LogAddresses, err = r.BoolPtr("SHADOWSOCKS_LOG")
+	if err != nil {
+		return err
+	}
+	s.Settings.CipherName = r.String("SHADOWSOCKS_CIPHER",
+		reader.RetroKeys("SHADOWSOCKS_METHOD"))
+	s.Settings.Password = r.Get("SHADOWSOCKS_PASSWORD",
+		reader.ForceLowercase(false))
+
+	return nil
+}
+
+func readShadowsocksAddress(r *reader.Reader) (address *string, err error) {
+	const currentKey = "SHADOWSOCKS_LISTENING_ADDRESS"
+	port, err := r.Uint16Ptr("SHADOWSOCKS_PORT", reader.IsRetro(currentKey)) // retro-compatibility
+	if err != nil {
+		return nil, err
+	} else if port != nil {
+		return ptrTo(fmt.Sprintf(":%d", *port)), nil
+	}
+
+	return r.Get(currentKey), nil
+}

internal/configuration/settings/system.go

@@ -2,6 +2,7 @@ package settings
 
 import (
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -25,16 +26,10 @@ func (s *System) copy() (copied System) {
 	}
 }
 
-func (s *System) mergeWith(other System) {
-	s.PUID = gosettings.MergeWithPointer(s.PUID, other.PUID)
-	s.PGID = gosettings.MergeWithPointer(s.PGID, other.PGID)
-	s.Timezone = gosettings.MergeWithString(s.Timezone, other.Timezone)
-}
-
 func (s *System) overrideWith(other System) {
 	s.PUID = gosettings.OverrideWithPointer(s.PUID, other.PUID)
 	s.PGID = gosettings.OverrideWithPointer(s.PGID, other.PGID)
-	s.Timezone = gosettings.OverrideWithString(s.Timezone, other.Timezone)
+	s.Timezone = gosettings.OverrideWithComparable(s.Timezone, other.Timezone)
 }
 
 func (s *System) setDefaults() {
@@ -59,3 +54,18 @@ func (s System) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (s *System) read(r *reader.Reader) (err error) {
+	s.PUID, err = r.Uint32Ptr("PUID", reader.RetroKeys("UID"))
+	if err != nil {
+		return err
+	}
+
+	s.PGID, err = r.Uint32Ptr("PGID", reader.RetroKeys("GID"))
+	if err != nil {
+		return err
+	}
+
+	s.Timezone = r.String("TZ")
+	return nil
+}

internal/configuration/settings/unbound.go

@@ -8,6 +8,7 @@ import (
 	"github.com/qdm12/dns/pkg/provider"
 	"github.com/qdm12/dns/pkg/unbound"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -49,7 +50,7 @@ func (u *Unbound) setDefaults() {
 		}
 	}
 
-	u.Username = gosettings.DefaultString(u.Username, "root")
+	u.Username = gosettings.DefaultComparable(u.Username, "root")
 }
 
 var (
@@ -105,17 +106,6 @@ func (u Unbound) copy() (copied Unbound) {
 	}
 }
 
-func (u *Unbound) mergeWith(other Unbound) {
-	u.Providers = gosettings.MergeWithSlice(u.Providers, other.Providers)
-	u.Caching = gosettings.MergeWithPointer(u.Caching, other.Caching)
-	u.IPv6 = gosettings.MergeWithPointer(u.IPv6, other.IPv6)
-	u.VerbosityLevel = gosettings.MergeWithPointer(u.VerbosityLevel, other.VerbosityLevel)
-	u.VerbosityDetailsLevel = gosettings.MergeWithPointer(u.VerbosityDetailsLevel, other.VerbosityDetailsLevel)
-	u.ValidationLogLevel = gosettings.MergeWithPointer(u.ValidationLogLevel, other.ValidationLogLevel)
-	u.Username = gosettings.MergeWithString(u.Username, other.Username)
-	u.Allowed = gosettings.MergeWithSlice(u.Allowed, other.Allowed)
-}
-
 func (u *Unbound) overrideWith(other Unbound) {
 	u.Providers = gosettings.OverrideWithSlice(u.Providers, other.Providers)
 	u.Caching = gosettings.OverrideWithPointer(u.Caching, other.Caching)
@@ -123,7 +113,7 @@ func (u *Unbound) overrideWith(other Unbound) {
 	u.VerbosityLevel = gosettings.OverrideWithPointer(u.VerbosityLevel, other.VerbosityLevel)
 	u.VerbosityDetailsLevel = gosettings.OverrideWithPointer(u.VerbosityDetailsLevel, other.VerbosityDetailsLevel)
 	u.ValidationLogLevel = gosettings.OverrideWithPointer(u.ValidationLogLevel, other.ValidationLogLevel)
-	u.Username = gosettings.OverrideWithString(u.Username, other.Username)
+	u.Username = gosettings.OverrideWithComparable(u.Username, other.Username)
 	u.Allowed = gosettings.OverrideWithSlice(u.Allowed, other.Allowed)
 }
 
@@ -200,3 +190,34 @@ func (u Unbound) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (u *Unbound) read(reader *reader.Reader) (err error) {
+	u.Providers = reader.CSV("DOT_PROVIDERS")
+
+	u.Caching, err = reader.BoolPtr("DOT_CACHING")
+	if err != nil {
+		return err
+	}
+
+	u.IPv6, err = reader.BoolPtr("DOT_IPV6")
+	if err != nil {
+		return err
+	}
+
+	u.VerbosityLevel, err = reader.Uint8Ptr("DOT_VERBOSITY")
+	if err != nil {
+		return err
+	}
+
+	u.VerbosityDetailsLevel, err = reader.Uint8Ptr("DOT_VERBOSITY_DETAILS")
+	if err != nil {
+		return err
+	}
+
+	u.ValidationLogLevel, err = reader.Uint8Ptr("DOT_VALIDATION_LOGLEVEL")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/updater.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -64,28 +65,19 @@ func (u *Updater) copy() (copied Updater) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (u *Updater) mergeWith(other Updater) {
-	u.Period = gosettings.MergeWithPointer(u.Period, other.Period)
-	u.DNSAddress = gosettings.MergeWithString(u.DNSAddress, other.DNSAddress)
-	u.MinRatio = gosettings.MergeWithNumber(u.MinRatio, other.MinRatio)
-	u.Providers = gosettings.MergeWithSlice(u.Providers, other.Providers)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
 func (u *Updater) overrideWith(other Updater) {
 	u.Period = gosettings.OverrideWithPointer(u.Period, other.Period)
-	u.DNSAddress = gosettings.OverrideWithString(u.DNSAddress, other.DNSAddress)
-	u.MinRatio = gosettings.OverrideWithNumber(u.MinRatio, other.MinRatio)
+	u.DNSAddress = gosettings.OverrideWithComparable(u.DNSAddress, other.DNSAddress)
+	u.MinRatio = gosettings.OverrideWithComparable(u.MinRatio, other.MinRatio)
 	u.Providers = gosettings.OverrideWithSlice(u.Providers, other.Providers)
 }
 
 func (u *Updater) SetDefaults(vpnProvider string) {
 	u.Period = gosettings.DefaultPointer(u.Period, 0)
-	u.DNSAddress = gosettings.DefaultString(u.DNSAddress, "1.1.1.1:53")
+	u.DNSAddress = gosettings.DefaultComparable(u.DNSAddress, "1.1.1.1:53")
 
 	if u.MinRatio == 0 {
 		const defaultMinRatio = 0.8
@@ -114,3 +106,33 @@ func (u Updater) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (u *Updater) read(r *reader.Reader) (err error) {
+	u.Period, err = r.DurationPtr("UPDATER_PERIOD")
+	if err != nil {
+		return err
+	}
+
+	u.DNSAddress, err = readUpdaterDNSAddress()
+	if err != nil {
+		return err
+	}
+
+	u.MinRatio, err = r.Float64("UPDATER_MIN_RATIO")
+	if err != nil {
+		return err
+	}
+
+	u.Providers = r.CSV("UPDATER_VPN_SERVICE_PROVIDERS")
+
+	return nil
+}
+
+func readUpdaterDNSAddress() (address string, err error) {
+	// TODO this is currently using Cloudflare in
+	// plaintext to not be blocked by DNS over TLS by default.
+	// If a plaintext address is set in the DNS settings, this one will be used.
+	// use custom future encrypted DNS written in Go without blocking
+	// as it's too much trouble to start another parallel unbound instance for now.
+	return "", nil
+}

internal/configuration/settings/version.go

@@ -2,6 +2,7 @@ package settings
 
 import (
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gotree"
 )
 
@@ -23,12 +24,6 @@ func (v *Version) copy() (copied Version) {
 	}
 }
 
-// mergeWith merges the other settings into any
-// unset field of the receiver settings object.
-func (v *Version) mergeWith(other Version) {
-	v.Enabled = gosettings.MergeWithPointer(v.Enabled, other.Enabled)
-}
-
 // overrideWith overrides fields of the receiver
 // settings object with any field set in the other
 // settings.
@@ -51,3 +46,12 @@ func (v Version) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (v *Version) read(r *reader.Reader) (err error) {
+	v.Enabled, err = r.BoolPtr("VERSION_INFORMATION")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/settings/vpn.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 )
@@ -56,22 +57,15 @@ func (v *VPN) Copy() (copied VPN) {
 	}
 }
 
-func (v *VPN) mergeWith(other VPN) {
-	v.Type = gosettings.MergeWithString(v.Type, other.Type)
-	v.Provider.mergeWith(other.Provider)
-	v.OpenVPN.mergeWith(other.OpenVPN)
-	v.Wireguard.mergeWith(other.Wireguard)
-}
-
 func (v *VPN) OverrideWith(other VPN) {
-	v.Type = gosettings.OverrideWithString(v.Type, other.Type)
+	v.Type = gosettings.OverrideWithComparable(v.Type, other.Type)
 	v.Provider.overrideWith(other.Provider)
 	v.OpenVPN.overrideWith(other.OpenVPN)
 	v.Wireguard.overrideWith(other.Wireguard)
 }
 
 func (v *VPN) setDefaults() {
-	v.Type = gosettings.DefaultString(v.Type, vpn.OpenVPN)
+	v.Type = gosettings.DefaultComparable(v.Type, vpn.OpenVPN)
 	v.Provider.setDefaults()
 	v.OpenVPN.setDefaults(v.Provider.Name)
 	v.Wireguard.setDefaults(v.Provider.Name)
@@ -94,3 +88,24 @@ func (v VPN) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (v *VPN) read(r *reader.Reader) (err error) {
+	v.Type = r.String("VPN_TYPE")
+
+	err = v.Provider.read(r, v.Type)
+	if err != nil {
+		return fmt.Errorf("VPN provider: %w", err)
+	}
+
+	err = v.OpenVPN.read(r)
+	if err != nil {
+		return fmt.Errorf("OpenVPN: %w", err)
+	}
+
+	err = v.Wireguard.read(r)
+	if err != nil {
+		return fmt.Errorf("wireguard: %w", err)
+	}
+
+	return nil
+}

internal/configuration/settings/wireguard.go

@@ -8,6 +8,7 @@ import (
 	"github.com/qdm12/gluetun/internal/configuration/settings/helpers"
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
@@ -147,24 +148,14 @@ func (w *Wireguard) copy() (copied Wireguard) {
 	}
 }
 
-func (w *Wireguard) mergeWith(other Wireguard) {
-	w.PrivateKey = gosettings.MergeWithPointer(w.PrivateKey, other.PrivateKey)
-	w.PreSharedKey = gosettings.MergeWithPointer(w.PreSharedKey, other.PreSharedKey)
-	w.Addresses = gosettings.MergeWithSlice(w.Addresses, other.Addresses)
-	w.AllowedIPs = gosettings.MergeWithSlice(w.AllowedIPs, other.AllowedIPs)
-	w.Interface = gosettings.MergeWithString(w.Interface, other.Interface)
-	w.MTU = gosettings.MergeWithNumber(w.MTU, other.MTU)
-	w.Implementation = gosettings.MergeWithString(w.Implementation, other.Implementation)
-}
-
 func (w *Wireguard) overrideWith(other Wireguard) {
 	w.PrivateKey = gosettings.OverrideWithPointer(w.PrivateKey, other.PrivateKey)
 	w.PreSharedKey = gosettings.OverrideWithPointer(w.PreSharedKey, other.PreSharedKey)
 	w.Addresses = gosettings.OverrideWithSlice(w.Addresses, other.Addresses)
 	w.AllowedIPs = gosettings.OverrideWithSlice(w.AllowedIPs, other.AllowedIPs)
-	w.Interface = gosettings.OverrideWithString(w.Interface, other.Interface)
-	w.MTU = gosettings.OverrideWithNumber(w.MTU, other.MTU)
-	w.Implementation = gosettings.OverrideWithString(w.Implementation, other.Implementation)
+	w.Interface = gosettings.OverrideWithComparable(w.Interface, other.Interface)
+	w.MTU = gosettings.OverrideWithComparable(w.MTU, other.MTU)
+	w.Implementation = gosettings.OverrideWithComparable(w.Implementation, other.Implementation)
 }
 
 func (w *Wireguard) setDefaults(vpnProvider string) {
@@ -180,10 +171,10 @@ func (w *Wireguard) setDefaults(vpnProvider string) {
 		netip.PrefixFrom(netip.IPv6Unspecified(), 0),
 	}
 	w.AllowedIPs = gosettings.DefaultSlice(w.AllowedIPs, defaultAllowedIPs)
-	w.Interface = gosettings.DefaultString(w.Interface, "wg0")
+	w.Interface = gosettings.DefaultComparable(w.Interface, "wg0")
 	const defaultMTU = 1400
-	w.MTU = gosettings.DefaultNumber(w.MTU, defaultMTU)
-	w.Implementation = gosettings.DefaultString(w.Implementation, "auto")
+	w.MTU = gosettings.DefaultComparable(w.MTU, defaultMTU)
+	w.Implementation = gosettings.DefaultComparable(w.Implementation, "auto")
 }
 
 func (w Wireguard) String() string {
@@ -222,3 +213,27 @@ func (w Wireguard) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (w *Wireguard) read(r *reader.Reader) (err error) {
+	w.PrivateKey = r.Get("WIREGUARD_PRIVATE_KEY", reader.ForceLowercase(false))
+	w.PreSharedKey = r.Get("WIREGUARD_PRESHARED_KEY", reader.ForceLowercase(false))
+	w.Interface = r.String("VPN_INTERFACE",
+		reader.RetroKeys("WIREGUARD_INTERFACE"), reader.ForceLowercase(false))
+	w.Implementation = r.String("WIREGUARD_IMPLEMENTATION")
+	w.Addresses, err = r.CSVNetipPrefixes("WIREGUARD_ADDRESSES",
+		reader.RetroKeys("WIREGUARD_ADDRESS"))
+	if err != nil {
+		return err // already wrapped
+	}
+	w.AllowedIPs, err = r.CSVNetipPrefixes("WIREGUARD_ALLOWED_IPS")
+	if err != nil {
+		return err // already wrapped
+	}
+	mtuPtr, err := r.Uint16Ptr("WIREGUARD_MTU")
+	if err != nil {
+		return err
+	} else if mtuPtr != nil {
+		w.MTU = *mtuPtr
+	}
+	return nil
+}

internal/configuration/settings/wireguardselection.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gosettings"
+	"github.com/qdm12/gosettings/reader"
 	"github.com/qdm12/gosettings/validate"
 	"github.com/qdm12/gotree"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
@@ -116,16 +117,10 @@ func (w *WireguardSelection) copy() (copied WireguardSelection) {
 	}
 }
 
-func (w *WireguardSelection) mergeWith(other WireguardSelection) {
-	w.EndpointIP = gosettings.MergeWithValidator(w.EndpointIP, other.EndpointIP)
-	w.EndpointPort = gosettings.MergeWithPointer(w.EndpointPort, other.EndpointPort)
-	w.PublicKey = gosettings.MergeWithString(w.PublicKey, other.PublicKey)
-}
-
 func (w *WireguardSelection) overrideWith(other WireguardSelection) {
 	w.EndpointIP = gosettings.OverrideWithValidator(w.EndpointIP, other.EndpointIP)
 	w.EndpointPort = gosettings.OverrideWithPointer(w.EndpointPort, other.EndpointPort)
-	w.PublicKey = gosettings.OverrideWithString(w.PublicKey, other.PublicKey)
+	w.PublicKey = gosettings.OverrideWithComparable(w.PublicKey, other.PublicKey)
 }
 
 func (w *WireguardSelection) setDefaults() {
@@ -154,3 +149,18 @@ func (w WireguardSelection) toLinesNode() (node *gotree.Node) {
 
 	return node
 }
+
+func (w *WireguardSelection) read(r *reader.Reader) (err error) {
+	w.EndpointIP, err = r.NetipAddr("VPN_ENDPOINT_IP", reader.RetroKeys("WIREGUARD_ENDPOINT_IP"))
+	if err != nil {
+		return err
+	}
+
+	w.EndpointPort, err = r.Uint16Ptr("VPN_ENDPOINT_PORT", reader.RetroKeys("WIREGUARD_ENDPOINT_PORT"))
+	if err != nil {
+		return err
+	}
+
+	w.PublicKey = r.String("WIREGUARD_PUBLIC_KEY", reader.ForceLowercase(false))
+	return nil
+}