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