hotfix(portforwarding): allow setting ports when no custom code is running

internal/portforward/loop.go

@@ -99,7 +99,6 @@ func (l *Loop) run(runCtx context.Context, runDone chan<- struct{},
 		case partialUpdate := <-updateTrigger:
 			updatedSettings, err := l.settings.updateWith(partialUpdate, *l.settings.VPNIsUp)
 			if err != nil {
-				l.logger.Debug(fmt.Sprintf("port forward loop: run: updateWith error %v", err))
 				updateResult <- err
 				continue
 			}
@@ -137,7 +136,6 @@ func (l *Loop) run(runCtx context.Context, runDone chan<- struct{},
 			if err != nil {
 				err = fmt.Errorf("starting port forwarding service: %w", err)
 			}
-			l.logger.Debug(fmt.Sprintf("port forward loop: Start: error is %v", err))
 			updateResult <- err
 		} else if err != nil {
 			// Log the error and schedule a retry
@@ -152,7 +150,6 @@ func (l *Loop) UpdateWith(partialUpdate Settings) (err error) {
 	case l.updateTrigger <- partialUpdate:
 		select {
 		case err = <-l.updatedResult:
-			l.logger.Debug(fmt.Sprintf("port forward loop: UpdateWith: received error %v", err))
 			return err
 		case <-l.runCtx.Done():
 			return l.runCtx.Err()

internal/portforward/service/service.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"slices"
+	"strings"
 	"sync"
 )
 
@@ -60,7 +61,8 @@ func (s *Service) SetPortsForwarded(ctx context.Context, ports []uint16) (err er
 	s.portMutex.Lock()
 	defer s.portMutex.Unlock()
 
-	if s.settings.PortForwarder != nil {
+	hasPortForwardingCodeRunning := !strings.HasSuffix(s.settings.PortForwarder.Name(), "[not supported]")
+	if hasPortForwardingCodeRunning {
 		return errors.New("setting port forwarded at runtime is not supported with internally running port forwarding code")
 	}
 

internal/portforward/service/start.go

@@ -123,9 +123,7 @@ func (s *Service) onNewPorts(ctx context.Context, internalToExternalPorts map[ui
 		}
 	}
 
-	s.logger.Debug(fmt.Sprintf("writePortForwardedFile with externalPorts: %v", externalPorts))
 	err = s.writePortForwardedFile(externalPorts)
-	s.logger.Debug(fmt.Sprintf("writing port file: error is %v", err))
 	if err != nil {
 		_ = s.cleanup()
 		return fmt.Errorf("writing port file: %w", err)

internal/portforward/service/stop.go

@@ -58,7 +58,6 @@ func (s *Service) cleanup() (err error) {
 
 	s.ports = nil
 
-	s.logger.Debug("writePortForwardedFile in cleanup")
 	err = s.writePortForwardedFile(nil)
 	if err != nil {
 		return fmt.Errorf("clearing port file: %w", err)

internal/provider/protonvpn/portforward.go

@@ -133,20 +133,6 @@ func (p *Provider) KeepPortForward(ctx context.Context,
 		case <-timer.C:
 		}
 
-		_, externalIPv4Address, err := client.ExternalAddress(ctx, objects.Gateway)
-		if err != nil {
-			switch {
-			case strings.HasSuffix(err.Error(), "connection refused"):
-				err = fmt.Errorf("%w - make sure you have +pmp at the end of your OpenVPN username "+
-					"or that your Wireguard key is set to work with PMP", err)
-			case strings.Contains(err.Error(), "i/o timeout"):
-				err = fmt.Errorf("%w - make sure FIREWALL_OUTBOUND_SUBNETS does not conflict with "+
-					"the VPN gateway ip address %s", err, objects.Gateway)
-			}
-			logger.Error(fmt.Sprintf("getting external IPv4 address: %v", err))
-		}
-		logger.Debug("gateway external IPv4 address is " + externalIPv4Address.String())
-
 		objects.Logger.Debug("refreshing forwarded ports since 45 seconds have elapsed")
 		const lifetime = 60 * time.Second
 		for internalPort, externalPort := range p.internalToExternalPorts {

internal/vpn/portforward.go

@@ -34,9 +34,7 @@ func (l *Loop) startPortForwarding(data tunnelUpData) (err error) {
 			Password:       data.password,
 		},
 	}
-	err = l.portForward.UpdateWith(partialUpdate)
+	return l.portForward.UpdateWith(partialUpdate)
-	l.logger.Debug(fmt.Sprintf("vpn loop: start port forwarding: error is %v", err))
-	return err
 }
 
 func (l *Loop) stopPortForwarding() (err error) {
@@ -57,7 +55,7 @@ func newNoPortForwarder(providerName string) *noPortForwarder {
 }
 
 func (n *noPortForwarder) Name() string {
-	return n.providerName
+	return n.providerName + " [not supported]"
 }
 
 func (n *noPortForwarder) PortForward(context.Context, pfutils.PortForwardObjects) (