github.com/needkane/go-ethereum@v1.7.4-0.20180131070256-c212876ea2b7/p2p/discv5/net.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package discv5 18 19 import ( 20 "bytes" 21 "crypto/ecdsa" 22 "errors" 23 "fmt" 24 "net" 25 "time" 26 27 "github.com/ethereum/go-ethereum/common" 28 "github.com/ethereum/go-ethereum/common/mclock" 29 "github.com/ethereum/go-ethereum/crypto" 30 "github.com/ethereum/go-ethereum/crypto/sha3" 31 "github.com/ethereum/go-ethereum/log" 32 "github.com/ethereum/go-ethereum/p2p/netutil" 33 "github.com/ethereum/go-ethereum/rlp" 34 ) 35 36 var ( 37 errInvalidEvent = errors.New("invalid in current state") 38 errNoQuery = errors.New("no pending query") 39 errWrongAddress = errors.New("unknown sender address") 40 ) 41 42 const ( 43 autoRefreshInterval = 1 * time.Hour 44 bucketRefreshInterval = 1 * time.Minute 45 seedCount = 30 46 seedMaxAge = 5 * 24 * time.Hour 47 lowPort = 1024 48 ) 49 50 const testTopic = "foo" 51 52 const ( 53 printTestImgLogs = false 54 ) 55 56 // Network manages the table and all protocol interaction. 57 type Network struct { 58 db *nodeDB // database of known nodes 59 conn transport 60 netrestrict *netutil.Netlist 61 62 closed chan struct{} // closed when loop is done 63 closeReq chan struct{} // 'request to close' 64 refreshReq chan []*Node // lookups ask for refresh on this channel 65 refreshResp chan (<-chan struct{}) // ...and get the channel to block on from this one 66 read chan ingressPacket // ingress packets arrive here 67 timeout chan timeoutEvent 68 queryReq chan *findnodeQuery // lookups submit findnode queries on this channel 69 tableOpReq chan func() 70 tableOpResp chan struct{} 71 topicRegisterReq chan topicRegisterReq 72 topicSearchReq chan topicSearchReq 73 74 // State of the main loop. 75 tab *Table 76 topictab *topicTable 77 ticketStore *ticketStore 78 nursery []*Node 79 nodes map[NodeID]*Node // tracks active nodes with state != known 80 timeoutTimers map[timeoutEvent]*time.Timer 81 82 // Revalidation queues. 83 // Nodes put on these queues will be pinged eventually. 84 slowRevalidateQueue []*Node 85 fastRevalidateQueue []*Node 86 87 // Buffers for state transition. 88 sendBuf []*ingressPacket 89 } 90 91 // transport is implemented by the UDP transport. 92 // it is an interface so we can test without opening lots of UDP 93 // sockets and without generating a private key. 94 type transport interface { 95 sendPing(remote *Node, remoteAddr *net.UDPAddr, topics []Topic) (hash []byte) 96 sendNeighbours(remote *Node, nodes []*Node) 97 sendFindnodeHash(remote *Node, target common.Hash) 98 sendTopicRegister(remote *Node, topics []Topic, topicIdx int, pong []byte) 99 sendTopicNodes(remote *Node, queryHash common.Hash, nodes []*Node) 100 101 send(remote *Node, ptype nodeEvent, p interface{}) (hash []byte) 102 103 localAddr() *net.UDPAddr 104 Close() 105 } 106 107 type findnodeQuery struct { 108 remote *Node 109 target common.Hash 110 reply chan<- []*Node 111 nresults int // counter for received nodes 112 } 113 114 type topicRegisterReq struct { 115 add bool 116 topic Topic 117 } 118 119 type topicSearchReq struct { 120 topic Topic 121 found chan<- *Node 122 lookup chan<- bool 123 delay time.Duration 124 } 125 126 type topicSearchResult struct { 127 target lookupInfo 128 nodes []*Node 129 } 130 131 type timeoutEvent struct { 132 ev nodeEvent 133 node *Node 134 } 135 136 func newNetwork(conn transport, ourPubkey ecdsa.PublicKey, dbPath string, netrestrict *netutil.Netlist) (*Network, error) { 137 ourID := PubkeyID(&ourPubkey) 138 139 var db *nodeDB 140 if dbPath != "<no database>" { 141 var err error 142 if db, err = newNodeDB(dbPath, Version, ourID); err != nil { 143 return nil, err 144 } 145 } 146 147 tab := newTable(ourID, conn.localAddr()) 148 net := &Network{ 149 db: db, 150 conn: conn, 151 netrestrict: netrestrict, 152 tab: tab, 153 topictab: newTopicTable(db, tab.self), 154 ticketStore: newTicketStore(), 155 refreshReq: make(chan []*Node), 156 refreshResp: make(chan (<-chan struct{})), 157 closed: make(chan struct{}), 158 closeReq: make(chan struct{}), 159 read: make(chan ingressPacket, 100), 160 timeout: make(chan timeoutEvent), 161 timeoutTimers: make(map[timeoutEvent]*time.Timer), 162 tableOpReq: make(chan func()), 163 tableOpResp: make(chan struct{}), 164 queryReq: make(chan *findnodeQuery), 165 topicRegisterReq: make(chan topicRegisterReq), 166 topicSearchReq: make(chan topicSearchReq), 167 nodes: make(map[NodeID]*Node), 168 } 169 go net.loop() 170 return net, nil 171 } 172 173 // Close terminates the network listener and flushes the node database. 174 func (net *Network) Close() { 175 net.conn.Close() 176 select { 177 case <-net.closed: 178 case net.closeReq <- struct{}{}: 179 <-net.closed 180 } 181 } 182 183 // Self returns the local node. 184 // The returned node should not be modified by the caller. 185 func (net *Network) Self() *Node { 186 return net.tab.self 187 } 188 189 // ReadRandomNodes fills the given slice with random nodes from the 190 // table. It will not write the same node more than once. The nodes in 191 // the slice are copies and can be modified by the caller. 192 func (net *Network) ReadRandomNodes(buf []*Node) (n int) { 193 net.reqTableOp(func() { n = net.tab.readRandomNodes(buf) }) 194 return n 195 } 196 197 // SetFallbackNodes sets the initial points of contact. These nodes 198 // are used to connect to the network if the table is empty and there 199 // are no known nodes in the database. 200 func (net *Network) SetFallbackNodes(nodes []*Node) error { 201 nursery := make([]*Node, 0, len(nodes)) 202 for _, n := range nodes { 203 if err := n.validateComplete(); err != nil { 204 return fmt.Errorf("bad bootstrap/fallback node %q (%v)", n, err) 205 } 206 // Recompute cpy.sha because the node might not have been 207 // created by NewNode or ParseNode. 208 cpy := *n 209 cpy.sha = crypto.Keccak256Hash(n.ID[:]) 210 nursery = append(nursery, &cpy) 211 } 212 net.reqRefresh(nursery) 213 return nil 214 } 215 216 // Resolve searches for a specific node with the given ID. 217 // It returns nil if the node could not be found. 218 func (net *Network) Resolve(targetID NodeID) *Node { 219 result := net.lookup(crypto.Keccak256Hash(targetID[:]), true) 220 for _, n := range result { 221 if n.ID == targetID { 222 return n 223 } 224 } 225 return nil 226 } 227 228 // Lookup performs a network search for nodes close 229 // to the given target. It approaches the target by querying 230 // nodes that are closer to it on each iteration. 231 // The given target does not need to be an actual node 232 // identifier. 233 // 234 // The local node may be included in the result. 235 func (net *Network) Lookup(targetID NodeID) []*Node { 236 return net.lookup(crypto.Keccak256Hash(targetID[:]), false) 237 } 238 239 func (net *Network) lookup(target common.Hash, stopOnMatch bool) []*Node { 240 var ( 241 asked = make(map[NodeID]bool) 242 seen = make(map[NodeID]bool) 243 reply = make(chan []*Node, alpha) 244 result = nodesByDistance{target: target} 245 pendingQueries = 0 246 ) 247 // Get initial answers from the local node. 248 result.push(net.tab.self, bucketSize) 249 for { 250 // Ask the α closest nodes that we haven't asked yet. 251 for i := 0; i < len(result.entries) && pendingQueries < alpha; i++ { 252 n := result.entries[i] 253 if !asked[n.ID] { 254 asked[n.ID] = true 255 pendingQueries++ 256 net.reqQueryFindnode(n, target, reply) 257 } 258 } 259 if pendingQueries == 0 { 260 // We have asked all closest nodes, stop the search. 261 break 262 } 263 // Wait for the next reply. 264 select { 265 case nodes := <-reply: 266 for _, n := range nodes { 267 if n != nil && !seen[n.ID] { 268 seen[n.ID] = true 269 result.push(n, bucketSize) 270 if stopOnMatch && n.sha == target { 271 return result.entries 272 } 273 } 274 } 275 pendingQueries-- 276 case <-time.After(respTimeout): 277 // forget all pending requests, start new ones 278 pendingQueries = 0 279 reply = make(chan []*Node, alpha) 280 } 281 } 282 return result.entries 283 } 284 285 func (net *Network) RegisterTopic(topic Topic, stop <-chan struct{}) { 286 select { 287 case net.topicRegisterReq <- topicRegisterReq{true, topic}: 288 case <-net.closed: 289 return 290 } 291 select { 292 case <-net.closed: 293 case <-stop: 294 select { 295 case net.topicRegisterReq <- topicRegisterReq{false, topic}: 296 case <-net.closed: 297 } 298 } 299 } 300 301 func (net *Network) SearchTopic(topic Topic, setPeriod <-chan time.Duration, found chan<- *Node, lookup chan<- bool) { 302 for { 303 select { 304 case <-net.closed: 305 return 306 case delay, ok := <-setPeriod: 307 select { 308 case net.topicSearchReq <- topicSearchReq{topic: topic, found: found, lookup: lookup, delay: delay}: 309 case <-net.closed: 310 return 311 } 312 if !ok { 313 return 314 } 315 } 316 } 317 } 318 319 func (net *Network) reqRefresh(nursery []*Node) <-chan struct{} { 320 select { 321 case net.refreshReq <- nursery: 322 return <-net.refreshResp 323 case <-net.closed: 324 return net.closed 325 } 326 } 327 328 func (net *Network) reqQueryFindnode(n *Node, target common.Hash, reply chan []*Node) bool { 329 q := &findnodeQuery{remote: n, target: target, reply: reply} 330 select { 331 case net.queryReq <- q: 332 return true 333 case <-net.closed: 334 return false 335 } 336 } 337 338 func (net *Network) reqReadPacket(pkt ingressPacket) { 339 select { 340 case net.read <- pkt: 341 case <-net.closed: 342 } 343 } 344 345 func (net *Network) reqTableOp(f func()) (called bool) { 346 select { 347 case net.tableOpReq <- f: 348 <-net.tableOpResp 349 return true 350 case <-net.closed: 351 return false 352 } 353 } 354 355 // TODO: external address handling. 356 357 type topicSearchInfo struct { 358 lookupChn chan<- bool 359 period time.Duration 360 } 361 362 const maxSearchCount = 5 363 364 func (net *Network) loop() { 365 var ( 366 refreshTimer = time.NewTicker(autoRefreshInterval) 367 bucketRefreshTimer = time.NewTimer(bucketRefreshInterval) 368 refreshDone chan struct{} // closed when the 'refresh' lookup has ended 369 ) 370 371 // Tracking the next ticket to register. 372 var ( 373 nextTicket *ticketRef 374 nextRegisterTimer *time.Timer 375 nextRegisterTime <-chan time.Time 376 ) 377 defer func() { 378 if nextRegisterTimer != nil { 379 nextRegisterTimer.Stop() 380 } 381 }() 382 resetNextTicket := func() { 383 ticket, timeout := net.ticketStore.nextFilteredTicket() 384 if nextTicket != ticket { 385 nextTicket = ticket 386 if nextRegisterTimer != nil { 387 nextRegisterTimer.Stop() 388 nextRegisterTime = nil 389 } 390 if ticket != nil { 391 nextRegisterTimer = time.NewTimer(timeout) 392 nextRegisterTime = nextRegisterTimer.C 393 } 394 } 395 } 396 397 // Tracking registration and search lookups. 398 var ( 399 topicRegisterLookupTarget lookupInfo 400 topicRegisterLookupDone chan []*Node 401 topicRegisterLookupTick = time.NewTimer(0) 402 searchReqWhenRefreshDone []topicSearchReq 403 searchInfo = make(map[Topic]topicSearchInfo) 404 activeSearchCount int 405 ) 406 topicSearchLookupDone := make(chan topicSearchResult, 100) 407 topicSearch := make(chan Topic, 100) 408 <-topicRegisterLookupTick.C 409 410 statsDump := time.NewTicker(10 * time.Second) 411 412 loop: 413 for { 414 resetNextTicket() 415 416 select { 417 case <-net.closeReq: 418 log.Trace("<-net.closeReq") 419 break loop 420 421 // Ingress packet handling. 422 case pkt := <-net.read: 423 //fmt.Println("read", pkt.ev) 424 log.Trace("<-net.read") 425 n := net.internNode(&pkt) 426 prestate := n.state 427 status := "ok" 428 if err := net.handle(n, pkt.ev, &pkt); err != nil { 429 status = err.Error() 430 } 431 log.Trace("", "msg", log.Lazy{Fn: func() string { 432 return fmt.Sprintf("<<< (%d) %v from %x@%v: %v -> %v (%v)", 433 net.tab.count, pkt.ev, pkt.remoteID[:8], pkt.remoteAddr, prestate, n.state, status) 434 }}) 435 // TODO: persist state if n.state goes >= known, delete if it goes <= known 436 437 // State transition timeouts. 438 case timeout := <-net.timeout: 439 log.Trace("<-net.timeout") 440 if net.timeoutTimers[timeout] == nil { 441 // Stale timer (was aborted). 442 continue 443 } 444 delete(net.timeoutTimers, timeout) 445 prestate := timeout.node.state 446 status := "ok" 447 if err := net.handle(timeout.node, timeout.ev, nil); err != nil { 448 status = err.Error() 449 } 450 log.Trace("", "msg", log.Lazy{Fn: func() string { 451 return fmt.Sprintf("--- (%d) %v for %x@%v: %v -> %v (%v)", 452 net.tab.count, timeout.ev, timeout.node.ID[:8], timeout.node.addr(), prestate, timeout.node.state, status) 453 }}) 454 455 // Querying. 456 case q := <-net.queryReq: 457 log.Trace("<-net.queryReq") 458 if !q.start(net) { 459 q.remote.deferQuery(q) 460 } 461 462 // Interacting with the table. 463 case f := <-net.tableOpReq: 464 log.Trace("<-net.tableOpReq") 465 f() 466 net.tableOpResp <- struct{}{} 467 468 // Topic registration stuff. 469 case req := <-net.topicRegisterReq: 470 log.Trace("<-net.topicRegisterReq") 471 if !req.add { 472 net.ticketStore.removeRegisterTopic(req.topic) 473 continue 474 } 475 net.ticketStore.addTopic(req.topic, true) 476 // If we're currently waiting idle (nothing to look up), give the ticket store a 477 // chance to start it sooner. This should speed up convergence of the radius 478 // determination for new topics. 479 // if topicRegisterLookupDone == nil { 480 if topicRegisterLookupTarget.target == (common.Hash{}) { 481 log.Trace("topicRegisterLookupTarget == null") 482 if topicRegisterLookupTick.Stop() { 483 <-topicRegisterLookupTick.C 484 } 485 target, delay := net.ticketStore.nextRegisterLookup() 486 topicRegisterLookupTarget = target 487 topicRegisterLookupTick.Reset(delay) 488 } 489 490 case nodes := <-topicRegisterLookupDone: 491 log.Trace("<-topicRegisterLookupDone") 492 net.ticketStore.registerLookupDone(topicRegisterLookupTarget, nodes, func(n *Node) []byte { 493 net.ping(n, n.addr()) 494 return n.pingEcho 495 }) 496 target, delay := net.ticketStore.nextRegisterLookup() 497 topicRegisterLookupTarget = target 498 topicRegisterLookupTick.Reset(delay) 499 topicRegisterLookupDone = nil 500 501 case <-topicRegisterLookupTick.C: 502 log.Trace("<-topicRegisterLookupTick") 503 if (topicRegisterLookupTarget.target == common.Hash{}) { 504 target, delay := net.ticketStore.nextRegisterLookup() 505 topicRegisterLookupTarget = target 506 topicRegisterLookupTick.Reset(delay) 507 topicRegisterLookupDone = nil 508 } else { 509 topicRegisterLookupDone = make(chan []*Node) 510 target := topicRegisterLookupTarget.target 511 go func() { topicRegisterLookupDone <- net.lookup(target, false) }() 512 } 513 514 case <-nextRegisterTime: 515 log.Trace("<-nextRegisterTime") 516 net.ticketStore.ticketRegistered(*nextTicket) 517 //fmt.Println("sendTopicRegister", nextTicket.t.node.addr().String(), nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong) 518 net.conn.sendTopicRegister(nextTicket.t.node, nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong) 519 520 case req := <-net.topicSearchReq: 521 if refreshDone == nil { 522 log.Trace("<-net.topicSearchReq") 523 info, ok := searchInfo[req.topic] 524 if ok { 525 if req.delay == time.Duration(0) { 526 delete(searchInfo, req.topic) 527 net.ticketStore.removeSearchTopic(req.topic) 528 } else { 529 info.period = req.delay 530 searchInfo[req.topic] = info 531 } 532 continue 533 } 534 if req.delay != time.Duration(0) { 535 var info topicSearchInfo 536 info.period = req.delay 537 info.lookupChn = req.lookup 538 searchInfo[req.topic] = info 539 net.ticketStore.addSearchTopic(req.topic, req.found) 540 topicSearch <- req.topic 541 } 542 } else { 543 searchReqWhenRefreshDone = append(searchReqWhenRefreshDone, req) 544 } 545 546 case topic := <-topicSearch: 547 if activeSearchCount < maxSearchCount { 548 activeSearchCount++ 549 target := net.ticketStore.nextSearchLookup(topic) 550 go func() { 551 nodes := net.lookup(target.target, false) 552 topicSearchLookupDone <- topicSearchResult{target: target, nodes: nodes} 553 }() 554 } 555 period := searchInfo[topic].period 556 if period != time.Duration(0) { 557 go func() { 558 time.Sleep(period) 559 topicSearch <- topic 560 }() 561 } 562 563 case res := <-topicSearchLookupDone: 564 activeSearchCount-- 565 if lookupChn := searchInfo[res.target.topic].lookupChn; lookupChn != nil { 566 lookupChn <- net.ticketStore.radius[res.target.topic].converged 567 } 568 net.ticketStore.searchLookupDone(res.target, res.nodes, func(n *Node) []byte { 569 net.ping(n, n.addr()) 570 return n.pingEcho 571 }, func(n *Node, topic Topic) []byte { 572 if n.state == known { 573 return net.conn.send(n, topicQueryPacket, topicQuery{Topic: topic}) // TODO: set expiration 574 } else { 575 if n.state == unknown { 576 net.ping(n, n.addr()) 577 } 578 return nil 579 } 580 }) 581 582 case <-statsDump.C: 583 log.Trace("<-statsDump.C") 584 /*r, ok := net.ticketStore.radius[testTopic] 585 if !ok { 586 fmt.Printf("(%x) no radius @ %v\n", net.tab.self.ID[:8], time.Now()) 587 } else { 588 topics := len(net.ticketStore.tickets) 589 tickets := len(net.ticketStore.nodes) 590 rad := r.radius / (maxRadius/10000+1) 591 fmt.Printf("(%x) topics:%d radius:%d tickets:%d @ %v\n", net.tab.self.ID[:8], topics, rad, tickets, time.Now()) 592 }*/ 593 594 tm := mclock.Now() 595 for topic, r := range net.ticketStore.radius { 596 if printTestImgLogs { 597 rad := r.radius / (maxRadius/1000000 + 1) 598 minrad := r.minRadius / (maxRadius/1000000 + 1) 599 fmt.Printf("*R %d %v %016x %v\n", tm/1000000, topic, net.tab.self.sha[:8], rad) 600 fmt.Printf("*MR %d %v %016x %v\n", tm/1000000, topic, net.tab.self.sha[:8], minrad) 601 } 602 } 603 for topic, t := range net.topictab.topics { 604 wp := t.wcl.nextWaitPeriod(tm) 605 if printTestImgLogs { 606 fmt.Printf("*W %d %v %016x %d\n", tm/1000000, topic, net.tab.self.sha[:8], wp/1000000) 607 } 608 } 609 610 // Periodic / lookup-initiated bucket refresh. 611 case <-refreshTimer.C: 612 log.Trace("<-refreshTimer.C") 613 // TODO: ideally we would start the refresh timer after 614 // fallback nodes have been set for the first time. 615 if refreshDone == nil { 616 refreshDone = make(chan struct{}) 617 net.refresh(refreshDone) 618 } 619 case <-bucketRefreshTimer.C: 620 target := net.tab.chooseBucketRefreshTarget() 621 go func() { 622 net.lookup(target, false) 623 bucketRefreshTimer.Reset(bucketRefreshInterval) 624 }() 625 case newNursery := <-net.refreshReq: 626 log.Trace("<-net.refreshReq") 627 if newNursery != nil { 628 net.nursery = newNursery 629 } 630 if refreshDone == nil { 631 refreshDone = make(chan struct{}) 632 net.refresh(refreshDone) 633 } 634 net.refreshResp <- refreshDone 635 case <-refreshDone: 636 log.Trace("<-net.refreshDone") 637 refreshDone = nil 638 list := searchReqWhenRefreshDone 639 searchReqWhenRefreshDone = nil 640 go func() { 641 for _, req := range list { 642 net.topicSearchReq <- req 643 } 644 }() 645 } 646 } 647 log.Trace("loop stopped") 648 649 log.Debug(fmt.Sprintf("shutting down")) 650 if net.conn != nil { 651 net.conn.Close() 652 } 653 if refreshDone != nil { 654 // TODO: wait for pending refresh. 655 //<-refreshResults 656 } 657 // Cancel all pending timeouts. 658 for _, timer := range net.timeoutTimers { 659 timer.Stop() 660 } 661 if net.db != nil { 662 net.db.close() 663 } 664 close(net.closed) 665 } 666 667 // Everything below runs on the Network.loop goroutine 668 // and can modify Node, Table and Network at any time without locking. 669 670 func (net *Network) refresh(done chan<- struct{}) { 671 var seeds []*Node 672 if net.db != nil { 673 seeds = net.db.querySeeds(seedCount, seedMaxAge) 674 } 675 if len(seeds) == 0 { 676 seeds = net.nursery 677 } 678 if len(seeds) == 0 { 679 log.Trace("no seed nodes found") 680 close(done) 681 return 682 } 683 for _, n := range seeds { 684 log.Debug("", "msg", log.Lazy{Fn: func() string { 685 var age string 686 if net.db != nil { 687 age = time.Since(net.db.lastPong(n.ID)).String() 688 } else { 689 age = "unknown" 690 } 691 return fmt.Sprintf("seed node (age %s): %v", age, n) 692 }}) 693 n = net.internNodeFromDB(n) 694 if n.state == unknown { 695 net.transition(n, verifyinit) 696 } 697 // Force-add the seed node so Lookup does something. 698 // It will be deleted again if verification fails. 699 net.tab.add(n) 700 } 701 // Start self lookup to fill up the buckets. 702 go func() { 703 net.Lookup(net.tab.self.ID) 704 close(done) 705 }() 706 } 707 708 // Node Interning. 709 710 func (net *Network) internNode(pkt *ingressPacket) *Node { 711 if n := net.nodes[pkt.remoteID]; n != nil { 712 n.IP = pkt.remoteAddr.IP 713 n.UDP = uint16(pkt.remoteAddr.Port) 714 n.TCP = uint16(pkt.remoteAddr.Port) 715 return n 716 } 717 n := NewNode(pkt.remoteID, pkt.remoteAddr.IP, uint16(pkt.remoteAddr.Port), uint16(pkt.remoteAddr.Port)) 718 n.state = unknown 719 net.nodes[pkt.remoteID] = n 720 return n 721 } 722 723 func (net *Network) internNodeFromDB(dbn *Node) *Node { 724 if n := net.nodes[dbn.ID]; n != nil { 725 return n 726 } 727 n := NewNode(dbn.ID, dbn.IP, dbn.UDP, dbn.TCP) 728 n.state = unknown 729 net.nodes[n.ID] = n 730 return n 731 } 732 733 func (net *Network) internNodeFromNeighbours(sender *net.UDPAddr, rn rpcNode) (n *Node, err error) { 734 if rn.ID == net.tab.self.ID { 735 return nil, errors.New("is self") 736 } 737 if rn.UDP <= lowPort { 738 return nil, errors.New("low port") 739 } 740 n = net.nodes[rn.ID] 741 if n == nil { 742 // We haven't seen this node before. 743 n, err = nodeFromRPC(sender, rn) 744 if net.netrestrict != nil && !net.netrestrict.Contains(n.IP) { 745 return n, errors.New("not contained in netrestrict whitelist") 746 } 747 if err == nil { 748 n.state = unknown 749 net.nodes[n.ID] = n 750 } 751 return n, err 752 } 753 if !n.IP.Equal(rn.IP) || n.UDP != rn.UDP || n.TCP != rn.TCP { 754 err = fmt.Errorf("metadata mismatch: got %v, want %v", rn, n) 755 } 756 return n, err 757 } 758 759 // nodeNetGuts is embedded in Node and contains fields. 760 type nodeNetGuts struct { 761 // This is a cached copy of sha3(ID) which is used for node 762 // distance calculations. This is part of Node in order to make it 763 // possible to write tests that need a node at a certain distance. 764 // In those tests, the content of sha will not actually correspond 765 // with ID. 766 sha common.Hash 767 768 // State machine fields. Access to these fields 769 // is restricted to the Network.loop goroutine. 770 state *nodeState 771 pingEcho []byte // hash of last ping sent by us 772 pingTopics []Topic // topic set sent by us in last ping 773 deferredQueries []*findnodeQuery // queries that can't be sent yet 774 pendingNeighbours *findnodeQuery // current query, waiting for reply 775 queryTimeouts int 776 } 777 778 func (n *nodeNetGuts) deferQuery(q *findnodeQuery) { 779 n.deferredQueries = append(n.deferredQueries, q) 780 } 781 782 func (n *nodeNetGuts) startNextQuery(net *Network) { 783 if len(n.deferredQueries) == 0 { 784 return 785 } 786 nextq := n.deferredQueries[0] 787 if nextq.start(net) { 788 n.deferredQueries = append(n.deferredQueries[:0], n.deferredQueries[1:]...) 789 } 790 } 791 792 func (q *findnodeQuery) start(net *Network) bool { 793 // Satisfy queries against the local node directly. 794 if q.remote == net.tab.self { 795 closest := net.tab.closest(crypto.Keccak256Hash(q.target[:]), bucketSize) 796 q.reply <- closest.entries 797 return true 798 } 799 if q.remote.state.canQuery && q.remote.pendingNeighbours == nil { 800 net.conn.sendFindnodeHash(q.remote, q.target) 801 net.timedEvent(respTimeout, q.remote, neighboursTimeout) 802 q.remote.pendingNeighbours = q 803 return true 804 } 805 // If the node is not known yet, it won't accept queries. 806 // Initiate the transition to known. 807 // The request will be sent later when the node reaches known state. 808 if q.remote.state == unknown { 809 net.transition(q.remote, verifyinit) 810 } 811 return false 812 } 813 814 // Node Events (the input to the state machine). 815 816 type nodeEvent uint 817 818 //go:generate stringer -type=nodeEvent 819 820 const ( 821 invalidEvent nodeEvent = iota // zero is reserved 822 823 // Packet type events. 824 // These correspond to packet types in the UDP protocol. 825 pingPacket 826 pongPacket 827 findnodePacket 828 neighborsPacket 829 findnodeHashPacket 830 topicRegisterPacket 831 topicQueryPacket 832 topicNodesPacket 833 834 // Non-packet events. 835 // Event values in this category are allocated outside 836 // the packet type range (packet types are encoded as a single byte). 837 pongTimeout nodeEvent = iota + 256 838 pingTimeout 839 neighboursTimeout 840 ) 841 842 // Node State Machine. 843 844 type nodeState struct { 845 name string 846 handle func(*Network, *Node, nodeEvent, *ingressPacket) (next *nodeState, err error) 847 enter func(*Network, *Node) 848 canQuery bool 849 } 850 851 func (s *nodeState) String() string { 852 return s.name 853 } 854 855 var ( 856 unknown *nodeState 857 verifyinit *nodeState 858 verifywait *nodeState 859 remoteverifywait *nodeState 860 known *nodeState 861 contested *nodeState 862 unresponsive *nodeState 863 ) 864 865 func init() { 866 unknown = &nodeState{ 867 name: "unknown", 868 enter: func(net *Network, n *Node) { 869 net.tab.delete(n) 870 n.pingEcho = nil 871 // Abort active queries. 872 for _, q := range n.deferredQueries { 873 q.reply <- nil 874 } 875 n.deferredQueries = nil 876 if n.pendingNeighbours != nil { 877 n.pendingNeighbours.reply <- nil 878 n.pendingNeighbours = nil 879 } 880 n.queryTimeouts = 0 881 }, 882 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 883 switch ev { 884 case pingPacket: 885 net.handlePing(n, pkt) 886 net.ping(n, pkt.remoteAddr) 887 return verifywait, nil 888 default: 889 return unknown, errInvalidEvent 890 } 891 }, 892 } 893 894 verifyinit = &nodeState{ 895 name: "verifyinit", 896 enter: func(net *Network, n *Node) { 897 net.ping(n, n.addr()) 898 }, 899 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 900 switch ev { 901 case pingPacket: 902 net.handlePing(n, pkt) 903 return verifywait, nil 904 case pongPacket: 905 err := net.handleKnownPong(n, pkt) 906 return remoteverifywait, err 907 case pongTimeout: 908 return unknown, nil 909 default: 910 return verifyinit, errInvalidEvent 911 } 912 }, 913 } 914 915 verifywait = &nodeState{ 916 name: "verifywait", 917 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 918 switch ev { 919 case pingPacket: 920 net.handlePing(n, pkt) 921 return verifywait, nil 922 case pongPacket: 923 err := net.handleKnownPong(n, pkt) 924 return known, err 925 case pongTimeout: 926 return unknown, nil 927 default: 928 return verifywait, errInvalidEvent 929 } 930 }, 931 } 932 933 remoteverifywait = &nodeState{ 934 name: "remoteverifywait", 935 enter: func(net *Network, n *Node) { 936 net.timedEvent(respTimeout, n, pingTimeout) 937 }, 938 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 939 switch ev { 940 case pingPacket: 941 net.handlePing(n, pkt) 942 return remoteverifywait, nil 943 case pingTimeout: 944 return known, nil 945 default: 946 return remoteverifywait, errInvalidEvent 947 } 948 }, 949 } 950 951 known = &nodeState{ 952 name: "known", 953 canQuery: true, 954 enter: func(net *Network, n *Node) { 955 n.queryTimeouts = 0 956 n.startNextQuery(net) 957 // Insert into the table and start revalidation of the last node 958 // in the bucket if it is full. 959 last := net.tab.add(n) 960 if last != nil && last.state == known { 961 // TODO: do this asynchronously 962 net.transition(last, contested) 963 } 964 }, 965 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 966 switch ev { 967 case pingPacket: 968 net.handlePing(n, pkt) 969 return known, nil 970 case pongPacket: 971 err := net.handleKnownPong(n, pkt) 972 return known, err 973 default: 974 return net.handleQueryEvent(n, ev, pkt) 975 } 976 }, 977 } 978 979 contested = &nodeState{ 980 name: "contested", 981 canQuery: true, 982 enter: func(net *Network, n *Node) { 983 net.ping(n, n.addr()) 984 }, 985 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 986 switch ev { 987 case pongPacket: 988 // Node is still alive. 989 err := net.handleKnownPong(n, pkt) 990 return known, err 991 case pongTimeout: 992 net.tab.deleteReplace(n) 993 return unresponsive, nil 994 case pingPacket: 995 net.handlePing(n, pkt) 996 return contested, nil 997 default: 998 return net.handleQueryEvent(n, ev, pkt) 999 } 1000 }, 1001 } 1002 1003 unresponsive = &nodeState{ 1004 name: "unresponsive", 1005 canQuery: true, 1006 handle: func(net *Network, n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 1007 switch ev { 1008 case pingPacket: 1009 net.handlePing(n, pkt) 1010 return known, nil 1011 case pongPacket: 1012 err := net.handleKnownPong(n, pkt) 1013 return known, err 1014 default: 1015 return net.handleQueryEvent(n, ev, pkt) 1016 } 1017 }, 1018 } 1019 } 1020 1021 // handle processes packets sent by n and events related to n. 1022 func (net *Network) handle(n *Node, ev nodeEvent, pkt *ingressPacket) error { 1023 //fmt.Println("handle", n.addr().String(), n.state, ev) 1024 if pkt != nil { 1025 if err := net.checkPacket(n, ev, pkt); err != nil { 1026 //fmt.Println("check err:", err) 1027 return err 1028 } 1029 // Start the background expiration goroutine after the first 1030 // successful communication. Subsequent calls have no effect if it 1031 // is already running. We do this here instead of somewhere else 1032 // so that the search for seed nodes also considers older nodes 1033 // that would otherwise be removed by the expirer. 1034 if net.db != nil { 1035 net.db.ensureExpirer() 1036 } 1037 } 1038 if n.state == nil { 1039 n.state = unknown //??? 1040 } 1041 next, err := n.state.handle(net, n, ev, pkt) 1042 net.transition(n, next) 1043 //fmt.Println("new state:", n.state) 1044 return err 1045 } 1046 1047 func (net *Network) checkPacket(n *Node, ev nodeEvent, pkt *ingressPacket) error { 1048 // Replay prevention checks. 1049 switch ev { 1050 case pingPacket, findnodeHashPacket, neighborsPacket: 1051 // TODO: check date is > last date seen 1052 // TODO: check ping version 1053 case pongPacket: 1054 if !bytes.Equal(pkt.data.(*pong).ReplyTok, n.pingEcho) { 1055 // fmt.Println("pong reply token mismatch") 1056 return fmt.Errorf("pong reply token mismatch") 1057 } 1058 n.pingEcho = nil 1059 } 1060 // Address validation. 1061 // TODO: Ideally we would do the following: 1062 // - reject all packets with wrong address except ping. 1063 // - for ping with new address, transition to verifywait but keep the 1064 // previous node (with old address) around. if the new one reaches known, 1065 // swap it out. 1066 return nil 1067 } 1068 1069 func (net *Network) transition(n *Node, next *nodeState) { 1070 if n.state != next { 1071 n.state = next 1072 if next.enter != nil { 1073 next.enter(net, n) 1074 } 1075 } 1076 1077 // TODO: persist/unpersist node 1078 } 1079 1080 func (net *Network) timedEvent(d time.Duration, n *Node, ev nodeEvent) { 1081 timeout := timeoutEvent{ev, n} 1082 net.timeoutTimers[timeout] = time.AfterFunc(d, func() { 1083 select { 1084 case net.timeout <- timeout: 1085 case <-net.closed: 1086 } 1087 }) 1088 } 1089 1090 func (net *Network) abortTimedEvent(n *Node, ev nodeEvent) { 1091 timer := net.timeoutTimers[timeoutEvent{ev, n}] 1092 if timer != nil { 1093 timer.Stop() 1094 delete(net.timeoutTimers, timeoutEvent{ev, n}) 1095 } 1096 } 1097 1098 func (net *Network) ping(n *Node, addr *net.UDPAddr) { 1099 //fmt.Println("ping", n.addr().String(), n.ID.String(), n.sha.Hex()) 1100 if n.pingEcho != nil || n.ID == net.tab.self.ID { 1101 //fmt.Println(" not sent") 1102 return 1103 } 1104 log.Trace("Pinging remote node", "node", n.ID) 1105 n.pingTopics = net.ticketStore.regTopicSet() 1106 n.pingEcho = net.conn.sendPing(n, addr, n.pingTopics) 1107 net.timedEvent(respTimeout, n, pongTimeout) 1108 } 1109 1110 func (net *Network) handlePing(n *Node, pkt *ingressPacket) { 1111 log.Trace("Handling remote ping", "node", n.ID) 1112 ping := pkt.data.(*ping) 1113 n.TCP = ping.From.TCP 1114 t := net.topictab.getTicket(n, ping.Topics) 1115 1116 pong := &pong{ 1117 To: makeEndpoint(n.addr(), n.TCP), // TODO: maybe use known TCP port from DB 1118 ReplyTok: pkt.hash, 1119 Expiration: uint64(time.Now().Add(expiration).Unix()), 1120 } 1121 ticketToPong(t, pong) 1122 net.conn.send(n, pongPacket, pong) 1123 } 1124 1125 func (net *Network) handleKnownPong(n *Node, pkt *ingressPacket) error { 1126 log.Trace("Handling known pong", "node", n.ID) 1127 net.abortTimedEvent(n, pongTimeout) 1128 now := mclock.Now() 1129 ticket, err := pongToTicket(now, n.pingTopics, n, pkt) 1130 if err == nil { 1131 // fmt.Printf("(%x) ticket: %+v\n", net.tab.self.ID[:8], pkt.data) 1132 net.ticketStore.addTicket(now, pkt.data.(*pong).ReplyTok, ticket) 1133 } else { 1134 log.Trace("Failed to convert pong to ticket", "err", err) 1135 } 1136 n.pingEcho = nil 1137 n.pingTopics = nil 1138 return err 1139 } 1140 1141 func (net *Network) handleQueryEvent(n *Node, ev nodeEvent, pkt *ingressPacket) (*nodeState, error) { 1142 switch ev { 1143 case findnodePacket: 1144 target := crypto.Keccak256Hash(pkt.data.(*findnode).Target[:]) 1145 results := net.tab.closest(target, bucketSize).entries 1146 net.conn.sendNeighbours(n, results) 1147 return n.state, nil 1148 case neighborsPacket: 1149 err := net.handleNeighboursPacket(n, pkt) 1150 return n.state, err 1151 case neighboursTimeout: 1152 if n.pendingNeighbours != nil { 1153 n.pendingNeighbours.reply <- nil 1154 n.pendingNeighbours = nil 1155 } 1156 n.queryTimeouts++ 1157 if n.queryTimeouts > maxFindnodeFailures && n.state == known { 1158 return contested, errors.New("too many timeouts") 1159 } 1160 return n.state, nil 1161 1162 // v5 1163 1164 case findnodeHashPacket: 1165 results := net.tab.closest(pkt.data.(*findnodeHash).Target, bucketSize).entries 1166 net.conn.sendNeighbours(n, results) 1167 return n.state, nil 1168 case topicRegisterPacket: 1169 //fmt.Println("got topicRegisterPacket") 1170 regdata := pkt.data.(*topicRegister) 1171 pong, err := net.checkTopicRegister(regdata) 1172 if err != nil { 1173 //fmt.Println(err) 1174 return n.state, fmt.Errorf("bad waiting ticket: %v", err) 1175 } 1176 net.topictab.useTicket(n, pong.TicketSerial, regdata.Topics, int(regdata.Idx), pong.Expiration, pong.WaitPeriods) 1177 return n.state, nil 1178 case topicQueryPacket: 1179 // TODO: handle expiration 1180 topic := pkt.data.(*topicQuery).Topic 1181 results := net.topictab.getEntries(topic) 1182 if _, ok := net.ticketStore.tickets[topic]; ok { 1183 results = append(results, net.tab.self) // we're not registering in our own table but if we're advertising, return ourselves too 1184 } 1185 if len(results) > 10 { 1186 results = results[:10] 1187 } 1188 var hash common.Hash 1189 copy(hash[:], pkt.hash) 1190 net.conn.sendTopicNodes(n, hash, results) 1191 return n.state, nil 1192 case topicNodesPacket: 1193 p := pkt.data.(*topicNodes) 1194 if net.ticketStore.gotTopicNodes(n, p.Echo, p.Nodes) { 1195 n.queryTimeouts++ 1196 if n.queryTimeouts > maxFindnodeFailures && n.state == known { 1197 return contested, errors.New("too many timeouts") 1198 } 1199 } 1200 return n.state, nil 1201 1202 default: 1203 return n.state, errInvalidEvent 1204 } 1205 } 1206 1207 func (net *Network) checkTopicRegister(data *topicRegister) (*pong, error) { 1208 var pongpkt ingressPacket 1209 if err := decodePacket(data.Pong, &pongpkt); err != nil { 1210 return nil, err 1211 } 1212 if pongpkt.ev != pongPacket { 1213 return nil, errors.New("is not pong packet") 1214 } 1215 if pongpkt.remoteID != net.tab.self.ID { 1216 return nil, errors.New("not signed by us") 1217 } 1218 // check that we previously authorised all topics 1219 // that the other side is trying to register. 1220 if rlpHash(data.Topics) != pongpkt.data.(*pong).TopicHash { 1221 return nil, errors.New("topic hash mismatch") 1222 } 1223 if data.Idx < 0 || int(data.Idx) >= len(data.Topics) { 1224 return nil, errors.New("topic index out of range") 1225 } 1226 return pongpkt.data.(*pong), nil 1227 } 1228 1229 func rlpHash(x interface{}) (h common.Hash) { 1230 hw := sha3.NewKeccak256() 1231 rlp.Encode(hw, x) 1232 hw.Sum(h[:0]) 1233 return h 1234 } 1235 1236 func (net *Network) handleNeighboursPacket(n *Node, pkt *ingressPacket) error { 1237 if n.pendingNeighbours == nil { 1238 return errNoQuery 1239 } 1240 net.abortTimedEvent(n, neighboursTimeout) 1241 1242 req := pkt.data.(*neighbors) 1243 nodes := make([]*Node, len(req.Nodes)) 1244 for i, rn := range req.Nodes { 1245 nn, err := net.internNodeFromNeighbours(pkt.remoteAddr, rn) 1246 if err != nil { 1247 log.Debug(fmt.Sprintf("invalid neighbour (%v) from %x@%v: %v", rn.IP, n.ID[:8], pkt.remoteAddr, err)) 1248 continue 1249 } 1250 nodes[i] = nn 1251 // Start validation of query results immediately. 1252 // This fills the table quickly. 1253 // TODO: generates way too many packets, maybe do it via queue. 1254 if nn.state == unknown { 1255 net.transition(nn, verifyinit) 1256 } 1257 } 1258 // TODO: don't ignore second packet 1259 n.pendingNeighbours.reply <- nodes 1260 n.pendingNeighbours = nil 1261 // Now that this query is done, start the next one. 1262 n.startNextQuery(net) 1263 return nil 1264 }