admin/gluetun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Maint: common no port forwarding implementation

Browse Source
This commit is contained in:
Quentin McGaw (desktop)
2021-07-26 16:29:40 +00:00
parent d7a6caa2ac
commit 49885c63c4
33 changed files with 128 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
internal/provider/cyberghost/portforward.go
View File

@@ -1,16 +0,0 @@
package cyberghost
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (c *Cyberghost) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Cyberghost")
}

4
internal/provider/cyberghost/provider.go
View File

@@ -3,17 +3,21 @@ package cyberghost
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Cyberghost struct {
servers []models.CyberghostServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.CyberghostServer, randSource rand.Source) *Cyberghost {
return &Cyberghost{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Cyberghost),
}
}

16
internal/provider/fastestvpn/portforward.go
View File

@@ -1,16 +0,0 @@
package fastestvpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (f *Fastestvpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for FastestVPN")
}

4
internal/provider/fastestvpn/provider.go
View File

@@ -3,17 +3,21 @@ package fastestvpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Fastestvpn struct {
servers []models.FastestvpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.FastestvpnServer, randSource rand.Source) *Fastestvpn {
return &Fastestvpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Fastestvpn),
}
}

16
internal/provider/hidemyass/portforward.go
View File

@@ -1,16 +0,0 @@
package hidemyass
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (f *HideMyAss) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for HideMyAss")
}

4
internal/provider/hidemyass/provider.go
View File

@@ -3,17 +3,21 @@ package hidemyass
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type HideMyAss struct {
servers []models.HideMyAssServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.HideMyAssServer, randSource rand.Source) *HideMyAss {
return &HideMyAss{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.HideMyAss),
}
}

16
internal/provider/ipvanish/portforward.go
View File

@@ -1,16 +0,0 @@
package ipvanish
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (i *Ipvanish) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Ipvanish")
}

4
internal/provider/ipvanish/provider.go
View File

@@ -3,17 +3,21 @@ package ipvanish
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Ipvanish struct {
servers []models.IpvanishServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.IpvanishServer, randSource rand.Source) *Ipvanish {
return &Ipvanish{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Ipvanish),
}
}

16
internal/provider/ivpn/portforward.go
View File

@@ -1,16 +0,0 @@
package ivpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (i *Ivpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Ivpn")
}

4
internal/provider/ivpn/provider.go
View File

@@ -3,17 +3,21 @@ package ivpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Ivpn struct {
servers []models.IvpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.IvpnServer, randSource rand.Source) *Ivpn {
return &Ivpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Ivpn),
}
}

16
internal/provider/mullvad/portforward.go
View File

@@ -1,16 +0,0 @@
package mullvad
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (m *Mullvad) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding logic is not needed for Mullvad")
}

4
internal/provider/mullvad/provider.go
View File

@@ -3,17 +3,21 @@ package mullvad
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Mullvad struct {
servers []models.MullvadServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.MullvadServer, randSource rand.Source) *Mullvad {
return &Mullvad{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Mullvad),
}
}

16
internal/provider/nordvpn/portforward.go
View File

@@ -1,16 +0,0 @@
package nordvpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (n *Nordvpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for NordVPN")
}

4
internal/provider/nordvpn/provider.go
View File

@@ -3,17 +3,21 @@ package nordvpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Nordvpn struct {
servers []models.NordvpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.NordvpnServer, randSource rand.Source) *Nordvpn {
return &Nordvpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Nordvpn),
}
}

16
internal/provider/privado/portforward.go
View File

@@ -1,16 +0,0 @@
package privado
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (p *Privado) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Privado")
}

4
internal/provider/privado/provider.go
View File

@@ -3,17 +3,21 @@ package privado
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Privado struct {
servers []models.PrivadoServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.PrivadoServer, randSource rand.Source) *Privado {
return &Privado{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Privado),
}
}

16
internal/provider/privatevpn/portforward.go
View File

@@ -1,16 +0,0 @@
package privatevpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (p *Privatevpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for PrivateVPN")
}

4
internal/provider/privatevpn/provider.go
View File

@@ -3,17 +3,21 @@ package privatevpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Privatevpn struct {
servers []models.PrivatevpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.PrivatevpnServer, randSource rand.Source) *Privatevpn {
return &Privatevpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Privatevpn),
}
}

16
internal/provider/protonvpn/portforward.go
View File

@@ -1,16 +0,0 @@
package protonvpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (p *Protonvpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for ProtonVPN")
}

4
internal/provider/protonvpn/provider.go
View File

@@ -3,17 +3,21 @@ package protonvpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Protonvpn struct {
servers []models.ProtonvpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.ProtonvpnServer, randSource rand.Source) *Protonvpn {
return &Protonvpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Protonvpn),
}
}

16
internal/provider/purevpn/portforward.go
View File

@@ -1,16 +0,0 @@
package purevpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (p *Purevpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for PureVPN")
}

4
internal/provider/purevpn/provider.go
View File

@@ -3,17 +3,21 @@ package purevpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Purevpn struct {
servers []models.PurevpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.PurevpnServer, randSource rand.Source) *Purevpn {
return &Purevpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Purevpn),
}
}

16
internal/provider/surfshark/portforward.go
View File

@@ -1,16 +0,0 @@
package surfshark
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (s *Surfshark) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Surfshark")
}

4
internal/provider/surfshark/provider.go
View File

@@ -3,17 +3,21 @@ package surfshark
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Surfshark struct {
servers []models.SurfsharkServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.SurfsharkServer, randSource rand.Source) *Surfshark {
return &Surfshark{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Surfshark),
}
}

16
internal/provider/torguard/portforward.go
View File

@@ -1,16 +0,0 @@
package torguard
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (t *Torguard) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Torguard")
}

4
internal/provider/torguard/provider.go
View File

@@ -3,17 +3,21 @@ package torguard
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Torguard struct {
servers []models.TorguardServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.TorguardServer, randSource rand.Source) *Torguard {
return &Torguard{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Torguard),
}
}

32
internal/provider/utils/noportforward.go Normal file
View File

@@ -0,0 +1,32 @@
package utils
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
type NoPortForwarder interface {
PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string))
}
type NoPortForwarding struct {
providerName string
}
func NewNoPortForwarding(providerName string) *NoPortForwarding {
return &NoPortForwarding{
providerName: providerName,
}
}
func (n *NoPortForwarding) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("custom port forwarding obtention is not supported for " + n.providerName)
}

16
internal/provider/vpnunlimited/portforward.go
View File

@@ -1,16 +0,0 @@
package vpnunlimited
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (p *Provider) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for VPN Unlimited")
}

4
internal/provider/vpnunlimited/provider.go
View File

@@ -3,17 +3,21 @@ package vpnunlimited
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Provider struct {
servers []models.VPNUnlimitedServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.VPNUnlimitedServer, randSource rand.Source) *Provider {
return &Provider{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.VPNUnlimited),
}
}

16
internal/provider/vyprvpn/portforward.go
View File

@@ -1,16 +0,0 @@
package vyprvpn
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (v *Vyprvpn) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Vyprvpn")
}

4
internal/provider/vyprvpn/provider.go
View File

@@ -3,17 +3,21 @@ package vyprvpn
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Vyprvpn struct {
servers []models.VyprvpnServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.VyprvpnServer, randSource rand.Source) *Vyprvpn {
return &Vyprvpn{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Vyprvpn),
}
}

16
internal/provider/windscribe/portforward.go
View File

@@ -1,16 +0,0 @@
package windscribe
import (
"context"
"net"
"net/http"
"github.com/qdm12/gluetun/internal/firewall"
"github.com/qdm12/golibs/logging"
)
func (w *Windscribe) PortForward(ctx context.Context, client *http.Client,
pfLogger logging.Logger, gateway net.IP, portAllower firewall.PortAllower,
syncState func(port uint16) (pfFilepath string)) {
panic("port forwarding is not supported for Windscribe")
}

4
internal/provider/windscribe/provider.go
View File

@@ -3,17 +3,21 @@ package windscribe
import (
"math/rand"
"github.com/qdm12/gluetun/internal/constants"
"github.com/qdm12/gluetun/internal/models"
"github.com/qdm12/gluetun/internal/provider/utils"
)
type Windscribe struct {
servers []models.WindscribeServer
randSource rand.Source
utils.NoPortForwarder
}
func New(servers []models.WindscribeServer, randSource rand.Source) *Windscribe {
return &Windscribe{
servers: servers,
randSource: randSource,
NoPortForwarder: utils.NewNoPortForwarding(constants.Windscribe),
}
}