feat(protonvpn): Wireguard support (#2390)

internal/provider/protonvpn/connection.go

@@ -8,7 +8,7 @@ import (
 
 func (p *Provider) GetConnection(selection settings.ServerSelection, ipv6Supported bool) (
 	connection models.Connection, err error) {
-	defaults := utils.NewConnectionDefaults(443, 1194, 0) //nolint:gomnd
+	defaults := utils.NewConnectionDefaults(443, 1194, 51820) //nolint:gomnd
 	return utils.GetConnection(p.Name(),
 		p.storage, selection, defaults, ipv6Supported, p.randSource)
 }

internal/provider/protonvpn/updater/api.go

@@ -28,10 +28,11 @@ type logicalServer struct {
 }
 
 type physicalServer struct {
-	EntryIP netip.Addr `json:"EntryIP"`
-	ExitIP  netip.Addr `json:"ExitIP"`
-	Domain  string     `json:"Domain"`
-	Status  uint8      `json:"Status"`
+	EntryIP         netip.Addr `json:"EntryIP"`
+	ExitIP          netip.Addr `json:"ExitIP"`
+	Domain          string     `json:"Domain"`
+	Status          uint8      `json:"Status"`
+	X25519PublicKey string     `json:"X25519PublicKey"`
 }
 
 func fetchAPI(ctx context.Context, client *http.Client) (

internal/provider/protonvpn/updater/iptoserver.go

@@ -7,7 +7,7 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type ipToServer map[string]models.Server
+type ipToServers map[string][2]models.Server // first server is OpenVPN, second is Wireguard.
 
 type features struct {
 	secureCore bool
@@ -16,36 +16,50 @@ type features struct {
 	stream     bool
 }
 
-func (its ipToServer) add(country, region, city, name, hostname string,
+func (its ipToServers) add(country, region, city, name, hostname, wgPubKey string,
 	free bool, entryIP netip.Addr, features features) {
 	key := entryIP.String()
 
-	server, ok := its[key]
+	servers, ok := its[key]
 	if ok {
 		return
 	}
 
-	server.VPN = vpn.OpenVPN
-	server.Country = country
-	server.Region = region
-	server.City = city
-	server.ServerName = name
-	server.Hostname = hostname
-	server.Free = free
-	server.SecureCore = features.secureCore
-	server.Tor = features.tor
-	server.PortForward = features.p2p
-	server.Stream = features.stream
-	server.UDP = true
-	server.TCP = true
-	server.IPs = []netip.Addr{entryIP}
-	its[key] = server
+	baseServer := models.Server{
+		Country:     country,
+		Region:      region,
+		City:        city,
+		ServerName:  name,
+		Hostname:    hostname,
+		Free:        free,
+		SecureCore:  features.secureCore,
+		Tor:         features.tor,
+		PortForward: features.p2p,
+		Stream:      features.stream,
+		IPs:         []netip.Addr{entryIP},
+	}
+	openvpnServer := baseServer
+	openvpnServer.VPN = vpn.OpenVPN
+	openvpnServer.UDP = true
+	openvpnServer.TCP = true
+	servers[0] = openvpnServer
+	wireguardServer := baseServer
+	wireguardServer.VPN = vpn.Wireguard
+	wireguardServer.WgPubKey = wgPubKey
+	servers[1] = wireguardServer
+	its[key] = servers
 }
 
-func (its ipToServer) toServersSlice() (servers []models.Server) {
-	servers = make([]models.Server, 0, len(its))
-	for _, server := range its {
-		servers = append(servers, server)
+func (its ipToServers) toServersSlice() (serversSlice []models.Server) {
+	const vpnProtocols = 2
+	serversSlice = make([]models.Server, 0, vpnProtocols*len(its))
+	for _, servers := range its {
+		serversSlice = append(serversSlice, servers[0], servers[1])
 	}
-	return servers
+	return serversSlice
+}
+
+func (its ipToServers) numberOfServers() int {
+	const serversPerIP = 2
+	return len(its) * serversPerIP
 }

internal/provider/protonvpn/updater/servers.go

@@ -29,7 +29,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 			common.ErrNotEnoughServers, count, minServers)
 	}
 
-	ipToServer := make(ipToServer, count)
+	ipToServer := make(ipToServers, count)
 	for _, logicalServer := range data.LogicalServers {
 		region := getStringValue(logicalServer.Region)
 		city := getStringValue(logicalServer.City)
@@ -65,6 +65,7 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 
 			hostname := physicalServer.Domain
 			entryIP := physicalServer.EntryIP
+			wgPubKey := physicalServer.X25519PublicKey
 
 			// Note: for multi-hop use the server name or hostname
 			// instead of the country
@@ -74,11 +75,11 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 				u.warner.Warn(warning)
 			}
 
-			ipToServer.add(country, region, city, name, hostname, free, entryIP, features)
+			ipToServer.add(country, region, city, name, hostname, wgPubKey, free, entryIP, features)
 		}
 	}
 
-	if len(ipToServer) < minServers {
+	if ipToServer.numberOfServers() < minServers {
 		return nil, fmt.Errorf("%w: %d and expected at least %d",
 			common.ErrNotEnoughServers, len(ipToServer), minServers)
 	}