"fmt"
"net"
"strconv"
+ "strings"
"time"
log "github.com/sirupsen/logrus"
cmn "github.com/tendermint/tmlibs/common"
- "github.com/vapor/errors"
- "github.com/vapor/p2p/upnp"
+ cfg "github.com/bytom/vapor/config"
+ "github.com/bytom/vapor/errors"
+ "github.com/bytom/vapor/p2p/upnp"
)
const (
Stop() bool
}
+// Defaults to tcp
+func protocolAndAddress(listenAddr string) (string, string) {
+ p, address := "tcp", listenAddr
+ parts := strings.SplitN(address, "://", 2)
+ if len(parts) == 2 {
+ p, address = parts[0], parts[1]
+ }
+ return p, address
+}
+
+// GetListener get listener and listen address.
+func GetListener(config *cfg.P2PConfig) (Listener, string) {
+ p, address := protocolAndAddress(config.ListenAddress)
+ l, listenerStatus := NewDefaultListener(p, address, config.SkipUPNP)
+
+ // We assume that the rpcListener has the same ExternalAddress.
+ // This is probably true because both P2P and RPC listeners use UPnP,
+ // except of course if the rpc is only bound to localhost
+ if listenerStatus {
+ return l, cmn.Fmt("%v:%v", l.ExternalAddress().IP.String(), l.ExternalAddress().Port)
+ }
+
+ return l, cmn.Fmt("%v:%v", l.InternalAddress().IP.String(), l.InternalAddress().Port)
+}
+
//getUPNPExternalAddress UPNP external address discovery & port mapping
func getUPNPExternalAddress(externalPort, internalPort int) (*NetAddress, error) {
nat, err := upnp.Discover()
if externalPort == 0 {
externalPort = defaultExternalPort
}
- externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "bytomd tcp", 0)
+ externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "vapord tcp", 0)
if err != nil {
return nil, errors.Wrap(err, "could not add tcp UPNP port mapping")
}
- externalPort, err = nat.AddPortMapping("udp", externalPort, internalPort, "bytomd udp", 0)
+ externalPort, err = nat.AddPortMapping("udp", externalPort, internalPort, "vapord udp", 0)
if err != nil {
return nil, errors.Wrap(err, "could not add udp UPNP port mapping")
}
return NewNetAddressIPPort(ext, uint16(externalPort)), nil
}
-func getNaiveExternalAddress(port int, settleForLocal bool) *NetAddress {
- addrs, err := net.InterfaceAddrs()
- if err != nil {
- cmn.PanicCrisis(cmn.Fmt("Could not fetch interface addresses: %v", err))
- }
-
- for _, a := range addrs {
- ipnet, ok := a.(*net.IPNet)
- if !ok {
- continue
- }
- if v4 := ipnet.IP.To4(); v4 == nil || (!settleForLocal && v4[0] == 127) {
- continue
- }
- return NewNetAddressIPPort(ipnet.IP, uint16(port))
- }
-
- log.Info("Node may not be connected to internet. Settling for local address")
- return getNaiveExternalAddress(port, true)
-}
-
func splitHostPort(addr string) (host string, port int) {
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
return host, port
}
-//DefaultListener Implements bytomd server Listener
+//DefaultListener Implements vapord server Listener
type DefaultListener struct {
cmn.BaseService
listener, err = net.Listen(protocol, lAddr)
}
if err != nil {
- cmn.PanicCrisis(err)
+ log.Panic(err)
}
intAddr, err := NewNetAddressString(lAddr)
if err != nil {
- cmn.PanicCrisis(err)
+ log.Panic(err)
}
// Actual listener local IP & port
if !skipUPNP && (lAddrIP == "" || lAddrIP == "0.0.0.0") {
extAddr, err = getUPNPExternalAddress(lAddrPort, listenerPort)
upnpMap = err == nil
- log.WithField("err", err).Info("get UPNP external address")
+ log.WithFields(log.Fields{"module": logModule, "err": err}).Info("get UPNP external address")
}
+ // Get the IPv4 available
if extAddr == nil {
- if address := GetIP(); address.Success == true {
- extAddr = NewNetAddressIPPort(net.ParseIP(address.IP), uint16(lAddrPort))
+ if ip, err := ExternalIPv4(); err != nil {
+ log.WithFields(log.Fields{"module": logModule, "err": err}).Warning("get ipv4 external address")
+ log.Panic("get ipv4 external address fail!")
+ } else {
+ extAddr = NewNetAddressIPPort(net.ParseIP(ip), uint16(lAddrPort))
+ log.WithFields(log.Fields{"module": logModule, "addr": extAddr}).Info("get ipv4 external address success")
}
}
- if extAddr == nil {
- extAddr = getNaiveExternalAddress(listenerPort, false)
- }
- if extAddr == nil {
- cmn.PanicCrisis("could not determine external address!")
- }
dl := &DefaultListener{
listener: listener,
// listener wasn't stopped,
// yet we encountered an error.
if err != nil {
- cmn.PanicCrisis(err)
+ log.Panic(err)
}
l.connections <- conn
}