chore(provider): use type assertion for port forwarders

internal/vpn/interfaces.go

@@ -9,6 +9,7 @@ import (
 	"github.com/qdm12/gluetun/internal/netlink"
 	portforward "github.com/qdm12/gluetun/internal/portforward/service"
 	"github.com/qdm12/gluetun/internal/provider"
+	"github.com/qdm12/gluetun/internal/provider/utils"
 )
 
 type Firewall interface {
@@ -35,6 +36,21 @@ type Providers interface {
 	Get(providerName string) provider.Provider
 }
 
+type Provider interface {
+	GetConnection(selection settings.ServerSelection, ipv6Supported bool) (connection models.Connection, err error)
+	OpenVPNConfig(connection models.Connection, settings settings.OpenVPN, ipv6Supported bool) (lines []string)
+	Name() string
+	FetchServers(ctx context.Context, minServers int) (
+		servers []models.Server, err error)
+}
+
+type PortForwarder interface {
+	Name() string
+	PortForward(ctx context.Context, objects utils.PortForwardObjects) (
+		port uint16, err error)
+	KeepPortForward(ctx context.Context, objects utils.PortForwardObjects) (err error)
+}
+
 type Storage interface {
 	FilterServers(provider string, selection settings.ServerSelection) (servers []models.Server, err error)
 	GetServerByName(provider, name string) (server models.Server, ok bool)

internal/vpn/portforward.go

@@ -1,10 +1,27 @@
 package vpn
 
 import (
+	"context"
+	"errors"
+	"fmt"
+
 	"github.com/qdm12/gluetun/internal/configuration/settings"
 	"github.com/qdm12/gluetun/internal/portforward/service"
+	pfutils "github.com/qdm12/gluetun/internal/provider/utils"
 )
 
+func getPortForwarder(provider Provider, providers Providers, //nolint:ireturn
+	customPortForwarderName string) (portForwarder PortForwarder) {
+	if customPortForwarderName != "" {
+		provider = providers.Get(customPortForwarderName)
+	}
+	portForwarder, ok := provider.(PortForwarder)
+	if ok {
+		return portForwarder
+	}
+	return newNoPortForwarder(provider.Name())
+}
+
 func (l *Loop) startPortForwarding(data tunnelUpData) (err error) {
 	partialUpdate := service.Settings{
 		PortForwarder: data.portForwarder,
@@ -24,3 +41,28 @@ func (l *Loop) stopPortForwarding(vpnProvider string) (err error) {
 	}
 	return l.portForward.UpdateWith(partialUpdate)
 }
+
+type noPortForwarder struct {
+	providerName string
+}
+
+func newNoPortForwarder(providerName string) *noPortForwarder {
+	return &noPortForwarder{
+		providerName: providerName,
+	}
+}
+
+var ErrPortForwardingNotSupported = errors.New("custom port forwarding obtention is not supported")
+
+func (n *noPortForwarder) Name() string {
+	return n.providerName
+}
+
+func (n *noPortForwarder) PortForward(context.Context, pfutils.PortForwardObjects) (
+	port uint16, err error) {
+	return 0, fmt.Errorf("%w: for %s", ErrPortForwardingNotSupported, n.providerName)
+}
+
+func (n *noPortForwarder) KeepPortForward(context.Context, pfutils.PortForwardObjects) (err error) {
+	return fmt.Errorf("%w: for %s", ErrPortForwardingNotSupported, n.providerName)
+}

internal/vpn/run.go

@@ -22,11 +22,8 @@ func (l *Loop) Run(ctx context.Context, done chan<- struct{}) {
 
 		providerConf := l.providers.Get(*settings.Provider.Name)
 
-		customPortForwardingProvider := *settings.Provider.PortForwarding.Provider
-		portForwarder := providerConf
-		if customPortForwardingProvider != "" {
-			portForwarder = l.providers.Get(customPortForwardingProvider)
-		}
+		portForwarder := getPortForwarder(providerConf, l.providers,
+			*settings.Provider.PortForwarding.Provider)
 
 		var vpnRunner interface {
 			Run(ctx context.Context, waitError chan<- error, tunnelReady chan<- struct{})

internal/vpn/tunnelup.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/qdm12/gluetun/internal/constants"
-	"github.com/qdm12/gluetun/internal/provider"
 	"github.com/qdm12/gluetun/internal/version"
 )
 
@@ -12,7 +11,7 @@ type tunnelUpData struct {
 	// Port forwarding
 	vpnIntf       string
 	serverName    string
-	portForwarder provider.PortForwarder
+	portForwarder PortForwarder
 }
 
 func (l *Loop) onTunnelUp(ctx context.Context, data tunnelUpData) {