mirror of
https://github.com/qdm12/gluetun.git
synced 2025-12-11 13:56:50 -06:00
96 lines
2.8 KiB
Go
96 lines
2.8 KiB
Go
package configuration
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
|
|
"github.com/qdm12/gluetun/internal/constants"
|
|
"github.com/qdm12/golibs/params"
|
|
)
|
|
|
|
var (
|
|
errCustomNotSupported = errors.New("custom provider is not supported")
|
|
errCustomExtractFromFile = errors.New("cannot extract configuration from file")
|
|
)
|
|
|
|
func (settings *Provider) readCustom(r reader, vpnType string) (err error) {
|
|
settings.Name = constants.Custom
|
|
|
|
switch vpnType {
|
|
case constants.OpenVPN:
|
|
return settings.ServerSelection.OpenVPN.readCustom(r)
|
|
case constants.Wireguard:
|
|
return settings.ServerSelection.Wireguard.readCustom(r)
|
|
default:
|
|
return fmt.Errorf("%w: for VPN type %s", errCustomNotSupported, vpnType)
|
|
}
|
|
}
|
|
|
|
func (settings *OpenVPNSelection) readCustom(r reader) (err error) {
|
|
configFile, err := r.env.Get("OPENVPN_CUSTOM_CONFIG", params.CaseSensitiveValue(), params.Compulsory())
|
|
if err != nil {
|
|
return fmt.Errorf("environment variable OPENVPN_CUSTOM_CONFIG: %w", err)
|
|
}
|
|
settings.ConfFile = configFile
|
|
|
|
// For display and consistency purposes only,
|
|
// these values are not actually used since the file is re-read
|
|
// before each OpenVPN start.
|
|
_, connection, err := r.ovpnExt.Data(configFile)
|
|
if err != nil {
|
|
return fmt.Errorf("%w: %s", errCustomExtractFromFile, err)
|
|
}
|
|
settings.TCP = connection.Protocol == constants.TCP
|
|
|
|
return nil
|
|
}
|
|
|
|
func (settings *OpenVPN) readCustom(r reader) (err error) {
|
|
settings.ConfFile, err = r.env.Path("OPENVPN_CUSTOM_CONFIG",
|
|
params.Compulsory(), params.CaseSensitiveValue())
|
|
if err != nil {
|
|
return fmt.Errorf("environment variable OPENVPN_CUSTOM_CONFIG: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (settings *WireguardSelection) readCustom(r reader) (err error) {
|
|
settings.PublicKey, err = r.env.Get("WIREGUARD_PUBLIC_KEY",
|
|
params.CaseSensitiveValue(), params.Compulsory())
|
|
if err != nil {
|
|
return fmt.Errorf("environment variable WIREGUARD_PUBLIC_KEY: %w", err)
|
|
}
|
|
|
|
settings.EndpointIP, err = readWireguardEndpointIP(r.env)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
settings.EndpointPort, err = r.env.Port("WIREGUARD_ENDPOINT_PORT", params.Compulsory(),
|
|
params.RetroKeys([]string{"WIREGUARD_PORT"}, r.onRetroActive))
|
|
if err != nil {
|
|
return fmt.Errorf("environment variable WIREGUARD_ENDPOINT_PORT: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// readWireguardEndpointIP reads and parses the server endpoint IP
|
|
// address from the environment variable WIREGUARD_ENDPOINT_IP.
|
|
func readWireguardEndpointIP(env params.Interface) (endpointIP net.IP, err error) {
|
|
s, err := env.Get("WIREGUARD_ENDPOINT_IP", params.Compulsory())
|
|
if err != nil {
|
|
return nil, fmt.Errorf("environment variable WIREGUARD_ENDPOINT_IP: %w", err)
|
|
}
|
|
|
|
endpointIP = net.ParseIP(s)
|
|
if endpointIP == nil {
|
|
return nil, fmt.Errorf("environment variable WIREGUARD_ENDPOINT_IP: %w: %s",
|
|
ErrInvalidIP, s)
|
|
}
|
|
|
|
return endpointIP, nil
|
|
}
|