p2p/listener.go

   1 package p2p
   2
   3 import (
   4         "fmt"
   5         "net"
   6         "strconv"
   7         "time"
   8
   9         "github.com/bytom/p2p/upnp"
  10         log "github.com/sirupsen/logrus"
  11         cmn "github.com/tendermint/tmlibs/common"
  12 )
  13
  14 //Listener subset of the methods of DefaultListener
  15 type Listener interface {
  16         Connections() <-chan net.Conn
  17         InternalAddress() *NetAddress
  18         ExternalAddress() *NetAddress
  19         String() string
  20         Stop() bool
  21 }
  22
  23 //DefaultListener Implements bytomd server Listener
  24 type DefaultListener struct {
  25         cmn.BaseService
  26
  27         listener    net.Listener
  28         intAddr     *NetAddress
  29         extAddr     *NetAddress
  30         connections chan net.Conn
  31 }
  32
  33 const (
  34         numBufferedConnections = 10
  35         defaultExternalPort    = 8770
  36         tryListenSeconds       = 5
  37 )
  38
  39 func splitHostPort(addr string) (host string, port int) {
  40         host, portStr, err := net.SplitHostPort(addr)
  41         if err != nil {
  42                 cmn.PanicSanity(err)
  43         }
  44         port, err = strconv.Atoi(portStr)
  45         if err != nil {
  46                 cmn.PanicSanity(err)
  47         }
  48         return host, port
  49 }
  50
  51 //NewDefaultListener create a default listener
  52 func NewDefaultListener(protocol string, lAddr string, skipUPNP bool) (Listener, bool) {
  53         // Local listen IP & port
  54         lAddrIP, lAddrPort := splitHostPort(lAddr)
  55
  56         // Create listener
  57         var listener net.Listener
  58         var err error
  59         var getExtIP = false
  60         var listenerStatus = false
  61
  62         for i := 0; i < tryListenSeconds; i++ {
  63                 listener, err = net.Listen(protocol, lAddr)
  64                 if err == nil {
  65                         break
  66                 } else if i < tryListenSeconds-1 {
  67                         time.Sleep(time.Second * 1)
  68                 }
  69         }
  70         if err != nil {
  71                 cmn.PanicCrisis(err)
  72         }
  73         // Actual listener local IP & port
  74         listenerIP, listenerPort := splitHostPort(listener.Addr().String())
  75         log.Info("Local listener", " ip:", listenerIP, " port:", listenerPort)
  76
  77         // Determine internal address...
  78         var intAddr *NetAddress
  79         intAddr, err = NewNetAddressString(lAddr)
  80         if err != nil {
  81                 cmn.PanicCrisis(err)
  82         }
  83
  84         // Determine external address...
  85         var extAddr *NetAddress
  86         //skipUPNP: If true, does not try getUPNPExternalAddress()
  87         if !skipUPNP {
  88                 // If the lAddrIP is INADDR_ANY, try UPnP
  89                 if lAddrIP == "" || lAddrIP == "0.0.0.0" {
  90                         extAddr = getUPNPExternalAddress(lAddrPort, listenerPort)
  91                         if extAddr != nil {
  92                                 getExtIP = true
  93                                 listenerStatus = true
  94                         }
  95                 }
  96         }
  97         if extAddr == nil {
  98                 if address := GetIP(); address.Success == true {
  99                         extAddr = NewNetAddressIPPort(net.ParseIP(address.Ip), uint16(lAddrPort))
 100                         getExtIP = true
 101                 }
 102         }
 103         // Otherwise just use the local address...
 104         if extAddr == nil {
 105                 extAddr = getNaiveExternalAddress(listenerPort, false)
 106         }
 107         if extAddr == nil {
 108                 cmn.PanicCrisis("Could not determine external address!")
 109         }
 110
 111         dl := &DefaultListener{
 112                 listener:    listener,
 113                 intAddr:     intAddr,
 114                 extAddr:     extAddr,
 115                 connections: make(chan net.Conn, numBufferedConnections),
 116         }
 117         dl.BaseService = *cmn.NewBaseService(nil, "DefaultListener", dl)
 118         dl.Start() // Started upon construction
 119
 120         if !listenerStatus && getExtIP {
 121                 conn, err := net.DialTimeout("tcp", extAddr.String(), 3*time.Second)
 122
 123                 if err != nil && conn == nil {
 124                         log.Error("Could not open listen port")
 125                 }
 126
 127                 if err == nil && conn != nil {
 128                         log.Info("Success open listen port")
 129                         listenerStatus = true
 130                         conn.Close()
 131                 }
 132         }
 133
 134         return dl, listenerStatus
 135 }
 136
 137 //OnStart start listener
 138 func (l *DefaultListener) OnStart() error {
 139         l.BaseService.OnStart()
 140         go l.listenRoutine()
 141         return nil
 142 }
 143
 144 //OnStop stop listener
 145 func (l *DefaultListener) OnStop() {
 146         l.BaseService.OnStop()
 147         l.listener.Close()
 148 }
 149
 150 //listenRoutine Accept connections and pass on the channel
 151 func (l *DefaultListener) listenRoutine() {
 152         for {
 153                 conn, err := l.listener.Accept()
 154
 155                 if !l.IsRunning() {
 156                         break // Go to cleanup
 157                 }
 158
 159                 // listener wasn't stopped,
 160                 // yet we encountered an error.
 161                 if err != nil {
 162                         cmn.PanicCrisis(err)
 163                 }
 164
 165                 l.connections <- conn
 166         }
 167
 168         // Cleanup
 169         close(l.connections)
 170         for _ = range l.connections {
 171                 // Drain
 172         }
 173 }
 174
 175 //Connections a channel of inbound connections. It gets closed when the listener closes.
 176 func (l *DefaultListener) Connections() <-chan net.Conn {
 177         return l.connections
 178 }
 179
 180 //InternalAddress listener internal address
 181 func (l *DefaultListener) InternalAddress() *NetAddress {
 182         return l.intAddr
 183 }
 184
 185 //ExternalAddress listener external address for remote peer dial
 186 func (l *DefaultListener) ExternalAddress() *NetAddress {
 187         return l.extAddr
 188 }
 189
 190 // NetListener the returned listener is already Accept()'ing. So it's not suitable to pass into http.Serve().
 191 func (l *DefaultListener) NetListener() net.Listener {
 192         return l.listener
 193 }
 194
 195 //String string of default listener
 196 func (l *DefaultListener) String() string {
 197         return fmt.Sprintf("Listener(@%v)", l.extAddr)
 198 }
 199
 200 //getUPNPExternalAddress UPNP external address discovery & port mapping
 201 func getUPNPExternalAddress(externalPort, internalPort int) *NetAddress {
 202         log.Info("Getting UPNP external address")
 203         nat, err := upnp.Discover()
 204         if err != nil {
 205                 log.Info("Could not perform UPNP discover. error:", err)
 206                 return nil
 207         }
 208
 209         ext, err := nat.GetExternalAddress()
 210         if err != nil {
 211                 log.Info("Could not perform UPNP external address. error:", err)
 212                 return nil
 213         }
 214
 215         // UPnP can't seem to get the external port, so let's just be explicit.
 216         if externalPort == 0 {
 217                 externalPort = defaultExternalPort
 218         }
 219
 220         externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "bytomd", 0)
 221         if err != nil {
 222                 log.Info("Could not add UPNP port mapping. error:", err)
 223                 return nil
 224         }
 225
 226         log.Info("Got UPNP external address ", ext)
 227         return NewNetAddressIPPort(ext, uint16(externalPort))
 228 }
 229
 230 func getNaiveExternalAddress(port int, settleForLocal bool) *NetAddress {
 231         addrs, err := net.InterfaceAddrs()
 232         if err != nil {
 233                 cmn.PanicCrisis(cmn.Fmt("Could not fetch interface addresses: %v", err))
 234         }
 235
 236         for _, a := range addrs {
 237                 ipnet, ok := a.(*net.IPNet)
 238                 if !ok {
 239                         continue
 240                 }
 241                 v4 := ipnet.IP.To4()
 242                 if v4 == nil || (!settleForLocal && v4[0] == 127) {
 243                         continue
 244                 } // loopback
 245                 return NewNetAddressIPPort(ipnet.IP, uint16(port))
 246         }
 247
 248         // try again, but settle for local
 249         log.Info("Node may not be connected to internet. Settling for local address")
 250         return getNaiveExternalAddress(port, true)
 251 }