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         tlog "github.com/tendermint/tmlibs/log"
  13 )
  14
  15 type Listener interface {
  16         Connections() <-chan net.Conn
  17         InternalAddress() *NetAddress
  18         ExternalAddress() *NetAddress
  19         String() string
  20         Stop() bool
  21 }
  22
  23 // Implements 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 // skipUPNP: If true, does not try getUPNPExternalAddress()
  52 func NewDefaultListener(protocol string, lAddr string, skipUPNP bool, logger tlog.Logger) (Listener, bool, 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 mapResult = false
  60         var extIP = 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.WithFields(log.Fields{
  76                 "ip":   listenerIP,
  77                 "port": listenerPort,
  78         }).Info("Local listener")
  79
  80         // Determine internal address...
  81         var intAddr *NetAddress
  82         intAddr, err = NewNetAddressString(lAddr)
  83         if err != nil {
  84                 cmn.PanicCrisis(err)
  85         }
  86
  87         // Determine external address...
  88         var extAddr *NetAddress
  89         if !skipUPNP {
  90                 // If the lAddrIP is INADDR_ANY, try UPnP
  91                 if lAddrIP == "" || lAddrIP == "0.0.0.0" {
  92                         extAddr = getUPNPExternalAddress(lAddrPort, listenerPort)
  93                         if extAddr != nil {
  94                                 mapResult = true
  95                         } else {
  96                                 extIP = true
  97                         }
  98                 }
  99         }
 100         if extAddr == nil {
 101                 if address := GetIP([]string{}, time.Duration(0)); address.Success == true {
 102                         extAddr = NewNetAddressIPPort(net.ParseIP(address.Ip), uint16(lAddrPort))
 103                         extIP = true
 104                 } else {
 105                         log.Info("Error get external ip:", address.Error)
 106                 }
 107         }
 108         // Otherwise just use the local address...
 109         if extAddr == nil {
 110                 extAddr = getNaiveExternalAddress(listenerPort)
 111         }
 112         if extAddr == nil {
 113                 cmn.PanicCrisis("Could not determine external address!")
 114         }
 115
 116         dl := &DefaultListener{
 117                 listener:    listener,
 118                 intAddr:     intAddr,
 119                 extAddr:     extAddr,
 120                 connections: make(chan net.Conn, numBufferedConnections),
 121         }
 122         dl.BaseService = *cmn.NewBaseService(logger, "DefaultListener", dl)
 123         dl.Start() // Started upon construction
 124         return dl, mapResult, extIP
 125 }
 126
 127 func (l *DefaultListener) OnStart() error {
 128         l.BaseService.OnStart()
 129         go l.listenRoutine()
 130         return nil
 131 }
 132
 133 func (l *DefaultListener) OnStop() {
 134         l.BaseService.OnStop()
 135         l.listener.Close()
 136 }
 137
 138 // Accept connections and pass on the channel
 139 func (l *DefaultListener) listenRoutine() {
 140         for {
 141                 conn, err := l.listener.Accept()
 142
 143                 if !l.IsRunning() {
 144                         break // Go to cleanup
 145                 }
 146
 147                 // listener wasn't stopped,
 148                 // yet we encountered an error.
 149                 if err != nil {
 150                         cmn.PanicCrisis(err)
 151                 }
 152
 153                 l.connections <- conn
 154         }
 155
 156         // Cleanup
 157         close(l.connections)
 158         for _ = range l.connections {
 159                 // Drain
 160         }
 161 }
 162
 163 // A channel of inbound connections.
 164 // It gets closed when the listener closes.
 165 func (l *DefaultListener) Connections() <-chan net.Conn {
 166         return l.connections
 167 }
 168
 169 func (l *DefaultListener) InternalAddress() *NetAddress {
 170         return l.intAddr
 171 }
 172
 173 func (l *DefaultListener) ExternalAddress() *NetAddress {
 174         return l.extAddr
 175 }
 176
 177 // NOTE: The returned listener is already Accept()'ing.
 178 // So it's not suitable to pass into http.Serve().
 179 func (l *DefaultListener) NetListener() net.Listener {
 180         return l.listener
 181 }
 182
 183 func (l *DefaultListener) String() string {
 184         return fmt.Sprintf("Listener(@%v)", l.extAddr)
 185 }
 186
 187 /* external address helpers */
 188
 189 // UPNP external address discovery & port mapping
 190 func getUPNPExternalAddress(externalPort, internalPort int) *NetAddress {
 191         log.Info("Getting UPNP external address")
 192         nat, err := upnp.Discover()
 193         if err != nil {
 194                 log.WithField("error", err).Error("Could not perform UPNP discover")
 195                 return nil
 196         }
 197
 198         ext, err := nat.GetExternalAddress()
 199         if err != nil {
 200                 log.WithField("error", err).Error("Could not perform UPNP external address")
 201                 return nil
 202         }
 203
 204         // UPnP can't seem to get the external port, so let's just be explicit.
 205         if externalPort == 0 {
 206                 externalPort = defaultExternalPort
 207         }
 208
 209         externalPort, err = nat.AddPortMapping("tcp", externalPort, internalPort, "bytomd", 0)
 210         if err != nil {
 211                 log.WithField("error", err).Error("Could not add UPNP port mapping")
 212                 return nil
 213         }
 214
 215         log.WithField("address", ext).Info("Got UPNP external address")
 216         return NewNetAddressIPPort(ext, uint16(externalPort))
 217 }
 218
 219 // TODO: use syscalls: http://pastebin.com/9exZG4rh
 220 func getNaiveExternalAddress(port int) *NetAddress {
 221         addrs, err := net.InterfaceAddrs()
 222         if err != nil {
 223                 cmn.PanicCrisis(cmn.Fmt("Could not fetch interface addresses: %v", err))
 224         }
 225
 226         for _, a := range addrs {
 227                 ipnet, ok := a.(*net.IPNet)
 228                 if !ok {
 229                         continue
 230                 }
 231                 v4 := ipnet.IP.To4()
 232                 if v4 == nil || v4[0] == 127 {
 233                         continue
 234                 } // loopback
 235                 return NewNetAddressIPPort(ipnet.IP, uint16(port))
 236         }
 237         return nil
 238 }