feat(fastestvpn): Wireguard support (#2383)

Credits to @Zerauskire for the initial investigation and @jvanderzande for an initial implementation as well as reviewing the pull request

internal/provider/fastestvpn/connection.go

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

internal/provider/fastestvpn/updater/hosttoserver.go

@@ -7,32 +7,45 @@ import (
 	"github.com/qdm12/gluetun/internal/models"
 )
 
-type hostToServer map[string]models.Server
+type hostToServerData map[string]serverData
 
-func (hts hostToServer) add(host, country, city string, tcp, udp bool) {
-	server, ok := hts[host]
-	if !ok {
-		server.VPN = vpn.OpenVPN
-		server.Hostname = host
-		server.Country = country
-		server.City = city
+type serverData struct {
+	openvpn    bool
+	wireguard  bool
+	country    string
+	city       string
+	openvpnUDP bool
+	openvpnTCP bool
+	ips        []netip.Addr
+}
+
+func (hts hostToServerData) add(host, vpnType, country, city string, tcp, udp bool) {
+	serverData, ok := hts[host]
+	switch vpnType {
+	case vpn.OpenVPN:
+		serverData.openvpn = true
+		serverData.openvpnTCP = serverData.openvpnTCP || tcp
+		serverData.openvpnUDP = serverData.openvpnUDP || udp
+	case vpn.Wireguard:
+		serverData.wireguard = true
+	default:
+		panic("protocol not supported")
 	}
-	if city != "" {
+
+	if !ok {
+		serverData.country = country
+		serverData.city = city
+	} else if city != "" {
 		// some servers are listed without the city although
 		// they are also listed with the city described, so update
 		// the city field.
-		server.City = city
+		serverData.city = city
 	}
-	if tcp {
-		server.TCP = true
-	}
-	if udp {
-		server.UDP = true
-	}
-	hts[host] = server
+
+	hts[host] = serverData
 }
 
-func (hts hostToServer) toHostsSlice() (hosts []string) {
+func (hts hostToServerData) toHostsSlice() (hosts []string) {
 	hosts = make([]string, 0, len(hts))
 	for host := range hts {
 		hosts = append(hosts, host)
@@ -40,23 +53,41 @@ func (hts hostToServer) toHostsSlice() (hosts []string) {
 	return hosts
 }
 
-func (hts hostToServer) adaptWithIPs(hostToIPs map[string][]netip.Addr) {
-	for host, IPs := range hostToIPs {
-		server := hts[host]
-		server.IPs = IPs
-		hts[host] = server
-	}
-	for host, server := range hts {
-		if len(server.IPs) == 0 {
+func (hts hostToServerData) adaptWithIPs(hostToIPs map[string][]netip.Addr) {
+	for host, serverData := range hts {
+		ips := hostToIPs[host]
+		if len(ips) == 0 {
 			delete(hts, host)
+			continue
 		}
+		serverData.ips = ips
+		hts[host] = serverData
 	}
 }
 
-func (hts hostToServer) toServersSlice() (servers []models.Server) {
-	servers = make([]models.Server, 0, len(hts))
-	for _, server := range hts {
-		servers = append(servers, server)
+func (hts hostToServerData) toServersSlice() (servers []models.Server) {
+	servers = make([]models.Server, 0, 2*len(hts)) //nolint:gomnd
+	for hostname, serverData := range hts {
+		baseServer := models.Server{
+			Hostname: hostname,
+			Country:  serverData.country,
+			City:     serverData.city,
+			IPs:      serverData.ips,
+		}
+		if serverData.openvpn {
+			openvpnServer := baseServer
+			openvpnServer.VPN = vpn.OpenVPN
+			openvpnServer.TCP = serverData.openvpnTCP
+			openvpnServer.UDP = serverData.openvpnUDP
+			servers = append(servers, openvpnServer)
+		}
+		if serverData.wireguard {
+			wireguardServer := baseServer
+			wireguardServer.VPN = vpn.Wireguard
+			const wireguardPublicKey = "658QxufMbjOTmB61Z7f+c7Rjg7oqWLnepTalqBERjF0="
+			wireguardServer.WgPubKey = wireguardPublicKey
+			servers = append(servers, wireguardServer)
+		}
 	}
 	return servers
 }

internal/provider/fastestvpn/updater/servers.go

@@ -5,14 +5,15 @@ import (
 	"fmt"
 	"sort"
 
+	"github.com/qdm12/gluetun/internal/constants/vpn"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/provider/common"
 )
 
 func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 	servers []models.Server, err error) {
-	protocols := []string{"tcp", "udp"}
-	hts := make(hostToServer)
+	protocols := []string{"ikev2", "tcp", "udp"}
+	hts := make(hostToServerData)
 
 	for _, protocol := range protocols {
 		apiServers, err := fetchAPIServers(ctx, u.client, protocol)
@@ -20,17 +21,20 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 			return nil, fmt.Errorf("fetching %s servers from API: %w", protocol, err)
 		}
 		for _, apiServer := range apiServers {
+			// all hostnames from the protocols TCP, UDP and IKEV2 support Wireguard
+			// per https://github.com/qdm12/gluetun-wiki/issues/76#issuecomment-2125420536
+			const wgTCP, wgUDP = false, false // ignored
+			hts.add(apiServer.hostname, vpn.Wireguard, apiServer.country, apiServer.city, wgTCP, wgUDP)
+
 			tcp := protocol == "tcp"
 			udp := protocol == "udp"
-			hts.add(apiServer.hostname, apiServer.country, apiServer.city, tcp, udp)
+			if !tcp && !udp { // not an OpenVPN protocol, for example ikev2
+				continue
+			}
+			hts.add(apiServer.hostname, vpn.OpenVPN, apiServer.country, apiServer.city, tcp, udp)
 		}
 	}
 
-	if len(hts) < minServers {
-		return nil, fmt.Errorf("%w: %d and expected at least %d",
-			common.ErrNotEnoughServers, len(hts), minServers)
-	}
-
 	hosts := hts.toHostsSlice()
 	resolveSettings := parallelResolverSettings(hosts)
 	hostToIPs, warnings, err := u.parallelResolver.Resolve(ctx, resolveSettings)
@@ -41,15 +45,15 @@ func (u *Updater) FetchServers(ctx context.Context, minServers int) (
 		return nil, err
 	}
 
-	if len(hostToIPs) < minServers {
-		return nil, fmt.Errorf("%w: %d and expected at least %d",
-			common.ErrNotEnoughServers, len(servers), minServers)
-	}
-
 	hts.adaptWithIPs(hostToIPs)
 
 	servers = hts.toServersSlice()
 
+	if len(servers) < minServers {
+		return nil, fmt.Errorf("%w: %d and expected at least %d",
+			common.ErrNotEnoughServers, len(servers), minServers)
+	}
+
 	sort.Sort(models.SortableServers(servers))
 
 	return servers, nil