Improved port definition (#1)

Add support setting external port and protocol per forwarded port
Supported syntax: `fwd2me <internal>:<external>:<proto>`

Author: outcatcher

README.md

@@ -1,24 +1,50 @@
-## Fwd2Me
+# Fwd2Me
 
-Fwd2Me - really simple UPnP port forwarding for Linux
+Fwd2Me - really simple UPnP port forwarding
 
-### Usage
+## Usage
 
 ```shell
 $ fwd2me --help
-Usage of fwd2me [options] [port1 port2 ...]:
+Usage of fwd2me [options] port1[:remote[:proto]] port2 ...:
   -label string
-    	Label for the forwarding (default "fwd2me")
+        Label for the forwarding (default "fwd2me")
   -proto string
-    	Forwarded port protocol (default "TCP")
+        Default forwarded port protocol (default "TCP")
 ```
 
-### Example
+## Example
+
+### Symmetrical, TCP
 
 ```shell
 $ fwd2me 80 443
 Recreating forwarding from 46.164.xxx.xx to 192.168.1.76
-Port 80 forwarded
-Port 443 forwarded
+Port forwarding created: internal (80), external (80), proto (TCP)
+Port forwarding created: internal (443), external (443), proto (TCP)
+```
+
+### Symmetrical, UDP
+
+```shell
+$ fwd2me -proto UDP 62332
+Recreating forwarding from 46.164.xxx.xx to 192.168.1.76
+Port forwarding created: internal (62332), external (62332), proto (UDP)
+```
+
+### Assymetrical, TCP
+
+```shell
+$ fwd2me 16080:80
+Recreating forwarding from 46.164.xxx.xx to 192.168.1.76
+Port forwarding created: internal (16080), external (80), proto (TCP)
 ```
 
+
+### Assymetrical, UDP
+
+```shell
+$ fwd2me 65101:51101:UDP
+Recreating forwarding from 46.164.xxx.xx to 192.168.1.76
+Port forwarding created: internal (65101), external (51101), proto (UDP)
+```

ensure.go

@@ -2,43 +2,83 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/outcatcher/fwd2me/forwarder"
 )
 
+const portSeparator = ":"
+
 var (
 	duration      = time.Hour
 	retryDuration = time.Second
+
+	errEmptyPortList = errors.New("empty port list")
 )
 
+func parsePort(portStr, defaultProto string) (*forwarder.ForwardedPort, error) {
+	parts := strings.Split(portStr, portSeparator)
+
+	result := &forwarder.ForwardedPort{
+		Protocol: defaultProto,
+	}
+
+	if len(parts) > 0 {
+		local, err := strconv.ParseUint(parts[0], 10, 16)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse port, local part %s is not uint16: %w", parts[0], err)
+		}
+
+		result.InternalPort = uint16(local)
+		result.ExternalPort = result.InternalPort
+	}
+
+	if len(parts) > 1 {
+		remote, err := strconv.ParseUint(parts[1], 10, 16)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse port, remote part %s is not uint16: %w", parts[1], err)
+		}
+
+		result.ExternalPort = uint16(remote)
+	}
+
+	if len(parts) > 2 {
+		result.Protocol = parts[2]
+	}
+
+	return result, nil
+}
+
 // keepForwarded makes sure ports are forwarded as long as possible without using a long lease.
 func keepForwarded(ctx context.Context) error {
 	portSlice := flag.Args()
 
-	if len(portSlice) == 0 {
-		return fmt.Errorf("empty port list")
-	}
-
-	ports := make([]uint16, 0, len(portSlice))
+	ports := make([]*forwarder.ForwardedPort, 0, len(portSlice))
 
 	for _, portStr := range portSlice {
-		port, err := strconv.ParseUint(portStr, 10, 16)
+		forwarded, err := parsePort(portStr, *proto)
 		if err != nil {
+			fmt.Fprintln(os.Stderr, "Failed to parse port string:", portStr)
+
 			continue
 		}
 
-		ports = append(ports, uint16(port))
+		ports = append(ports, forwarded)
+	}
+
+	if len(ports) == 0 {
+		return errEmptyPortList
 	}
 
 	opts := forwarder.ForwardOpts{
 		LeaseDuration: duration,
-		Protocol:      *proto,
-		RemoteHost:    "",
+		RemoteHost:    "", // default gateway
 		ProgramName:   *label,
 		Ports:         ports,
 	}

forwarder/forwarder.go

@@ -15,7 +15,7 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
-type RouterClient interface {
+type routerClient interface {
 	AddPortMappingCtx(
 		ctx context.Context,
 		NewRemoteHost string,
@@ -43,7 +43,7 @@ type RouterClient interface {
 	LocalAddr() net.IP
 }
 
-func pickRouterClient(ctx context.Context) (RouterClient, error) {
+func pickRouterClient(ctx context.Context) (routerClient, error) {
 	tasks, _ := errgroup.WithContext(ctx)
 	// Request each type of client in parallel, and return what is found.
 	var ip1Clients []*internetgateway2.WANIPConnection1
@@ -84,23 +84,27 @@ func pickRouterClient(ctx context.Context) (RouterClient, error) {
 	}
 }
 
+type ForwardedPort struct {
+	InternalPort uint16
+	ExternalPort uint16
+	Protocol     string
+}
+
 type ForwardOpts struct {
 	RemoteHost    string
 	ProgramName   string
-	Protocol      string
-	Ports         []uint16
+	Ports         []*ForwardedPort
 	LeaseDuration time.Duration
 }
 
 type forwardedPort struct {
-	remoteHost   string
+	remoteHost   string // ForwardOpts has no remote host
 	externalPort uint16
 	protocol     string
-	endOfLease   time.Time
 }
 
 type Forwarder struct {
-	client RouterClient
+	client routerClient
 
 	existingForwarding map[forwardedPort]struct{}
 }
@@ -129,24 +133,32 @@ func (f *Forwarder) ForwardPorts(ctx context.Context, opts ForwardOpts) error {
 
 	for _, port := range opts.Ports {
 		// Try to clean up first. That's not optimal, but simplifies workflow.
-		err := f.client.DeletePortMappingCtx(ctx, opts.RemoteHost, port, opts.Protocol)
+		err := f.client.DeletePortMappingCtx(ctx, opts.RemoteHost, port.ExternalPort, port.Protocol)
 		if err != nil {
 			_, _ = fmt.Fprintln(os.Stderr, "failed to delete before create", err.Error())
 
 			errs = errors.Join(errs, err)
 		}
 
+		storedPort := forwardedPort{
+			remoteHost:   opts.RemoteHost,
+			externalPort: port.ExternalPort,
+			protocol:     port.Protocol,
+		}
+
+		delete(f.existingForwarding, storedPort)
+
 		if err := f.client.AddPortMappingCtx(
 			ctx,
 			opts.RemoteHost,
 			// External port number to expose to Internet:
-			port,
+			port.ExternalPort,
 			// Forward TCP (this could be "UDP" if we wanted that instead).
-			opts.Protocol,
+			port.Protocol,
 			// Internal port number on the LAN to forward to.
 			// Some routers might not support this being different to the external
 			// port number.
-			port, // symmetrical
+			port.InternalPort,
 			// Internal address on the LAN we want to forward to.
 			f.client.LocalAddr().String(),
 			// Enabled:
@@ -158,21 +170,17 @@ func (f *Forwarder) ForwardPorts(ctx context.Context, opts ForwardOpts) error {
 			// resets, you might want to periodically request before this elapses.
 			uint32(opts.LeaseDuration.Seconds()),
 		); err != nil {
-			extErr := fmt.Errorf("error forwarding port %d: %w", port, err)
+			extErr := fmt.Errorf("error forwarding port %+v: %w", port, err)
 
 			_, _ = fmt.Fprintln(os.Stderr, extErr.Error())
 
 			errs = errors.Join(errs, extErr)
 		}
 
-		f.existingForwarding[forwardedPort{
-			remoteHost:   opts.RemoteHost,
-			externalPort: port,
-			protocol:     opts.Protocol,
-			endOfLease:   time.Now().UTC().Add(opts.LeaseDuration),
-		}] = struct{}{}
+		f.existingForwarding[storedPort] = struct{}{}
 
-		fmt.Printf("Port %d forwarded\n", port)
+		fmt.Printf("Port forwarding created: internal (%d), external (%d), proto (%s)\n",
+			port.InternalPort, port.ExternalPort, port.Protocol)
 	}
 
 	if errs != nil {
@@ -200,7 +208,7 @@ func (f *Forwarder) StopAllForwarding(ctx context.Context) error {
 
 		deleted = append(deleted, fwd)
 
-		fmt.Printf("Port forwarding for port %d stopped\n", fwd.externalPort)
+		fmt.Printf("Port forwarding for external port %d stopped\n", fwd.externalPort)
 	}
 
 	for _, deletedPort := range deleted {

main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -11,12 +12,16 @@ import (
 
 var (
 	proto = flag.String("proto", "TCP", "Forwarded port protocol")
-	label = flag.String("label", "fwd2me", "Label for the forwarding")
+	label = flag.String("label", "fwd2me", "Label for the forwarding shown in router menu")
 )
 
 func main() {
 	flag.Usage = func() {
-		fmt.Fprintf(flag.CommandLine.Output(), "Usage of %s [options] [port1 port2 ...]:\n", os.Args[0])
+		fmt.Fprintf(
+			flag.CommandLine.Output(),
+			"Usage of %s [options] port1[:external[:proto]] port2 ...:\n",
+			os.Args[0],
+		)
 		flag.PrintDefaults()
 	}
 
@@ -33,7 +38,7 @@ func main() {
 		cancel()
 	}()
 
-	if err := keepForwarded(ctx); err != nil {
+	if err := keepForwarded(ctx); err != nil && !errors.Is(err, errEmptyPortList) {
 		_, _ = fmt.Fprintln(os.Stderr, err.Error())
 
 		os.Exit(1)