You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

349 lines
9.8 KiB

9 years ago
8 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
8 years ago
9 years ago
9 years ago
9 years ago
9 years ago
7 years ago
9 years ago
7 years ago
8 years ago
7 years ago
8 years ago
9 years ago
8 years ago
7 years ago
8 years ago
9 years ago
7 years ago
8 years ago
9 years ago
9 years ago
8 years ago
9 years ago
9 years ago
9 years ago
prevent nil addr Error: ``` Error: runtime error: invalid memoryaddress or nil pointer dereference\nStack: goroutine 549 [running]:\nruntime/debug.Stack(0x0, 0x0, 0x0)\n\t/usr/local/go/src/runtime/debug/stack.go:24 +0x80\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection)._recover(0xc821723b00)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:173 +0x53\npanic(0xbe1500, 0xc820012080)\n\t/usr/local/go/src/runtime/panic.go:443 +0x4e9\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*NetAddress).Valid(0x0, 0x0)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/netaddress.go:125 +0x1c\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*NetAddress).Routable(0x0, 0xc8217bb740)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/netaddress.go:117 +0x25\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*AddrBook).addAddress(0xc820108380, 0x0, 0xc821739590)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/addrbook.go:524 +0x45\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*AddrBook).AddAddress(0xc820108380, 0x0, 0xc821739590)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/addrbook.go:160 +0x286\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*PEXReactor).Receive(0xc82000be60, 0xc820149f00, 0xc8218163f0, 0xc82184e000, 0x5b, 0x1000)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/pex_reactor.go:109 +0x457\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.newPeer.func1(0xc82011d500, 0xc82184e000, 0x5b, 0x1000)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/peer.go:58 +0x202\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection).recvRoutine(0xc821723b00)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:439 +0x1177\ncreated by github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection).OnStart\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:138 +0x1a1\n ```
8 years ago
prevent nil addr Error: ``` Error: runtime error: invalid memoryaddress or nil pointer dereference\nStack: goroutine 549 [running]:\nruntime/debug.Stack(0x0, 0x0, 0x0)\n\t/usr/local/go/src/runtime/debug/stack.go:24 +0x80\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection)._recover(0xc821723b00)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:173 +0x53\npanic(0xbe1500, 0xc820012080)\n\t/usr/local/go/src/runtime/panic.go:443 +0x4e9\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*NetAddress).Valid(0x0, 0x0)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/netaddress.go:125 +0x1c\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*NetAddress).Routable(0x0, 0xc8217bb740)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/netaddress.go:117 +0x25\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*AddrBook).addAddress(0xc820108380, 0x0, 0xc821739590)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/addrbook.go:524 +0x45\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*AddrBook).AddAddress(0xc820108380, 0x0, 0xc821739590)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/addrbook.go:160 +0x286\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*PEXReactor).Receive(0xc82000be60, 0xc820149f00, 0xc8218163f0, 0xc82184e000, 0x5b, 0x1000)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/pex_reactor.go:109 +0x457\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.newPeer.func1(0xc82011d500, 0xc82184e000, 0x5b, 0x1000)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/peer.go:58 +0x202\ngithub.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection).recvRoutine(0xc821723b00)\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:439 +0x1177\ncreated by github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p.(*MConnection).OnStart\n\t/go/src/github.com/tendermint/tendermint/vendor/github.com/tendermint/go-p2p/connection.go:138 +0x1a1\n ```
8 years ago
9 years ago
8 years ago
9 years ago
7 years ago
9 years ago
7 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
8 years ago
9 years ago
8 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
8 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
9 years ago
  1. package p2p
  2. import (
  3. "bytes"
  4. "fmt"
  5. "math/rand"
  6. "reflect"
  7. "time"
  8. wire "github.com/tendermint/go-wire"
  9. cmn "github.com/tendermint/tmlibs/common"
  10. )
  11. const (
  12. // PexChannel is a channel for PEX messages
  13. PexChannel = byte(0x00)
  14. // period to ensure peers connected
  15. defaultEnsurePeersPeriod = 30 * time.Second
  16. minNumOutboundPeers = 10
  17. maxPexMessageSize = 1048576 // 1MB
  18. // maximum messages one peer can send to us during `msgCountByPeerFlushInterval`
  19. defaultMaxMsgCountByPeer = 1000
  20. msgCountByPeerFlushInterval = 1 * time.Hour
  21. )
  22. // PEXReactor handles PEX (peer exchange) and ensures that an
  23. // adequate number of peers are connected to the switch.
  24. //
  25. // It uses `AddrBook` (address book) to store `NetAddress`es of the peers.
  26. //
  27. // ## Preventing abuse
  28. //
  29. // For now, it just limits the number of messages from one peer to
  30. // `defaultMaxMsgCountByPeer` messages per `msgCountByPeerFlushInterval` (1000
  31. // msg/hour).
  32. //
  33. // NOTE [2017-01-17]:
  34. // Limiting is fine for now. Maybe down the road we want to keep track of the
  35. // quality of peer messages so if peerA keeps telling us about peers we can't
  36. // connect to then maybe we should care less about peerA. But I don't think
  37. // that kind of complexity is priority right now.
  38. type PEXReactor struct {
  39. BaseReactor
  40. book *AddrBook
  41. ensurePeersPeriod time.Duration
  42. // tracks message count by peer, so we can prevent abuse
  43. msgCountByPeer *cmn.CMap
  44. maxMsgCountByPeer uint16
  45. }
  46. // NewPEXReactor creates new PEX reactor.
  47. func NewPEXReactor(b *AddrBook) *PEXReactor {
  48. r := &PEXReactor{
  49. book: b,
  50. ensurePeersPeriod: defaultEnsurePeersPeriod,
  51. msgCountByPeer: cmn.NewCMap(),
  52. maxMsgCountByPeer: defaultMaxMsgCountByPeer,
  53. }
  54. r.BaseReactor = *NewBaseReactor("PEXReactor", r)
  55. return r
  56. }
  57. // OnStart implements BaseService
  58. func (r *PEXReactor) OnStart() error {
  59. r.BaseReactor.OnStart()
  60. r.book.Start()
  61. go r.ensurePeersRoutine()
  62. go r.flushMsgCountByPeer()
  63. return nil
  64. }
  65. // OnStop implements BaseService
  66. func (r *PEXReactor) OnStop() {
  67. r.BaseReactor.OnStop()
  68. r.book.Stop()
  69. }
  70. // GetChannels implements Reactor
  71. func (r *PEXReactor) GetChannels() []*ChannelDescriptor {
  72. return []*ChannelDescriptor{
  73. &ChannelDescriptor{
  74. ID: PexChannel,
  75. Priority: 1,
  76. SendQueueCapacity: 10,
  77. },
  78. }
  79. }
  80. // AddPeer implements Reactor by adding peer to the address book (if inbound)
  81. // or by requesting more addresses (if outbound).
  82. func (r *PEXReactor) AddPeer(p Peer) {
  83. if p.IsOutbound() {
  84. // For outbound peers, the address is already in the books.
  85. // Either it was added in DialSeeds or when we
  86. // received the peer's address in r.Receive
  87. if r.book.NeedMoreAddrs() {
  88. r.RequestPEX(p)
  89. }
  90. } else { // For inbound connections, the peer is its own source
  91. addr, err := NewNetAddressString(p.NodeInfo().ListenAddr)
  92. if err != nil {
  93. // peer gave us a bad ListenAddr. TODO: punish
  94. r.Logger.Error("Error in AddPeer: invalid peer address", "addr", p.NodeInfo().ListenAddr, "err", err)
  95. return
  96. }
  97. r.book.AddAddress(addr, addr)
  98. }
  99. }
  100. // RemovePeer implements Reactor.
  101. func (r *PEXReactor) RemovePeer(p Peer, reason interface{}) {
  102. // If we aren't keeping track of local temp data for each peer here, then we
  103. // don't have to do anything.
  104. }
  105. // Receive implements Reactor by handling incoming PEX messages.
  106. func (r *PEXReactor) Receive(chID byte, src Peer, msgBytes []byte) {
  107. srcAddrStr := src.NodeInfo().RemoteAddr
  108. srcAddr, err := NewNetAddressString(srcAddrStr)
  109. if err != nil {
  110. // this should never happen. TODO: cancel conn
  111. r.Logger.Error("Error in Receive: invalid peer address", "addr", srcAddrStr, "err", err)
  112. return
  113. }
  114. r.IncrementMsgCountForPeer(srcAddrStr)
  115. if r.ReachedMaxMsgCountForPeer(srcAddrStr) {
  116. r.Logger.Error("Maximum number of messages reached for peer", "peer", srcAddrStr)
  117. // TODO remove src from peers?
  118. return
  119. }
  120. _, msg, err := DecodeMessage(msgBytes)
  121. if err != nil {
  122. r.Logger.Error("Error decoding message", "err", err)
  123. return
  124. }
  125. r.Logger.Info("Received message", "msg", msg)
  126. switch msg := msg.(type) {
  127. case *pexRequestMessage:
  128. // src requested some peers.
  129. // NOTE: we might send an empty selection
  130. r.SendAddrs(src, r.book.GetSelection())
  131. case *pexAddrsMessage:
  132. // We received some peer addresses from src.
  133. // TODO: (We don't want to get spammed with bad peers)
  134. for _, addr := range msg.Addrs {
  135. if addr != nil {
  136. r.book.AddAddress(addr, srcAddr)
  137. }
  138. }
  139. default:
  140. r.Logger.Error(fmt.Sprintf("Unknown message type %v", reflect.TypeOf(msg)))
  141. }
  142. }
  143. // RequestPEX asks peer for more addresses.
  144. func (r *PEXReactor) RequestPEX(p Peer) {
  145. p.Send(PexChannel, struct{ PexMessage }{&pexRequestMessage{}})
  146. }
  147. // SendAddrs sends addrs to the peer.
  148. func (r *PEXReactor) SendAddrs(p Peer, addrs []*NetAddress) {
  149. p.Send(PexChannel, struct{ PexMessage }{&pexAddrsMessage{Addrs: addrs}})
  150. }
  151. // SetEnsurePeersPeriod sets period to ensure peers connected.
  152. func (r *PEXReactor) SetEnsurePeersPeriod(d time.Duration) {
  153. r.ensurePeersPeriod = d
  154. }
  155. // SetMaxMsgCountByPeer sets maximum messages one peer can send to us during 'msgCountByPeerFlushInterval'.
  156. func (r *PEXReactor) SetMaxMsgCountByPeer(v uint16) {
  157. r.maxMsgCountByPeer = v
  158. }
  159. // ReachedMaxMsgCountForPeer returns true if we received too many
  160. // messages from peer with address `addr`.
  161. // NOTE: assumes the value in the CMap is non-nil
  162. func (r *PEXReactor) ReachedMaxMsgCountForPeer(addr string) bool {
  163. return r.msgCountByPeer.Get(addr).(uint16) >= r.maxMsgCountByPeer
  164. }
  165. // Increment or initialize the msg count for the peer in the CMap
  166. func (r *PEXReactor) IncrementMsgCountForPeer(addr string) {
  167. var count uint16
  168. countI := r.msgCountByPeer.Get(addr)
  169. if countI != nil {
  170. count = countI.(uint16)
  171. }
  172. count++
  173. r.msgCountByPeer.Set(addr, count)
  174. }
  175. // Ensures that sufficient peers are connected. (continuous)
  176. func (r *PEXReactor) ensurePeersRoutine() {
  177. // Randomize when routine starts
  178. ensurePeersPeriodMs := r.ensurePeersPeriod.Nanoseconds() / 1e6
  179. time.Sleep(time.Duration(rand.Int63n(ensurePeersPeriodMs)) * time.Millisecond)
  180. // fire once immediately.
  181. r.ensurePeers()
  182. // fire periodically
  183. ticker := time.NewTicker(r.ensurePeersPeriod)
  184. for {
  185. select {
  186. case <-ticker.C:
  187. r.ensurePeers()
  188. case <-r.Quit:
  189. ticker.Stop()
  190. return
  191. }
  192. }
  193. }
  194. // ensurePeers ensures that sufficient peers are connected. (once)
  195. //
  196. // Old bucket / New bucket are arbitrary categories to denote whether an
  197. // address is vetted or not, and this needs to be determined over time via a
  198. // heuristic that we haven't perfected yet, or, perhaps is manually edited by
  199. // the node operator. It should not be used to compute what addresses are
  200. // already connected or not.
  201. //
  202. // TODO Basically, we need to work harder on our good-peer/bad-peer marking.
  203. // What we're currently doing in terms of marking good/bad peers is just a
  204. // placeholder. It should not be the case that an address becomes old/vetted
  205. // upon a single successful connection.
  206. func (r *PEXReactor) ensurePeers() {
  207. numOutPeers, _, numDialing := r.Switch.NumPeers()
  208. numToDial := minNumOutboundPeers - (numOutPeers + numDialing)
  209. r.Logger.Info("Ensure peers", "numOutPeers", numOutPeers, "numDialing", numDialing, "numToDial", numToDial)
  210. if numToDial <= 0 {
  211. return
  212. }
  213. // bias to prefer more vetted peers when we have fewer connections.
  214. // not perfect, but somewhate ensures that we prioritize connecting to more-vetted
  215. newBias := cmn.MinInt(numOutPeers, 8)*10 + 10
  216. toDial := make(map[string]*NetAddress)
  217. // Try maxAttempts times to pick numToDial addresses to dial
  218. maxAttempts := numToDial * 3
  219. for i := 0; i < maxAttempts && len(toDial) < numToDial; i++ {
  220. try := r.book.PickAddress(newBias)
  221. if try == nil {
  222. continue
  223. }
  224. if _, selected := toDial[try.IP.String()]; selected {
  225. continue
  226. }
  227. if dialling := r.Switch.IsDialing(try); dialling {
  228. continue
  229. }
  230. if connected := r.Switch.Peers().Has(try.IP.String()); connected {
  231. continue
  232. }
  233. r.Logger.Info("Will dial address", "addr", try)
  234. toDial[try.IP.String()] = try
  235. }
  236. // Dial picked addresses
  237. for _, item := range toDial {
  238. go func(picked *NetAddress) {
  239. _, err := r.Switch.DialPeerWithAddress(picked, false)
  240. if err != nil {
  241. r.book.MarkAttempt(picked)
  242. }
  243. }(item)
  244. }
  245. // If we need more addresses, pick a random peer and ask for more.
  246. if r.book.NeedMoreAddrs() {
  247. if peers := r.Switch.Peers().List(); len(peers) > 0 {
  248. i := rand.Int() % len(peers)
  249. peer := peers[i]
  250. r.Logger.Info("No addresses to dial. Sending pexRequest to random peer", "peer", peer)
  251. r.RequestPEX(peer)
  252. }
  253. }
  254. }
  255. func (r *PEXReactor) flushMsgCountByPeer() {
  256. ticker := time.NewTicker(msgCountByPeerFlushInterval)
  257. for {
  258. select {
  259. case <-ticker.C:
  260. r.msgCountByPeer.Clear()
  261. case <-r.Quit:
  262. ticker.Stop()
  263. return
  264. }
  265. }
  266. }
  267. //-----------------------------------------------------------------------------
  268. // Messages
  269. const (
  270. msgTypeRequest = byte(0x01)
  271. msgTypeAddrs = byte(0x02)
  272. )
  273. // PexMessage is a primary type for PEX messages. Underneath, it could contain
  274. // either pexRequestMessage, or pexAddrsMessage messages.
  275. type PexMessage interface{}
  276. var _ = wire.RegisterInterface(
  277. struct{ PexMessage }{},
  278. wire.ConcreteType{&pexRequestMessage{}, msgTypeRequest},
  279. wire.ConcreteType{&pexAddrsMessage{}, msgTypeAddrs},
  280. )
  281. // DecodeMessage implements interface registered above.
  282. func DecodeMessage(bz []byte) (msgType byte, msg PexMessage, err error) {
  283. msgType = bz[0]
  284. n := new(int)
  285. r := bytes.NewReader(bz)
  286. msg = wire.ReadBinary(struct{ PexMessage }{}, r, maxPexMessageSize, n, &err).(struct{ PexMessage }).PexMessage
  287. return
  288. }
  289. /*
  290. A pexRequestMessage requests additional peer addresses.
  291. */
  292. type pexRequestMessage struct {
  293. }
  294. func (m *pexRequestMessage) String() string {
  295. return "[pexRequest]"
  296. }
  297. /*
  298. A message with announced peer addresses.
  299. */
  300. type pexAddrsMessage struct {
  301. Addrs []*NetAddress
  302. }
  303. func (m *pexAddrsMessage) String() string {
  304. return fmt.Sprintf("[pexAddrs %v]", m.Addrs)
  305. }