Remove PIA v3 servers support

README.md

@@ -28,7 +28,7 @@ Mullvad, Windscribe, Surfshark Cyberghost, VyprVPN, NordVPN and PureVPN VPN serv
 ## Features
 
 - Based on Alpine 3.12 for a small Docker image of 52MB
-- Supports **Private Internet Access** (new and old), **Mullvad**, **Windscribe**, **Surfshark**, **Cyberghost**, **Vyprvpn**, **NordVPN** and **PureVPN** servers
+- Supports **Private Internet Access**, **Mullvad**, **Windscribe**, **Surfshark**, **Cyberghost**, **Vyprvpn**, **NordVPN** and **PureVPN** servers
 - Supports Openvpn only for now
 - DNS over TLS baked in with service provider(s) of your choice
 - DNS fine blocking of malicious/ads/surveillance hostnames and IP addresses, with live update every 24 hours
@@ -96,7 +96,7 @@ docker run --rm --network=container:gluetun alpine:3.12 wget -qO- https://ipinfo
 
 | Variable | Default | Choices | Description |
 | --- | --- | --- | --- |
-| 🏁 `VPNSP` | `private internet access` | `private internet access`, `private internet access old`, `mullvad`, `windscribe`, `surfshark`, `vyprvpn`, `nordvpn`, `purevpn` | VPN Service Provider |
+| 🏁 `VPNSP` | `private internet access` | `private internet access`, `mullvad`, `windscribe`, `surfshark`, `vyprvpn`, `nordvpn`, `purevpn` | VPN Service Provider |
 | `IP_STATUS_FILE` | `/tmp/gluetun/ip` | Any filepath | Filepath to store the public IP address assigned |
 | `PROTOCOL` | `udp` | `udp` or `tcp` | Network protocol to use |
 | `OPENVPN_VERBOSITY` | `1` | `0` to `6` | Openvpn verbosity level |

cmd/gluetun/main.go

@@ -411,24 +411,13 @@ func routeReadyEvents(ctx context.Context, wg *sync.WaitGroup, tunnelReadyCh, dn
 				logger.Info("VPN routing IP address: %s", vpnDestination)
 			}
 			if portForwardingEnabled {
-				// TODO make instantaneous once v3 go out of service
-				const waitDuration = 5 * time.Second
-				timer := time.NewTimer(waitDuration)
-				select {
-				case <-ctx.Done():
-					if !timer.Stop() {
-						<-timer.C
-					}
-					continue
-				case <-timer.C:
-					// vpnGateway required only for PIA v4
-					vpnGateway, err := routing.VPNLocalGatewayIP()
-					if err != nil {
-						logger.Error(err)
-					}
-					logger.Info("VPN gateway IP address: %s", vpnGateway)
-					startPortForward(vpnGateway)
+				// vpnGateway required only for PIA v4
+				vpnGateway, err := routing.VPNLocalGatewayIP()
+				if err != nil {
+					logger.Error(err)
 				}
+				logger.Info("VPN gateway IP address: %s", vpnGateway)
+				startPortForward(vpnGateway)
 			}
 		case <-dnsReadyCh:
 			publicIPLooper.Restart() // TODO do not restart if disabled

internal/cli/cli.go

@@ -93,7 +93,6 @@ func Update(args []string) error {
 	flagSet.BoolVar(&options.Mullvad, "mullvad", false, "Update Mullvad servers")
 	flagSet.BoolVar(&options.Nordvpn, "nordvpn", false, "Update Nordvpn servers")
 	flagSet.BoolVar(&options.PIA, "pia", false, "Update Private Internet Access post-summer 2020 servers")
-	flagSet.BoolVar(&options.PIAold, "piaold", false, "Update Private Internet Access pre-summer 2020 servers")
 	flagSet.BoolVar(&options.Purevpn, "purevpn", false, "Update Purevpn servers")
 	flagSet.BoolVar(&options.Surfshark, "surfshark", false, "Update Surfshark servers")
 	flagSet.BoolVar(&options.Vyprvpn, "vyprvpn", false, "Update Vyprvpn servers")

internal/constants/pia.go

@@ -125,88 +125,3 @@ func PIAServers() []models.PIAServer {
 		{Region: "Vietnam", PortForward: true, OpenvpnUDP: models.PIAServerOpenvpn{CN: "vietnam401", IPs: []net.IP{{188, 214, 152, 76}}}, OpenvpnTCP: models.PIAServerOpenvpn{CN: "vietnam401", IPs: []net.IP{{188, 214, 152, 70}}}},
 	}
 }
-
-func PIAOldGeoChoices() (choices []string) {
-	servers := PIAOldServers()
-	choices = make([]string, len(servers))
-	for i := range servers {
-		choices[i] = servers[i].Region
-	}
-	return choices
-}
-
-//nolint:lll
-func PIAOldServers() []models.PIAOldServer {
-	return []models.PIAOldServer{
-		{Region: "AU Melbourne", IPs: []net.IP{{27, 50, 82, 131}, {43, 250, 204, 105}, {43, 250, 204, 107}, {43, 250, 204, 109}, {43, 250, 204, 111}, {43, 250, 204, 113}, {43, 250, 204, 115}, {43, 250, 204, 117}, {43, 250, 204, 119}, {43, 250, 204, 123}, {43, 250, 204, 125}}},
-		{Region: "AU Perth", IPs: []net.IP{{43, 250, 205, 59}, {43, 250, 205, 91}, {43, 250, 205, 93}, {43, 250, 205, 95}}},
-		{Region: "AU Sydney", IPs: []net.IP{{27, 50, 68, 23}, {27, 50, 70, 87}, {27, 50, 77, 251}, {27, 50, 81, 117}, {103, 13, 102, 123}, {103, 13, 102, 127}, {118, 127, 60, 51}, {221, 121, 145, 135}, {221, 121, 145, 137}, {221, 121, 145, 145}, {221, 121, 145, 147}, {221, 121, 145, 159}, {221, 121, 146, 203}, {221, 121, 148, 221}, {221, 121, 152, 215}}},
-		{Region: "Albania", IPs: []net.IP{{31, 171, 154, 114}}},
-		{Region: "Argentina", IPs: []net.IP{{190, 106, 134, 100}}},
-		{Region: "Austria", IPs: []net.IP{{89, 187, 168, 6}, {156, 146, 60, 129}}},
-		{Region: "Belgium", IPs: []net.IP{{77, 243, 191, 18}, {77, 243, 191, 19}, {77, 243, 191, 20}, {185, 232, 21, 26}}},
-		{Region: "Bosnia and Herzegovina", IPs: []net.IP{{185, 164, 35, 54}}},
-		{Region: "Bulgaria", IPs: []net.IP{{217, 138, 221, 66}}},
-		{Region: "CA Montreal", IPs: []net.IP{{172, 98, 71, 194}, {199, 36, 223, 130}, {199, 36, 223, 194}}},
-		{Region: "CA Ontario", IPs: []net.IP{{162, 219, 176, 26}, {162, 219, 176, 42}, {184, 75, 208, 2}, {184, 75, 208, 90}, {184, 75, 208, 114}, {184, 75, 208, 122}, {184, 75, 208, 130}, {184, 75, 208, 146}, {184, 75, 208, 170}, {184, 75, 208, 202}, {184, 75, 210, 18}, {184, 75, 210, 98}, {184, 75, 210, 106}, {184, 75, 213, 186}, {184, 75, 213, 218}, {184, 75, 214, 18}, {184, 75, 215, 18}, {184, 75, 215, 26}, {184, 75, 215, 66}, {184, 75, 215, 74}}},
-		{Region: "CA Toronto", IPs: []net.IP{{66, 115, 142, 130}, {66, 115, 145, 199}, {172, 98, 92, 66}, {172, 98, 92, 130}, {172, 98, 92, 194}}},
-		{Region: "CA Vancouver", IPs: []net.IP{{162, 216, 47, 66}, {162, 216, 47, 194}, {172, 98, 89, 130}, {172, 98, 89, 194}}},
-		{Region: "Czech Republic", IPs: []net.IP{{212, 102, 39, 1}}},
-		{Region: "DE Berlin", IPs: []net.IP{{185, 230, 127, 238}, {193, 176, 86, 122}, {193, 176, 86, 123}, {193, 176, 86, 134}, {193, 176, 86, 178}, {194, 36, 108, 6}}},
-		{Region: "DE Frankfurt", IPs: []net.IP{{195, 181, 170, 239}, {195, 181, 170, 240}, {195, 181, 170, 241}, {195, 181, 170, 242}, {195, 181, 170, 243}, {195, 181, 170, 244}, {212, 102, 57, 138}}},
-		{Region: "Denmark", IPs: []net.IP{{188, 126, 94, 34}}},
-		{Region: "Estonia", IPs: []net.IP{{77, 247, 111, 82}, {77, 247, 111, 98}, {77, 247, 111, 114}, {77, 247, 111, 130}}},
-		{Region: "Finland", IPs: []net.IP{{188, 126, 89, 4}, {188, 126, 89, 194}}},
-		{Region: "France", IPs: []net.IP{{156, 146, 63, 1}, {156, 146, 63, 65}}},
-		{Region: "Greece", IPs: []net.IP{{154, 57, 3, 91}, {154, 57, 3, 106}, {154, 57, 3, 145}}},
-		{Region: "Hungary", IPs: []net.IP{{185, 128, 26, 18}, {185, 128, 26, 19}, {185, 128, 26, 20}, {185, 128, 26, 21}, {185, 128, 26, 22}, {185, 128, 26, 23}, {185, 128, 26, 24}, {185, 189, 114, 98}}},
-		{Region: "Iceland", IPs: []net.IP{{45, 133, 193, 50}}},
-		{Region: "India", IPs: []net.IP{{45, 120, 139, 108}, {45, 120, 139, 109}, {150, 242, 12, 155}, {150, 242, 12, 171}, {150, 242, 12, 187}}},
-		{Region: "Ireland", IPs: []net.IP{{193, 56, 252, 210}, {193, 56, 252, 226}, {193, 56, 252, 242}, {193, 56, 252, 250}, {193, 56, 252, 251}, {193, 56, 252, 252}}},
-		{Region: "Israel", IPs: []net.IP{{31, 168, 172, 142}, {31, 168, 172, 143}, {31, 168, 172, 145}, {31, 168, 172, 146}}},
-		{Region: "Italy", IPs: []net.IP{{156, 146, 41, 129}, {156, 146, 41, 193}}},
-		{Region: "Japan", IPs: []net.IP{{156, 146, 34, 1}, {156, 146, 34, 65}}},
-		{Region: "Latvia", IPs: []net.IP{{46, 183, 217, 34}, {46, 183, 218, 130}, {46, 183, 218, 146}}},
-		{Region: "Lithuania", IPs: []net.IP{{85, 206, 165, 96}, {85, 206, 165, 112}, {85, 206, 165, 128}}},
-		{Region: "Luxembourg", IPs: []net.IP{{92, 223, 89, 133}, {92, 223, 89, 134}, {92, 223, 89, 135}, {92, 223, 89, 136}, {92, 223, 89, 137}, {92, 223, 89, 138}, {92, 223, 89, 140}, {92, 223, 89, 142}}},
-		{Region: "Moldova", IPs: []net.IP{{178, 17, 172, 242}, {178, 17, 173, 194}, {178, 175, 128, 34}}},
-		{Region: "Netherlands", IPs: []net.IP{{89, 187, 174, 198}, {212, 102, 35, 101}, {212, 102, 35, 102}, {212, 102, 35, 103}, {212, 102, 35, 104}}},
-		{Region: "New Zealand", IPs: []net.IP{{43, 250, 207, 1}, {43, 250, 207, 3}}},
-		{Region: "North Macedonia", IPs: []net.IP{{185, 225, 28, 130}}},
-		{Region: "Norway", IPs: []net.IP{{46, 246, 122, 34}, {46, 246, 122, 162}}},
-		{Region: "Poland", IPs: []net.IP{{185, 244, 214, 195}, {185, 244, 214, 196}, {185, 244, 214, 197}, {185, 244, 214, 198}, {185, 244, 214, 199}, {185, 244, 214, 200}}},
-		{Region: "Portugal", IPs: []net.IP{{89, 26, 241, 86}, {89, 26, 241, 102}, {89, 26, 241, 130}}},
-		{Region: "Romania", IPs: []net.IP{{86, 105, 25, 69}, {86, 105, 25, 70}, {86, 105, 25, 74}, {86, 105, 25, 75}, {86, 105, 25, 76}, {86, 105, 25, 77}, {86, 105, 25, 78}, {89, 33, 8, 38}, {89, 33, 8, 42}, {93, 115, 7, 70}, {94, 176, 148, 35}, {143, 244, 54, 1}, {185, 45, 12, 126}, {185, 210, 218, 98}, {185, 210, 218, 99}, {185, 210, 218, 100}, {185, 210, 218, 101}, {185, 210, 218, 102}, {185, 210, 218, 105}, {188, 240, 220, 26}}},
-		{Region: "Serbia", IPs: []net.IP{{37, 120, 193, 226}}},
-		{Region: "Singapore", IPs: []net.IP{{156, 146, 56, 193}, {156, 146, 57, 38}, {156, 146, 57, 235}, {156, 146, 57, 244}}},
-		{Region: "Slovakia", IPs: []net.IP{{37, 120, 221, 82}, {37, 120, 221, 98}}},
-		{Region: "South Africa", IPs: []net.IP{{102, 165, 20, 133}}},
-		{Region: "Spain", IPs: []net.IP{{212, 102, 49, 185}, {212, 102, 49, 251}}},
-		{Region: "Sweden", IPs: []net.IP{{46, 246, 3, 254}}},
-		{Region: "Switzerland", IPs: []net.IP{{156, 146, 62, 193}, {212, 102, 36, 1}, {212, 102, 36, 166}, {212, 102, 37, 240}, {212, 102, 37, 241}, {212, 102, 37, 242}, {212, 102, 37, 243}}},
-		{Region: "Turkey", IPs: []net.IP{{185, 195, 79, 34}, {185, 195, 79, 82}}},
-		{Region: "UAE", IPs: []net.IP{{45, 9, 250, 46}}},
-		{Region: "UK London", IPs: []net.IP{{212, 102, 52, 1}}},
-		{Region: "UK Manchester", IPs: []net.IP{{89, 238, 137, 36}, {89, 238, 137, 37}, {89, 238, 137, 38}, {89, 238, 137, 39}, {89, 238, 139, 52}, {89, 238, 139, 53}, {89, 238, 139, 54}, {89, 238, 139, 55}, {89, 238, 139, 56}, {89, 238, 139, 57}, {89, 238, 139, 58}, {89, 249, 67, 220}}},
-		{Region: "UK Southampton", IPs: []net.IP{{143, 244, 36, 58}, {143, 244, 37, 1}, {143, 244, 38, 1}, {143, 244, 38, 60}, {143, 244, 38, 119}}},
-		{Region: "US Atlanta", IPs: []net.IP{{156, 146, 46, 1}, {156, 146, 46, 134}, {156, 146, 46, 198}, {156, 146, 47, 11}}},
-		{Region: "US California", IPs: []net.IP{{37, 235, 108, 208}, {89, 187, 187, 129}, {89, 187, 187, 162}, {91, 207, 175, 194}, {91, 207, 175, 195}, {91, 207, 175, 197}, {91, 207, 175, 198}, {91, 207, 175, 199}, {91, 207, 175, 200}, {91, 207, 175, 205}, {91, 207, 175, 206}, {91, 207, 175, 207}, {91, 207, 175, 209}, {91, 207, 175, 210}, {91, 207, 175, 212}}},
-		{Region: "US Chicago", IPs: []net.IP{{156, 146, 50, 1}, {156, 146, 50, 65}, {156, 146, 50, 134}, {156, 146, 50, 198}, {156, 146, 51, 11}, {212, 102, 58, 113}, {212, 102, 59, 54}, {212, 102, 59, 129}}},
-		{Region: "US Dallas", IPs: []net.IP{{156, 146, 38, 65}, {156, 146, 38, 161}, {156, 146, 39, 1}, {156, 146, 39, 6}, {156, 146, 52, 6}, {156, 146, 52, 70}, {156, 146, 52, 139}, {156, 146, 52, 203}}},
-		{Region: "US Denver", IPs: []net.IP{{70, 39, 77, 130}, {70, 39, 92, 2}, {70, 39, 113, 194}, {174, 128, 225, 2}, {174, 128, 226, 10}, {174, 128, 226, 18}, {174, 128, 227, 2}, {174, 128, 227, 226}, {174, 128, 236, 98}, {174, 128, 242, 234}, {174, 128, 242, 250}, {174, 128, 243, 98}, {174, 128, 244, 74}, {174, 128, 245, 122}, {174, 128, 246, 10}, {199, 115, 98, 146}, {199, 115, 98, 234}, {199, 115, 101, 178}, {199, 115, 101, 186}, {199, 115, 102, 146}}},
-		{Region: "US East", IPs: []net.IP{{156, 146, 58, 202}, {156, 146, 58, 203}, {156, 146, 58, 204}, {156, 146, 58, 205}, {156, 146, 58, 207}, {156, 146, 58, 208}, {156, 146, 58, 209}, {193, 37, 253, 115}, {193, 37, 253, 134}, {194, 59, 251, 8}, {194, 59, 251, 11}, {194, 59, 251, 22}, {194, 59, 251, 28}, {194, 59, 251, 56}, {194, 59, 251, 62}, {194, 59, 251, 69}, {194, 59, 251, 82}, {194, 59, 251, 84}, {194, 59, 251, 91}, {194, 59, 251, 112}}},
-		{Region: "US Florida", IPs: []net.IP{{193, 37, 252, 6}, {193, 37, 252, 7}, {193, 37, 252, 8}, {193, 37, 252, 9}, {193, 37, 252, 10}, {193, 37, 252, 11}, {193, 37, 252, 12}, {193, 37, 252, 14}, {193, 37, 252, 15}, {193, 37, 252, 16}, {193, 37, 252, 17}, {193, 37, 252, 18}, {193, 37, 252, 19}, {193, 37, 252, 20}, {193, 37, 252, 21}, {193, 37, 252, 23}, {193, 37, 252, 24}, {193, 37, 252, 25}, {193, 37, 252, 26}, {193, 37, 252, 27}}},
-		{Region: "US Houston", IPs: []net.IP{{74, 81, 88, 26}, {74, 81, 88, 42}, {74, 81, 88, 66}, {74, 81, 88, 74}, {205, 251, 148, 66}, {205, 251, 148, 90}, {205, 251, 148, 98}, {205, 251, 148, 122}, {205, 251, 148, 130}, {205, 251, 148, 138}, {205, 251, 148, 186}, {205, 251, 150, 146}, {205, 251, 150, 170}}},
-		{Region: "US Las Vegas", IPs: []net.IP{{79, 110, 53, 50}, {79, 110, 53, 66}, {79, 110, 53, 98}, {79, 110, 53, 114}, {79, 110, 53, 130}, {79, 110, 53, 146}, {79, 110, 53, 162}, {79, 110, 53, 178}, {79, 110, 53, 194}, {79, 110, 53, 210}, {162, 251, 236, 7}, {199, 127, 56, 83}, {199, 127, 56, 84}, {199, 127, 56, 87}, {199, 127, 56, 89}, {199, 127, 56, 90}}},
-		{Region: "US New York City", IPs: []net.IP{{156, 146, 36, 225}, {156, 146, 37, 129}, {156, 146, 58, 1}, {156, 146, 58, 134}}},
-		{Region: "US Seattle", IPs: []net.IP{{156, 146, 48, 65}, {156, 146, 48, 135}, {156, 146, 48, 200}, {156, 146, 49, 13}, {212, 102, 46, 129}, {212, 102, 46, 193}, {212, 102, 47, 134}}},
-		{Region: "US Silicon Valley", IPs: []net.IP{{199, 116, 118, 130}, {199, 116, 118, 132}, {199, 116, 118, 134}, {199, 116, 118, 136}, {199, 116, 118, 145}, {199, 116, 118, 148}, {199, 116, 118, 149}, {199, 116, 118, 157}, {199, 116, 118, 166}, {199, 116, 118, 169}, {199, 116, 118, 172}}},
-		{Region: "US Washington DC", IPs: []net.IP{{70, 32, 0, 46}, {70, 32, 0, 51}, {70, 32, 0, 53}, {70, 32, 0, 62}, {70, 32, 0, 64}, {70, 32, 0, 68}, {70, 32, 0, 69}, {70, 32, 0, 72}, {70, 32, 0, 76}, {70, 32, 0, 77}, {70, 32, 0, 106}, {70, 32, 0, 107}, {70, 32, 0, 114}, {70, 32, 0, 116}, {70, 32, 0, 120}, {70, 32, 0, 167}, {70, 32, 0, 168}, {70, 32, 0, 170}, {70, 32, 0, 172}, {70, 32, 0, 173}}},
-		{Region: "US West", IPs: []net.IP{{184, 170, 241, 130}, {184, 170, 241, 194}, {184, 170, 242, 135}, {184, 170, 242, 199}}},
-		{Region: "Ukraine", IPs: []net.IP{{62, 149, 20, 10}, {62, 149, 20, 40}}},
-	}
-}
-
-const (
-	PIAPortForwardURL models.URL = "http://209.222.18.222:2000"
-)

internal/constants/servers.go

@@ -26,11 +26,6 @@ func GetAllServers() (allServers models.AllServers) {
 			Timestamp: 1602531173,
 			Servers:   PIAServers(),
 		},
-		PiaOld: models.PiaOldServers{
-			Version:   1,
-			Timestamp: 1602523433,
-			Servers:   PIAOldServers(),
-		},
 		Purevpn: models.PurevpnServers{
 			Version:   1,
 			Timestamp: 1599323261,

internal/constants/servers_test.go

@@ -54,11 +54,6 @@ func Test_versions(t *testing.T) {
 			version: allServers.Pia.Version,
 			digest:  "f1e01afe",
 		},
-		"Private Internet Access Old": {
-			model:   models.PIAOldServer{},
-			version: allServers.PiaOld.Version,
-			digest:  "4e25ce4a",
-		},
 		"Purevpn": {
 			model:   models.PurevpnServer{},
 			version: allServers.Purevpn.Version,
@@ -135,11 +130,6 @@ func Test_timestamps(t *testing.T) {
 			timestamp: allServers.Pia.Timestamp,
 			digest:    "1571e777",
 		},
-		"Private Internet Access Old": {
-			servers:   allServers.PiaOld.Servers,
-			timestamp: allServers.PiaOld.Timestamp,
-			digest:    "3566a800",
-		},
 		"Purevpn": {
 			servers:   allServers.Purevpn.Servers,
 			timestamp: allServers.Purevpn.Timestamp,

internal/constants/vpn.go

@@ -7,8 +7,6 @@ import (
 const (
 	// PrivateInternetAccess is a VPN provider.
 	PrivateInternetAccess models.VPNProvider = "private internet access"
-	// PrivateInternetAccessOld is the pre summer 2020 PIA provider.
-	PrivateInternetAccessOld models.VPNProvider = "private internet access old"
 	// Mullvad is a VPN provider.
 	Mullvad models.VPNProvider = "mullvad"
 	// Windscribe is a VPN provider.

internal/models/server.go

@@ -28,15 +28,6 @@ func (p *PIAServer) String() string {
 		p.Region, p.PortForward, p.OpenvpnUDP.String(), p.OpenvpnTCP.String())
 }
 
-type PIAOldServer struct {
-	IPs    []net.IP `json:"ips"`
-	Region string   `json:"region"`
-}
-
-func (p *PIAOldServer) String() string {
-	return fmt.Sprintf("{Region: %q, IPs: %s}", p.Region, goStringifyIPs(p.IPs))
-}
-
 type MullvadServer struct {
 	IPs     []net.IP `json:"ips"`
 	IPsV6   []net.IP `json:"ipsv6"`

internal/models/server_test.go

@@ -7,31 +7,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func Test_PIAOldServer_String(t *testing.T) {
-	t.Parallel()
-	testCases := map[string]struct {
-		server PIAOldServer
-		s      string
-	}{
-		"no ips": {
-			server: PIAOldServer{Region: "a b"},
-			s:      `{Region: "a b", IPs: []net.IP{}}`,
-		},
-		"with ips": {
-			server: PIAOldServer{Region: "a b", IPs: []net.IP{{1, 1, 1, 1}, {2, 2, 2, 2}}},
-			s:      `{Region: "a b", IPs: []net.IP{{1, 1, 1, 1}, {2, 2, 2, 2}}}`,
-		},
-	}
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			s := testCase.server.String()
-			assert.Equal(t, testCase.s, s)
-		})
-	}
-}
-
 func Test_MullvadServer_String(t *testing.T) {
 	t.Parallel()
 	testCases := map[string]struct {

internal/models/servers.go

@@ -5,7 +5,6 @@ type AllServers struct {
 	Cyberghost CyberghostServers `json:"cyberghost"`
 	Mullvad    MullvadServers    `json:"mullvad"`
 	Nordvpn    NordvpnServers    `json:"nordvpn"`
-	PiaOld     PiaOldServers     `json:"piaOld"`
 	Pia        PiaServers        `json:"pia"`
 	Purevpn    PurevpnServers    `json:"purevpn"`
 	Surfshark  SurfsharkServers  `json:"surfshark"`
@@ -28,11 +27,6 @@ type NordvpnServers struct {
 	Timestamp int64           `json:"timestamp"`
 	Servers   []NordvpnServer `json:"servers"`
 }
-type PiaOldServers struct {
-	Version   uint16         `json:"version"`
-	Timestamp int64          `json:"timestamp"`
-	Servers   []PIAOldServer `json:"servers"`
-}
 type PiaServers struct {
 	Version   uint16      `json:"version"`
 	Timestamp int64       `json:"timestamp"`

internal/params/params.go

@@ -62,7 +62,6 @@ type Reader interface {
 	GetPortForwardingStatusFilepath() (filepath models.Filepath, err error)
 	GetPIAEncryptionPreset() (preset string, err error)
 	GetPIARegions() (regions []string, err error)
-	GetPIAOldRegions() (regions []string, err error)
 
 	// Mullvad getters
 	GetMullvadCountries() (countries []string, err error)

internal/params/pia.go

@@ -63,9 +63,3 @@ func (r *reader) GetPIAEncryptionPreset() (preset string, err error) {
 func (r *reader) GetPIARegions() (regions []string, err error) {
 	return r.envParams.GetCSVInPossibilities("REGION", constants.PIAGeoChoices())
 }
-
-// GetPIAOldRegions obtains the regions for the PIA servers from the
-// environment variable REGION.
-func (r *reader) GetPIAOldRegions() (regions []string, err error) {
-	return r.envParams.GetCSVInPossibilities("REGION", constants.PIAOldGeoChoices())
-}

internal/provider/piav3.go

@@ -1,156 +0,0 @@
-package provider
-
-import (
-	"context"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"net"
-	"net/http"
-
-	"github.com/qdm12/gluetun/internal/constants"
-	"github.com/qdm12/gluetun/internal/firewall"
-	"github.com/qdm12/gluetun/internal/models"
-	"github.com/qdm12/golibs/files"
-	"github.com/qdm12/golibs/logging"
-)
-
-type piaV3 struct {
-	servers    []models.PIAOldServer
-	randSource rand.Source
-}
-
-func newPrivateInternetAccessV3(servers []models.PIAOldServer, timeNow timeNowFunc) *piaV3 {
-	return &piaV3{
-		servers:    servers,
-		randSource: rand.NewSource(timeNow().UnixNano()),
-	}
-}
-
-func (p *piaV3) GetOpenVPNConnection(selection models.ServerSelection) (
-	connection models.OpenVPNConnection, err error) {
-	var port uint16
-	switch selection.Protocol {
-	case constants.TCP:
-		switch selection.EncryptionPreset {
-		case constants.PIAEncryptionPresetNormal:
-			port = 502
-		case constants.PIAEncryptionPresetStrong:
-			port = 501
-		}
-	case constants.UDP:
-		switch selection.EncryptionPreset {
-		case constants.PIAEncryptionPresetNormal:
-			port = 1198
-		case constants.PIAEncryptionPresetStrong:
-			port = 1197
-		}
-	}
-	if port == 0 {
-		return connection, fmt.Errorf(
-			"combination of protocol %q and encryption %q does not yield any port number",
-			selection.Protocol, selection.EncryptionPreset)
-	}
-
-	if selection.TargetIP != nil {
-		return models.OpenVPNConnection{IP: selection.TargetIP, Port: port, Protocol: selection.Protocol}, nil
-	}
-
-	servers := filterPIAOldServers(p.servers, selection.Regions)
-	if len(servers) == 0 {
-		return connection, fmt.Errorf("no server found for regions %s", commaJoin(selection.Regions))
-	}
-
-	var connections []models.OpenVPNConnection
-	for _, server := range servers {
-		for _, IP := range server.IPs {
-			connections = append(connections, models.OpenVPNConnection{IP: IP, Port: port, Protocol: selection.Protocol})
-		}
-	}
-
-	return pickRandomConnection(connections, p.randSource), nil
-}
-
-func (p *piaV3) BuildConf(connection models.OpenVPNConnection, verbosity, uid, gid int,
-	root bool, cipher, auth string, extras models.ExtraConfigOptions) (lines []string) {
-	return buildPIAConf(connection, verbosity, root, cipher, auth, extras)
-}
-
-func (p *piaV3) PortForward(ctx context.Context, client *http.Client,
-	fileManager files.FileManager, pfLogger logging.Logger, gateway net.IP, fw firewall.Configurator,
-	syncState func(port uint16) (pfFilepath models.Filepath)) {
-	const uuidLength = 32
-	b := make([]byte, uuidLength)
-	n, err := rand.New(p.randSource).Read(b) //nolint:gosec
-	if err != nil {
-		pfLogger.Error(err)
-		return
-	} else if n != uuidLength {
-		pfLogger.Error("only read %d bytes instead of %d", n, uuidLength)
-		return
-	}
-	clientID := hex.EncodeToString(b)
-	url := fmt.Sprintf("%s/?client_id=%s", constants.PIAPortForwardURL, clientID)
-	request, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		pfLogger.Error(err)
-		return
-	}
-	response, err := client.Do(request)
-	if err != nil {
-		pfLogger.Error(err)
-		return
-	}
-	defer response.Body.Close()
-	if response.StatusCode != http.StatusOK {
-		pfLogger.Error("%s for %s; does your PIA server support port forwarding?", response.Status, url)
-		return
-	}
-	b, err = ioutil.ReadAll(response.Body)
-	if err != nil {
-		pfLogger.Error(err)
-		return
-	} else if len(b) == 0 {
-		pfLogger.Error("port forwarding is already activated on this connection, has expired, or you are not connected to a PIA region that supports port forwarding") //nolint:lll
-		return
-	}
-	body := struct {
-		Port uint16 `json:"port"`
-	}{}
-	if err := json.Unmarshal(b, &body); err != nil {
-		pfLogger.Error("port forwarding response: %s", err)
-		return
-	}
-	port := body.Port
-
-	filepath := syncState(port)
-	pfLogger.Info("Writing port to %s", filepath)
-	if err := fileManager.WriteToFile(
-		string(filepath), []byte(fmt.Sprintf("%d", port)),
-		files.Permissions(constants.AllReadWritePermissions),
-	); err != nil {
-		pfLogger.Error(err)
-	}
-
-	if err := fw.SetAllowedPort(ctx, port, string(constants.TUN)); err != nil {
-		pfLogger.Error(err)
-	}
-
-	<-ctx.Done()
-	if err := fw.RemoveAllowedPort(ctx, port); err != nil {
-		pfLogger.Error(err)
-	}
-}
-
-func filterPIAOldServers(servers []models.PIAOldServer, regions []string) (filtered []models.PIAOldServer) {
-	for _, server := range servers {
-		switch {
-		case filterByPossibilities(server.Region, regions):
-		default:
-			filtered = append(filtered, server)
-		}
-	}
-	return filtered
-}

internal/provider/provider.go

@@ -26,8 +26,6 @@ func New(provider models.VPNProvider, allServers models.AllServers, timeNow time
 	switch provider {
 	case constants.PrivateInternetAccess:
 		return newPrivateInternetAccessV4(allServers.Pia.Servers, timeNow)
-	case constants.PrivateInternetAccessOld:
-		return newPrivateInternetAccessV3(allServers.PiaOld.Servers, timeNow)
 	case constants.Mullvad:
 		return newMullvad(allServers.Mullvad.Servers, timeNow)
 	case constants.Windscribe:

internal/settings/openvpn.go

@@ -54,8 +54,6 @@ func GetOpenVPNSettings(paramsReader params.Reader, vpnProvider models.VPNProvid
 	switch vpnProvider {
 	case constants.PrivateInternetAccess:
 		settings.Provider, err = GetPIASettings(paramsReader)
-	case constants.PrivateInternetAccessOld:
-		settings.Provider, err = GetPIAOldSettings(paramsReader)
 	case constants.Mullvad:
 		settings.Provider, err = GetMullvadSettings(paramsReader)
 	case constants.Windscribe:

internal/settings/providers.go

@@ -10,17 +10,7 @@ import (
 
 // GetPIASettings obtains PIA settings from environment variables using the params package.
 func GetPIASettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
-	return getPIASettings(paramsReader, constants.PrivateInternetAccess)
-}
-
-// GetPIAOldSettings obtains PIA settings for the older PIA servers (pre summer 2020)
-// from environment variables using the params package.
-func GetPIAOldSettings(paramsReader params.Reader) (settings models.ProviderSettings, err error) {
-	return getPIASettings(paramsReader, constants.PrivateInternetAccessOld)
-}
-
-func getPIASettings(paramsReader params.Reader, name models.VPNProvider) (settings models.ProviderSettings, err error) {
-	settings.Name = name
+	settings.Name = constants.PrivateInternetAccess
 	settings.ServerSelection.Protocol, err = paramsReader.GetNetworkProtocol()
 	if err != nil {
 		return settings, err

internal/storage/merge.go

@@ -47,12 +47,6 @@ func (s *storage) mergeServers(hardcoded, persistent models.AllServers) (merged
 			merged.Pia = persistent.Pia
 		}
 	}
-	merged.PiaOld = hardcoded.PiaOld
-	if persistent.PiaOld.Timestamp > hardcoded.PiaOld.Timestamp {
-		s.logger.Info("Using Private Internet Access older servers from file (%s more recent)",
-			getUnixTimeDifference(persistent.PiaOld.Timestamp, hardcoded.PiaOld.Timestamp))
-		merged.PiaOld = persistent.PiaOld
-	}
 	merged.Purevpn = hardcoded.Purevpn
 	if persistent.Purevpn.Timestamp > hardcoded.Purevpn.Timestamp {
 		s.logger.Info("Using Purevpn servers from file (%s more recent)",

internal/storage/sync.go

@@ -18,7 +18,6 @@ func countServers(allServers models.AllServers) int {
 		len(allServers.Mullvad.Servers) +
 		len(allServers.Nordvpn.Servers) +
 		len(allServers.Pia.Servers) +
-		len(allServers.PiaOld.Servers) +
 		len(allServers.Purevpn.Servers) +
 		len(allServers.Surfshark.Servers) +
 		len(allServers.Vyprvpn.Servers) +

internal/updater/options.go

@@ -5,7 +5,6 @@ type Options struct {
 	Mullvad    bool
 	Nordvpn    bool
 	PIA        bool
-	PIAold     bool
 	Purevpn    bool
 	Surfshark  bool
 	Vyprvpn    bool
@@ -21,7 +20,6 @@ func NewOptions(dnsAddress string) Options {
 		Mullvad:    true,
 		Nordvpn:    true,
 		PIA:        true,
-		PIAold:     true,
 		Purevpn:    true,
 		Surfshark:  true,
 		Vyprvpn:    true,

internal/updater/piav3.go

@@ -1,101 +0,0 @@
-package updater
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/qdm12/gluetun/internal/models"
-)
-
-func (u *updater) updatePIAOld(ctx context.Context) (err error) {
-	const zipURL = "https://www.privateinternetaccess.com/openvpn/openvpn.zip"
-	contents, err := fetchAndExtractFiles(ctx, u.client, zipURL)
-	if err != nil {
-		return err
-	}
-	const maxGoroutines = 10
-	guard := make(chan struct{}, maxGoroutines)
-	errors := make(chan error)
-	serversCh := make(chan models.PIAOldServer)
-	servers := make([]models.PIAOldServer, 0, len(contents))
-	ctx, cancel := context.WithCancel(ctx)
-	wg := &sync.WaitGroup{}
-	defer func() {
-		cancel()
-		wg.Wait()
-		defer close(guard)
-		defer close(errors)
-		defer close(serversCh)
-	}()
-	for fileName, content := range contents {
-		remoteLines := extractRemoteLinesFromOpenvpn(content)
-		if len(remoteLines) == 0 {
-			return fmt.Errorf("cannot find any remote lines in %s", fileName)
-		}
-		hosts := extractHostnamesFromRemoteLines(remoteLines)
-		if len(hosts) == 0 {
-			return fmt.Errorf("cannot find any hosts in %s", fileName)
-		}
-		region := strings.TrimSuffix(fileName, ".ovpn")
-		wg.Add(1)
-		go resolvePIAv3Hostname(ctx, wg, region, hosts, u.lookupIP, errors, serversCh, guard)
-	}
-	for range contents {
-		select {
-		case err := <-errors:
-			return err
-		case server := <-serversCh:
-			servers = append(servers, server)
-		}
-	}
-	sort.Slice(servers, func(i, j int) bool {
-		return servers[i].Region < servers[j].Region
-	})
-	if u.options.Stdout {
-		u.println(stringifyPIAOldServers(servers))
-	}
-	u.servers.PiaOld.Timestamp = u.timeNow().Unix()
-	u.servers.PiaOld.Servers = servers
-	return nil
-}
-
-func resolvePIAv3Hostname(ctx context.Context, wg *sync.WaitGroup,
-	region string, hosts []string, lookupIP lookupIPFunc,
-	errors chan<- error, serversCh chan<- models.PIAOldServer, guard chan struct{}) {
-	guard <- struct{}{}
-	defer func() {
-		<-guard
-		wg.Done()
-	}()
-	var IPs []net.IP //nolint:prealloc
-	// usually one single host in this case
-	// so no need to run in goroutines the for loop below
-	for _, host := range hosts {
-		const repetition = 5
-		newIPs, err := resolveRepeat(ctx, lookupIP, host, repetition)
-		if err != nil {
-			errors <- err
-			return
-		}
-		IPs = append(IPs, newIPs...)
-	}
-	serversCh <- models.PIAOldServer{
-		Region: region,
-		IPs:    uniqueSortedIPs(IPs),
-	}
-}
-
-func stringifyPIAOldServers(servers []models.PIAOldServer) (s string) {
-	s = "func PIAOldServers() []models.PIAOldServer {\n"
-	s += "	return []models.PIAOldServer{\n"
-	for _, server := range servers {
-		s += "		" + server.String() + ",\n"
-	}
-	s += "	}\n"
-	s += "}"
-	return s
-}

internal/updater/updater.go

@@ -90,16 +90,6 @@ func (u *updater) UpdateServers(ctx context.Context) (allServers models.AllServe
 		}
 	}
 
-	if u.options.PIAold {
-		u.logger.Info("updating Private Internet Access old (v3) servers...")
-		if err := u.updatePIAOld(ctx); err != nil {
-			if ctxErr := ctx.Err(); ctxErr != nil {
-				return allServers, ctxErr
-			}
-			u.logger.Error(err)
-		}
-	}
-
 	if u.options.Purevpn {
 		u.logger.Info("updating PureVPN servers...")
 		// TODO support servers offering only TCP or only UDP