mirror of
https://github.com/lightningnetwork/lnd.git
synced 2024-11-19 18:10:34 +01:00
377e770db4
In this commit, we introduce a new package `nat`. This package is responsible for handling the different techniques for NAT traversals. Specifically, we have implemented UPnP and NAT-PMP support. This will allow users to easily advertise their nodes to the network as long as their devices are behind a single NAT. Devices behind multiple NATs are not supported.
113 lines
2.4 KiB
Go
113 lines
2.4 KiB
Go
package nat
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"sync"
|
|
|
|
upnp "github.com/NebulousLabs/go-upnp"
|
|
)
|
|
|
|
// Compile-time check to ensure UPnP implements the Traversal interface.
|
|
var _ Traversal = (*UPnP)(nil)
|
|
|
|
// UPnP is a concrete implementation of the Traversal interface that uses the
|
|
// UPnP technique.
|
|
type UPnP struct {
|
|
device *upnp.IGD
|
|
|
|
forwardedPortsMtx sync.Mutex
|
|
forwardedPorts map[uint16]struct{}
|
|
}
|
|
|
|
// DiscoverUPnP scans the local network for a UPnP enabled device.
|
|
func DiscoverUPnP(ctx context.Context) (*UPnP, error) {
|
|
// Scan the local network for a UPnP-enabled device.
|
|
device, err := upnp.DiscoverCtx(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
u := &UPnP{
|
|
device: device,
|
|
forwardedPorts: make(map[uint16]struct{}),
|
|
}
|
|
|
|
// We'll then attempt to retrieve the external IP address of this
|
|
// device to ensure it is not behind multiple NATs.
|
|
if _, err := u.ExternalIP(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return u, nil
|
|
}
|
|
|
|
// ExternalIP returns the external IP address of the UPnP enabled device.
|
|
func (u *UPnP) ExternalIP() (net.IP, error) {
|
|
ip, err := u.device.ExternalIP()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if isPrivateIP(net.ParseIP(ip)) {
|
|
return nil, ErrMultipleNAT
|
|
}
|
|
|
|
return net.ParseIP(ip), nil
|
|
}
|
|
|
|
// AddPortMapping enables port forwarding for the given port.
|
|
func (u *UPnP) AddPortMapping(port uint16) error {
|
|
u.forwardedPortsMtx.Lock()
|
|
defer u.forwardedPortsMtx.Unlock()
|
|
|
|
if _, exists := u.forwardedPorts[port]; exists {
|
|
return nil
|
|
}
|
|
|
|
if err := u.device.Forward(port, ""); err != nil {
|
|
return err
|
|
}
|
|
|
|
u.forwardedPorts[port] = struct{}{}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeletePortMapping disables port forwarding for the given port.
|
|
func (u *UPnP) DeletePortMapping(port uint16) error {
|
|
u.forwardedPortsMtx.Lock()
|
|
defer u.forwardedPortsMtx.Unlock()
|
|
|
|
if _, exists := u.forwardedPorts[port]; !exists {
|
|
return fmt.Errorf("port %d is not being forwarded", port)
|
|
}
|
|
|
|
if err := u.device.Clear(port); err != nil {
|
|
return err
|
|
}
|
|
|
|
delete(u.forwardedPorts, port)
|
|
|
|
return nil
|
|
}
|
|
|
|
// ForwardedPorts returns a list of ports currently being forwarded.
|
|
func (u *UPnP) ForwardedPorts() []uint16 {
|
|
u.forwardedPortsMtx.Lock()
|
|
defer u.forwardedPortsMtx.Unlock()
|
|
|
|
ports := make([]uint16, 0, len(u.forwardedPorts))
|
|
for port := range u.forwardedPorts {
|
|
ports = append(ports, port)
|
|
}
|
|
|
|
return ports
|
|
}
|
|
|
|
// Name returns the name of the specific NAT traversal technique used.
|
|
func (u *UPnP) Name() string {
|
|
return "UPnP"
|
|
}
|