github.com/snowblossomcoin/go-ethereum@v1.9.25/p2p/nat/nat.go (about)

     1  // Copyright 2015 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Package nat provides access to common network port mapping protocols.
    18  package nat
    19  
    20  import (
    21  	"errors"
    22  	"fmt"
    23  	"net"
    24  	"strings"
    25  	"sync"
    26  	"time"
    27  
    28  	"github.com/ethereum/go-ethereum/log"
    29  	natpmp "github.com/jackpal/go-nat-pmp"
    30  )
    31  
    32  // An implementation of nat.Interface can map local ports to ports
    33  // accessible from the Internet.
    34  type Interface interface {
    35  	// These methods manage a mapping between a port on the local
    36  	// machine to a port that can be connected to from the internet.
    37  	//
    38  	// protocol is "UDP" or "TCP". Some implementations allow setting
    39  	// a display name for the mapping. The mapping may be removed by
    40  	// the gateway when its lifetime ends.
    41  	AddMapping(protocol string, extport, intport int, name string, lifetime time.Duration) error
    42  	DeleteMapping(protocol string, extport, intport int) error
    43  
    44  	// This method should return the external (Internet-facing)
    45  	// address of the gateway device.
    46  	ExternalIP() (net.IP, error)
    47  
    48  	// Should return name of the method. This is used for logging.
    49  	String() string
    50  }
    51  
    52  // Parse parses a NAT interface description.
    53  // The following formats are currently accepted.
    54  // Note that mechanism names are not case-sensitive.
    55  //
    56  //     "" or "none"         return nil
    57  //     "extip:77.12.33.4"   will assume the local machine is reachable on the given IP
    58  //     "any"                uses the first auto-detected mechanism
    59  //     "upnp"               uses the Universal Plug and Play protocol
    60  //     "pmp"                uses NAT-PMP with an auto-detected gateway address
    61  //     "pmp:192.168.0.1"    uses NAT-PMP with the given gateway address
    62  func Parse(spec string) (Interface, error) {
    63  	var (
    64  		parts = strings.SplitN(spec, ":", 2)
    65  		mech  = strings.ToLower(parts[0])
    66  		ip    net.IP
    67  	)
    68  	if len(parts) > 1 {
    69  		ip = net.ParseIP(parts[1])
    70  		if ip == nil {
    71  			return nil, errors.New("invalid IP address")
    72  		}
    73  	}
    74  	switch mech {
    75  	case "", "none", "off":
    76  		return nil, nil
    77  	case "any", "auto", "on":
    78  		return Any(), nil
    79  	case "extip", "ip":
    80  		if ip == nil {
    81  			return nil, errors.New("missing IP address")
    82  		}
    83  		return ExtIP(ip), nil
    84  	case "upnp":
    85  		return UPnP(), nil
    86  	case "pmp", "natpmp", "nat-pmp":
    87  		return PMP(ip), nil
    88  	default:
    89  		return nil, fmt.Errorf("unknown mechanism %q", parts[0])
    90  	}
    91  }
    92  
    93  const (
    94  	mapTimeout = 10 * time.Minute
    95  )
    96  
    97  // Map adds a port mapping on m and keeps it alive until c is closed.
    98  // This function is typically invoked in its own goroutine.
    99  func Map(m Interface, c <-chan struct{}, protocol string, extport, intport int, name string) {
   100  	log := log.New("proto", protocol, "extport", extport, "intport", intport, "interface", m)
   101  	refresh := time.NewTimer(mapTimeout)
   102  	defer func() {
   103  		refresh.Stop()
   104  		log.Debug("Deleting port mapping")
   105  		m.DeleteMapping(protocol, extport, intport)
   106  	}()
   107  	if err := m.AddMapping(protocol, extport, intport, name, mapTimeout); err != nil {
   108  		log.Debug("Couldn't add port mapping", "err", err)
   109  	} else {
   110  		log.Info("Mapped network port")
   111  	}
   112  	for {
   113  		select {
   114  		case _, ok := <-c:
   115  			if !ok {
   116  				return
   117  			}
   118  		case <-refresh.C:
   119  			log.Trace("Refreshing port mapping")
   120  			if err := m.AddMapping(protocol, extport, intport, name, mapTimeout); err != nil {
   121  				log.Debug("Couldn't add port mapping", "err", err)
   122  			}
   123  			refresh.Reset(mapTimeout)
   124  		}
   125  	}
   126  }
   127  
   128  // ExtIP assumes that the local machine is reachable on the given
   129  // external IP address, and that any required ports were mapped manually.
   130  // Mapping operations will not return an error but won't actually do anything.
   131  type ExtIP net.IP
   132  
   133  func (n ExtIP) ExternalIP() (net.IP, error) { return net.IP(n), nil }
   134  func (n ExtIP) String() string              { return fmt.Sprintf("ExtIP(%v)", net.IP(n)) }
   135  
   136  // These do nothing.
   137  
   138  func (ExtIP) AddMapping(string, int, int, string, time.Duration) error { return nil }
   139  func (ExtIP) DeleteMapping(string, int, int) error                     { return nil }
   140  
   141  // Any returns a port mapper that tries to discover any supported
   142  // mechanism on the local network.
   143  func Any() Interface {
   144  	// TODO: attempt to discover whether the local machine has an
   145  	// Internet-class address. Return ExtIP in this case.
   146  	return startautodisc("UPnP or NAT-PMP", func() Interface {
   147  		found := make(chan Interface, 2)
   148  		go func() { found <- discoverUPnP() }()
   149  		go func() { found <- discoverPMP() }()
   150  		for i := 0; i < cap(found); i++ {
   151  			if c := <-found; c != nil {
   152  				return c
   153  			}
   154  		}
   155  		return nil
   156  	})
   157  }
   158  
   159  // UPnP returns a port mapper that uses UPnP. It will attempt to
   160  // discover the address of your router using UDP broadcasts.
   161  func UPnP() Interface {
   162  	return startautodisc("UPnP", discoverUPnP)
   163  }
   164  
   165  // PMP returns a port mapper that uses NAT-PMP. The provided gateway
   166  // address should be the IP of your router. If the given gateway
   167  // address is nil, PMP will attempt to auto-discover the router.
   168  func PMP(gateway net.IP) Interface {
   169  	if gateway != nil {
   170  		return &pmp{gw: gateway, c: natpmp.NewClient(gateway)}
   171  	}
   172  	return startautodisc("NAT-PMP", discoverPMP)
   173  }
   174  
   175  // autodisc represents a port mapping mechanism that is still being
   176  // auto-discovered. Calls to the Interface methods on this type will
   177  // wait until the discovery is done and then call the method on the
   178  // discovered mechanism.
   179  //
   180  // This type is useful because discovery can take a while but we
   181  // want return an Interface value from UPnP, PMP and Auto immediately.
   182  type autodisc struct {
   183  	what string // type of interface being autodiscovered
   184  	once sync.Once
   185  	doit func() Interface
   186  
   187  	mu    sync.Mutex
   188  	found Interface
   189  }
   190  
   191  func startautodisc(what string, doit func() Interface) Interface {
   192  	// TODO: monitor network configuration and rerun doit when it changes.
   193  	return &autodisc{what: what, doit: doit}
   194  }
   195  
   196  func (n *autodisc) AddMapping(protocol string, extport, intport int, name string, lifetime time.Duration) error {
   197  	if err := n.wait(); err != nil {
   198  		return err
   199  	}
   200  	return n.found.AddMapping(protocol, extport, intport, name, lifetime)
   201  }
   202  
   203  func (n *autodisc) DeleteMapping(protocol string, extport, intport int) error {
   204  	if err := n.wait(); err != nil {
   205  		return err
   206  	}
   207  	return n.found.DeleteMapping(protocol, extport, intport)
   208  }
   209  
   210  func (n *autodisc) ExternalIP() (net.IP, error) {
   211  	if err := n.wait(); err != nil {
   212  		return nil, err
   213  	}
   214  	return n.found.ExternalIP()
   215  }
   216  
   217  func (n *autodisc) String() string {
   218  	n.mu.Lock()
   219  	defer n.mu.Unlock()
   220  	if n.found == nil {
   221  		return n.what
   222  	} else {
   223  		return n.found.String()
   224  	}
   225  }
   226  
   227  // wait blocks until auto-discovery has been performed.
   228  func (n *autodisc) wait() error {
   229  	n.once.Do(func() {
   230  		n.mu.Lock()
   231  		n.found = n.doit()
   232  		n.mu.Unlock()
   233  	})
   234  	if n.found == nil {
   235  		return fmt.Errorf("no %s router discovered", n.what)
   236  	}
   237  	return nil
   238  }