github.com/bamzi/go-ethereum@v1.6.7-0.20170704111104-138f26c93af1/les/handler.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 les implements the Light Ethereum Subprotocol. 18 package les 19 20 import ( 21 "encoding/binary" 22 "errors" 23 "fmt" 24 "math/big" 25 "net" 26 "sync" 27 "time" 28 29 "github.com/ethereum/go-ethereum/common" 30 "github.com/ethereum/go-ethereum/consensus" 31 "github.com/ethereum/go-ethereum/core" 32 "github.com/ethereum/go-ethereum/core/state" 33 "github.com/ethereum/go-ethereum/core/types" 34 "github.com/ethereum/go-ethereum/eth" 35 "github.com/ethereum/go-ethereum/eth/downloader" 36 "github.com/ethereum/go-ethereum/ethdb" 37 "github.com/ethereum/go-ethereum/event" 38 "github.com/ethereum/go-ethereum/log" 39 "github.com/ethereum/go-ethereum/p2p" 40 "github.com/ethereum/go-ethereum/p2p/discover" 41 "github.com/ethereum/go-ethereum/p2p/discv5" 42 "github.com/ethereum/go-ethereum/params" 43 "github.com/ethereum/go-ethereum/rlp" 44 "github.com/ethereum/go-ethereum/trie" 45 ) 46 47 const ( 48 softResponseLimit = 2 * 1024 * 1024 // Target maximum size of returned blocks, headers or node data. 49 estHeaderRlpSize = 500 // Approximate size of an RLP encoded block header 50 51 ethVersion = 63 // equivalent eth version for the downloader 52 53 MaxHeaderFetch = 192 // Amount of block headers to be fetched per retrieval request 54 MaxBodyFetch = 32 // Amount of block bodies to be fetched per retrieval request 55 MaxReceiptFetch = 128 // Amount of transaction receipts to allow fetching per request 56 MaxCodeFetch = 64 // Amount of contract codes to allow fetching per request 57 MaxProofsFetch = 64 // Amount of merkle proofs to be fetched per retrieval request 58 MaxHeaderProofsFetch = 64 // Amount of merkle proofs to be fetched per retrieval request 59 MaxTxSend = 64 // Amount of transactions to be send per request 60 61 disableClientRemovePeer = false 62 ) 63 64 // errIncompatibleConfig is returned if the requested protocols and configs are 65 // not compatible (low protocol version restrictions and high requirements). 66 var errIncompatibleConfig = errors.New("incompatible configuration") 67 68 func errResp(code errCode, format string, v ...interface{}) error { 69 return fmt.Errorf("%v - %v", code, fmt.Sprintf(format, v...)) 70 } 71 72 type hashFetcherFn func(common.Hash) error 73 74 type BlockChain interface { 75 HasHeader(hash common.Hash) bool 76 GetHeader(hash common.Hash, number uint64) *types.Header 77 GetHeaderByHash(hash common.Hash) *types.Header 78 CurrentHeader() *types.Header 79 GetTdByHash(hash common.Hash) *big.Int 80 InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) 81 Rollback(chain []common.Hash) 82 Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash) 83 GetHeaderByNumber(number uint64) *types.Header 84 GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash 85 LastBlockHash() common.Hash 86 Genesis() *types.Block 87 } 88 89 type txPool interface { 90 // AddTransactions should add the given transactions to the pool. 91 AddBatch([]*types.Transaction) error 92 } 93 94 type ProtocolManager struct { 95 lightSync bool 96 txpool txPool 97 txrelay *LesTxRelay 98 networkId uint64 99 chainConfig *params.ChainConfig 100 blockchain BlockChain 101 chainDb ethdb.Database 102 odr *LesOdr 103 server *LesServer 104 serverPool *serverPool 105 lesTopic discv5.Topic 106 reqDist *requestDistributor 107 retriever *retrieveManager 108 109 downloader *downloader.Downloader 110 fetcher *lightFetcher 111 peers *peerSet 112 113 SubProtocols []p2p.Protocol 114 115 eventMux *event.TypeMux 116 117 // channels for fetcher, syncer, txsyncLoop 118 newPeerCh chan *peer 119 quitSync chan struct{} 120 noMorePeers chan struct{} 121 122 syncMu sync.Mutex 123 syncing bool 124 syncDone chan struct{} 125 126 // wait group is used for graceful shutdowns during downloading 127 // and processing 128 wg *sync.WaitGroup 129 } 130 131 // NewProtocolManager returns a new ethereum sub protocol manager. The Ethereum sub protocol manages peers capable 132 // with the ethereum network. 133 func NewProtocolManager(chainConfig *params.ChainConfig, lightSync bool, networkId uint64, mux *event.TypeMux, engine consensus.Engine, peers *peerSet, blockchain BlockChain, txpool txPool, chainDb ethdb.Database, odr *LesOdr, txrelay *LesTxRelay, quitSync chan struct{}, wg *sync.WaitGroup) (*ProtocolManager, error) { 134 // Create the protocol manager with the base fields 135 manager := &ProtocolManager{ 136 lightSync: lightSync, 137 eventMux: mux, 138 blockchain: blockchain, 139 chainConfig: chainConfig, 140 chainDb: chainDb, 141 odr: odr, 142 networkId: networkId, 143 txpool: txpool, 144 txrelay: txrelay, 145 peers: peers, 146 newPeerCh: make(chan *peer), 147 quitSync: quitSync, 148 wg: wg, 149 noMorePeers: make(chan struct{}), 150 } 151 if odr != nil { 152 manager.retriever = odr.retriever 153 manager.reqDist = odr.retriever.dist 154 } 155 // Initiate a sub-protocol for every implemented version we can handle 156 manager.SubProtocols = make([]p2p.Protocol, 0, len(ProtocolVersions)) 157 for i, version := range ProtocolVersions { 158 // Compatible, initialize the sub-protocol 159 version := version // Closure for the run 160 manager.SubProtocols = append(manager.SubProtocols, p2p.Protocol{ 161 Name: "les", 162 Version: version, 163 Length: ProtocolLengths[i], 164 Run: func(p *p2p.Peer, rw p2p.MsgReadWriter) error { 165 var entry *poolEntry 166 peer := manager.newPeer(int(version), networkId, p, rw) 167 if manager.serverPool != nil { 168 addr := p.RemoteAddr().(*net.TCPAddr) 169 entry = manager.serverPool.connect(peer, addr.IP, uint16(addr.Port)) 170 } 171 peer.poolEntry = entry 172 select { 173 case manager.newPeerCh <- peer: 174 manager.wg.Add(1) 175 defer manager.wg.Done() 176 err := manager.handle(peer) 177 if entry != nil { 178 manager.serverPool.disconnect(entry) 179 } 180 return err 181 case <-manager.quitSync: 182 if entry != nil { 183 manager.serverPool.disconnect(entry) 184 } 185 return p2p.DiscQuitting 186 } 187 }, 188 NodeInfo: func() interface{} { 189 return manager.NodeInfo() 190 }, 191 PeerInfo: func(id discover.NodeID) interface{} { 192 if p := manager.peers.Peer(fmt.Sprintf("%x", id[:8])); p != nil { 193 return p.Info() 194 } 195 return nil 196 }, 197 }) 198 } 199 if len(manager.SubProtocols) == 0 { 200 return nil, errIncompatibleConfig 201 } 202 203 removePeer := manager.removePeer 204 if disableClientRemovePeer { 205 removePeer = func(id string) {} 206 } 207 208 if lightSync { 209 manager.downloader = downloader.New(downloader.LightSync, chainDb, manager.eventMux, blockchain.HasHeader, nil, blockchain.GetHeaderByHash, 210 nil, blockchain.CurrentHeader, nil, nil, nil, blockchain.GetTdByHash, 211 blockchain.InsertHeaderChain, nil, nil, blockchain.Rollback, removePeer) 212 manager.peers.notify((*downloaderPeerNotify)(manager)) 213 manager.fetcher = newLightFetcher(manager) 214 } 215 216 return manager, nil 217 } 218 219 // removePeer initiates disconnection from a peer by removing it from the peer set 220 func (pm *ProtocolManager) removePeer(id string) { 221 pm.peers.Unregister(id) 222 } 223 224 func (pm *ProtocolManager) Start() { 225 if pm.lightSync { 226 go pm.syncer() 227 } else { 228 go func() { 229 for range pm.newPeerCh { 230 } 231 }() 232 } 233 } 234 235 func (pm *ProtocolManager) Stop() { 236 // Showing a log message. During download / process this could actually 237 // take between 5 to 10 seconds and therefor feedback is required. 238 log.Info("Stopping light Ethereum protocol") 239 240 // Quit the sync loop. 241 // After this send has completed, no new peers will be accepted. 242 pm.noMorePeers <- struct{}{} 243 244 close(pm.quitSync) // quits syncer, fetcher 245 246 // Disconnect existing sessions. 247 // This also closes the gate for any new registrations on the peer set. 248 // sessions which are already established but not added to pm.peers yet 249 // will exit when they try to register. 250 pm.peers.Close() 251 252 // Wait for any process action 253 pm.wg.Wait() 254 255 log.Info("Light Ethereum protocol stopped") 256 } 257 258 func (pm *ProtocolManager) newPeer(pv int, nv uint64, p *p2p.Peer, rw p2p.MsgReadWriter) *peer { 259 return newPeer(pv, nv, p, newMeteredMsgWriter(rw)) 260 } 261 262 // handle is the callback invoked to manage the life cycle of a les peer. When 263 // this function terminates, the peer is disconnected. 264 func (pm *ProtocolManager) handle(p *peer) error { 265 p.Log().Debug("Light Ethereum peer connected", "name", p.Name()) 266 267 // Execute the LES handshake 268 td, head, genesis := pm.blockchain.Status() 269 headNum := core.GetBlockNumber(pm.chainDb, head) 270 if err := p.Handshake(td, head, headNum, genesis, pm.server); err != nil { 271 p.Log().Debug("Light Ethereum handshake failed", "err", err) 272 return err 273 } 274 if rw, ok := p.rw.(*meteredMsgReadWriter); ok { 275 rw.Init(p.version) 276 } 277 // Register the peer locally 278 if err := pm.peers.Register(p); err != nil { 279 p.Log().Error("Light Ethereum peer registration failed", "err", err) 280 return err 281 } 282 defer func() { 283 if pm.server != nil && pm.server.fcManager != nil && p.fcClient != nil { 284 p.fcClient.Remove(pm.server.fcManager) 285 } 286 pm.removePeer(p.id) 287 }() 288 // Register the peer in the downloader. If the downloader considers it banned, we disconnect 289 if pm.lightSync { 290 p.lock.Lock() 291 head := p.headInfo 292 p.lock.Unlock() 293 if pm.fetcher != nil { 294 pm.fetcher.announce(p, head) 295 } 296 297 if p.poolEntry != nil { 298 pm.serverPool.registered(p.poolEntry) 299 } 300 } 301 302 stop := make(chan struct{}) 303 defer close(stop) 304 go func() { 305 // new block announce loop 306 for { 307 select { 308 case announce := <-p.announceChn: 309 p.SendAnnounce(announce) 310 case <-stop: 311 return 312 } 313 } 314 }() 315 316 // main loop. handle incoming messages. 317 for { 318 if err := pm.handleMsg(p); err != nil { 319 p.Log().Debug("Light Ethereum message handling failed", "err", err) 320 return err 321 } 322 } 323 } 324 325 var reqList = []uint64{GetBlockHeadersMsg, GetBlockBodiesMsg, GetCodeMsg, GetReceiptsMsg, GetProofsMsg, SendTxMsg, GetHeaderProofsMsg} 326 327 // handleMsg is invoked whenever an inbound message is received from a remote 328 // peer. The remote connection is torn down upon returning any error. 329 func (pm *ProtocolManager) handleMsg(p *peer) error { 330 // Read the next message from the remote peer, and ensure it's fully consumed 331 msg, err := p.rw.ReadMsg() 332 if err != nil { 333 return err 334 } 335 p.Log().Trace("Light Ethereum message arrived", "code", msg.Code, "bytes", msg.Size) 336 337 costs := p.fcCosts[msg.Code] 338 reject := func(reqCnt, maxCnt uint64) bool { 339 if p.fcClient == nil || reqCnt > maxCnt { 340 return true 341 } 342 bufValue, _ := p.fcClient.AcceptRequest() 343 cost := costs.baseCost + reqCnt*costs.reqCost 344 if cost > pm.server.defParams.BufLimit { 345 cost = pm.server.defParams.BufLimit 346 } 347 if cost > bufValue { 348 recharge := time.Duration((cost - bufValue) * 1000000 / pm.server.defParams.MinRecharge) 349 p.Log().Error("Request came too early", "recharge", common.PrettyDuration(recharge)) 350 return true 351 } 352 return false 353 } 354 355 if msg.Size > ProtocolMaxMsgSize { 356 return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize) 357 } 358 defer msg.Discard() 359 360 var deliverMsg *Msg 361 362 // Handle the message depending on its contents 363 switch msg.Code { 364 case StatusMsg: 365 p.Log().Trace("Received status message") 366 // Status messages should never arrive after the handshake 367 return errResp(ErrExtraStatusMsg, "uncontrolled status message") 368 369 // Block header query, collect the requested headers and reply 370 case AnnounceMsg: 371 p.Log().Trace("Received announce message") 372 373 var req announceData 374 if err := msg.Decode(&req); err != nil { 375 return errResp(ErrDecode, "%v: %v", msg, err) 376 } 377 p.Log().Trace("Announce message content", "number", req.Number, "hash", req.Hash, "td", req.Td, "reorg", req.ReorgDepth) 378 if pm.fetcher != nil { 379 pm.fetcher.announce(p, &req) 380 } 381 382 case GetBlockHeadersMsg: 383 p.Log().Trace("Received block header request") 384 // Decode the complex header query 385 var req struct { 386 ReqID uint64 387 Query getBlockHeadersData 388 } 389 if err := msg.Decode(&req); err != nil { 390 return errResp(ErrDecode, "%v: %v", msg, err) 391 } 392 393 query := req.Query 394 if reject(query.Amount, MaxHeaderFetch) { 395 return errResp(ErrRequestRejected, "") 396 } 397 398 hashMode := query.Origin.Hash != (common.Hash{}) 399 400 // Gather headers until the fetch or network limits is reached 401 var ( 402 bytes common.StorageSize 403 headers []*types.Header 404 unknown bool 405 ) 406 for !unknown && len(headers) < int(query.Amount) && bytes < softResponseLimit { 407 // Retrieve the next header satisfying the query 408 var origin *types.Header 409 if hashMode { 410 origin = pm.blockchain.GetHeaderByHash(query.Origin.Hash) 411 } else { 412 origin = pm.blockchain.GetHeaderByNumber(query.Origin.Number) 413 } 414 if origin == nil { 415 break 416 } 417 number := origin.Number.Uint64() 418 headers = append(headers, origin) 419 bytes += estHeaderRlpSize 420 421 // Advance to the next header of the query 422 switch { 423 case query.Origin.Hash != (common.Hash{}) && query.Reverse: 424 // Hash based traversal towards the genesis block 425 for i := 0; i < int(query.Skip)+1; i++ { 426 if header := pm.blockchain.GetHeader(query.Origin.Hash, number); header != nil { 427 query.Origin.Hash = header.ParentHash 428 number-- 429 } else { 430 unknown = true 431 break 432 } 433 } 434 case query.Origin.Hash != (common.Hash{}) && !query.Reverse: 435 // Hash based traversal towards the leaf block 436 if header := pm.blockchain.GetHeaderByNumber(origin.Number.Uint64() + query.Skip + 1); header != nil { 437 if pm.blockchain.GetBlockHashesFromHash(header.Hash(), query.Skip+1)[query.Skip] == query.Origin.Hash { 438 query.Origin.Hash = header.Hash() 439 } else { 440 unknown = true 441 } 442 } else { 443 unknown = true 444 } 445 case query.Reverse: 446 // Number based traversal towards the genesis block 447 if query.Origin.Number >= query.Skip+1 { 448 query.Origin.Number -= (query.Skip + 1) 449 } else { 450 unknown = true 451 } 452 453 case !query.Reverse: 454 // Number based traversal towards the leaf block 455 query.Origin.Number += (query.Skip + 1) 456 } 457 } 458 459 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + query.Amount*costs.reqCost) 460 pm.server.fcCostStats.update(msg.Code, query.Amount, rcost) 461 return p.SendBlockHeaders(req.ReqID, bv, headers) 462 463 case BlockHeadersMsg: 464 if pm.downloader == nil { 465 return errResp(ErrUnexpectedResponse, "") 466 } 467 468 p.Log().Trace("Received block header response message") 469 // A batch of headers arrived to one of our previous requests 470 var resp struct { 471 ReqID, BV uint64 472 Headers []*types.Header 473 } 474 if err := msg.Decode(&resp); err != nil { 475 return errResp(ErrDecode, "msg %v: %v", msg, err) 476 } 477 p.fcServer.GotReply(resp.ReqID, resp.BV) 478 if pm.fetcher != nil && pm.fetcher.requestedID(resp.ReqID) { 479 pm.fetcher.deliverHeaders(p, resp.ReqID, resp.Headers) 480 } else { 481 err := pm.downloader.DeliverHeaders(p.id, resp.Headers) 482 if err != nil { 483 log.Debug(fmt.Sprint(err)) 484 } 485 } 486 487 case GetBlockBodiesMsg: 488 p.Log().Trace("Received block bodies request") 489 // Decode the retrieval message 490 var req struct { 491 ReqID uint64 492 Hashes []common.Hash 493 } 494 if err := msg.Decode(&req); err != nil { 495 return errResp(ErrDecode, "msg %v: %v", msg, err) 496 } 497 // Gather blocks until the fetch or network limits is reached 498 var ( 499 bytes int 500 bodies []rlp.RawValue 501 ) 502 reqCnt := len(req.Hashes) 503 if reject(uint64(reqCnt), MaxBodyFetch) { 504 return errResp(ErrRequestRejected, "") 505 } 506 for _, hash := range req.Hashes { 507 if bytes >= softResponseLimit { 508 break 509 } 510 // Retrieve the requested block body, stopping if enough was found 511 if data := core.GetBodyRLP(pm.chainDb, hash, core.GetBlockNumber(pm.chainDb, hash)); len(data) != 0 { 512 bodies = append(bodies, data) 513 bytes += len(data) 514 } 515 } 516 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 517 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 518 return p.SendBlockBodiesRLP(req.ReqID, bv, bodies) 519 520 case BlockBodiesMsg: 521 if pm.odr == nil { 522 return errResp(ErrUnexpectedResponse, "") 523 } 524 525 p.Log().Trace("Received block bodies response") 526 // A batch of block bodies arrived to one of our previous requests 527 var resp struct { 528 ReqID, BV uint64 529 Data []*types.Body 530 } 531 if err := msg.Decode(&resp); err != nil { 532 return errResp(ErrDecode, "msg %v: %v", msg, err) 533 } 534 p.fcServer.GotReply(resp.ReqID, resp.BV) 535 deliverMsg = &Msg{ 536 MsgType: MsgBlockBodies, 537 ReqID: resp.ReqID, 538 Obj: resp.Data, 539 } 540 541 case GetCodeMsg: 542 p.Log().Trace("Received code request") 543 // Decode the retrieval message 544 var req struct { 545 ReqID uint64 546 Reqs []CodeReq 547 } 548 if err := msg.Decode(&req); err != nil { 549 return errResp(ErrDecode, "msg %v: %v", msg, err) 550 } 551 // Gather state data until the fetch or network limits is reached 552 var ( 553 bytes int 554 data [][]byte 555 ) 556 reqCnt := len(req.Reqs) 557 if reject(uint64(reqCnt), MaxCodeFetch) { 558 return errResp(ErrRequestRejected, "") 559 } 560 for _, req := range req.Reqs { 561 // Retrieve the requested state entry, stopping if enough was found 562 if header := core.GetHeader(pm.chainDb, req.BHash, core.GetBlockNumber(pm.chainDb, req.BHash)); header != nil { 563 if trie, _ := trie.New(header.Root, pm.chainDb); trie != nil { 564 sdata := trie.Get(req.AccKey) 565 var acc state.Account 566 if err := rlp.DecodeBytes(sdata, &acc); err == nil { 567 entry, _ := pm.chainDb.Get(acc.CodeHash) 568 if bytes+len(entry) >= softResponseLimit { 569 break 570 } 571 data = append(data, entry) 572 bytes += len(entry) 573 } 574 } 575 } 576 } 577 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 578 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 579 return p.SendCode(req.ReqID, bv, data) 580 581 case CodeMsg: 582 if pm.odr == nil { 583 return errResp(ErrUnexpectedResponse, "") 584 } 585 586 p.Log().Trace("Received code response") 587 // A batch of node state data arrived to one of our previous requests 588 var resp struct { 589 ReqID, BV uint64 590 Data [][]byte 591 } 592 if err := msg.Decode(&resp); err != nil { 593 return errResp(ErrDecode, "msg %v: %v", msg, err) 594 } 595 p.fcServer.GotReply(resp.ReqID, resp.BV) 596 deliverMsg = &Msg{ 597 MsgType: MsgCode, 598 ReqID: resp.ReqID, 599 Obj: resp.Data, 600 } 601 602 case GetReceiptsMsg: 603 p.Log().Trace("Received receipts request") 604 // Decode the retrieval message 605 var req struct { 606 ReqID uint64 607 Hashes []common.Hash 608 } 609 if err := msg.Decode(&req); err != nil { 610 return errResp(ErrDecode, "msg %v: %v", msg, err) 611 } 612 // Gather state data until the fetch or network limits is reached 613 var ( 614 bytes int 615 receipts []rlp.RawValue 616 ) 617 reqCnt := len(req.Hashes) 618 if reject(uint64(reqCnt), MaxReceiptFetch) { 619 return errResp(ErrRequestRejected, "") 620 } 621 for _, hash := range req.Hashes { 622 if bytes >= softResponseLimit { 623 break 624 } 625 // Retrieve the requested block's receipts, skipping if unknown to us 626 results := core.GetBlockReceipts(pm.chainDb, hash, core.GetBlockNumber(pm.chainDb, hash)) 627 if results == nil { 628 if header := pm.blockchain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash { 629 continue 630 } 631 } 632 // If known, encode and queue for response packet 633 if encoded, err := rlp.EncodeToBytes(results); err != nil { 634 log.Error("Failed to encode receipt", "err", err) 635 } else { 636 receipts = append(receipts, encoded) 637 bytes += len(encoded) 638 } 639 } 640 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 641 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 642 return p.SendReceiptsRLP(req.ReqID, bv, receipts) 643 644 case ReceiptsMsg: 645 if pm.odr == nil { 646 return errResp(ErrUnexpectedResponse, "") 647 } 648 649 p.Log().Trace("Received receipts response") 650 // A batch of receipts arrived to one of our previous requests 651 var resp struct { 652 ReqID, BV uint64 653 Receipts []types.Receipts 654 } 655 if err := msg.Decode(&resp); err != nil { 656 return errResp(ErrDecode, "msg %v: %v", msg, err) 657 } 658 p.fcServer.GotReply(resp.ReqID, resp.BV) 659 deliverMsg = &Msg{ 660 MsgType: MsgReceipts, 661 ReqID: resp.ReqID, 662 Obj: resp.Receipts, 663 } 664 665 case GetProofsMsg: 666 p.Log().Trace("Received proofs request") 667 // Decode the retrieval message 668 var req struct { 669 ReqID uint64 670 Reqs []ProofReq 671 } 672 if err := msg.Decode(&req); err != nil { 673 return errResp(ErrDecode, "msg %v: %v", msg, err) 674 } 675 // Gather state data until the fetch or network limits is reached 676 var ( 677 bytes int 678 proofs proofsData 679 ) 680 reqCnt := len(req.Reqs) 681 if reject(uint64(reqCnt), MaxProofsFetch) { 682 return errResp(ErrRequestRejected, "") 683 } 684 for _, req := range req.Reqs { 685 if bytes >= softResponseLimit { 686 break 687 } 688 // Retrieve the requested state entry, stopping if enough was found 689 if header := core.GetHeader(pm.chainDb, req.BHash, core.GetBlockNumber(pm.chainDb, req.BHash)); header != nil { 690 if tr, _ := trie.New(header.Root, pm.chainDb); tr != nil { 691 if len(req.AccKey) > 0 { 692 sdata := tr.Get(req.AccKey) 693 tr = nil 694 var acc state.Account 695 if err := rlp.DecodeBytes(sdata, &acc); err == nil { 696 tr, _ = trie.New(acc.Root, pm.chainDb) 697 } 698 } 699 if tr != nil { 700 proof := tr.Prove(req.Key) 701 proofs = append(proofs, proof) 702 bytes += len(proof) 703 } 704 } 705 } 706 } 707 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 708 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 709 return p.SendProofs(req.ReqID, bv, proofs) 710 711 case ProofsMsg: 712 if pm.odr == nil { 713 return errResp(ErrUnexpectedResponse, "") 714 } 715 716 p.Log().Trace("Received proofs response") 717 // A batch of merkle proofs arrived to one of our previous requests 718 var resp struct { 719 ReqID, BV uint64 720 Data [][]rlp.RawValue 721 } 722 if err := msg.Decode(&resp); err != nil { 723 return errResp(ErrDecode, "msg %v: %v", msg, err) 724 } 725 p.fcServer.GotReply(resp.ReqID, resp.BV) 726 deliverMsg = &Msg{ 727 MsgType: MsgProofs, 728 ReqID: resp.ReqID, 729 Obj: resp.Data, 730 } 731 732 case GetHeaderProofsMsg: 733 p.Log().Trace("Received headers proof request") 734 // Decode the retrieval message 735 var req struct { 736 ReqID uint64 737 Reqs []ChtReq 738 } 739 if err := msg.Decode(&req); err != nil { 740 return errResp(ErrDecode, "msg %v: %v", msg, err) 741 } 742 // Gather state data until the fetch or network limits is reached 743 var ( 744 bytes int 745 proofs []ChtResp 746 ) 747 reqCnt := len(req.Reqs) 748 if reject(uint64(reqCnt), MaxHeaderProofsFetch) { 749 return errResp(ErrRequestRejected, "") 750 } 751 for _, req := range req.Reqs { 752 if bytes >= softResponseLimit { 753 break 754 } 755 756 if header := pm.blockchain.GetHeaderByNumber(req.BlockNum); header != nil { 757 if root := getChtRoot(pm.chainDb, req.ChtNum); root != (common.Hash{}) { 758 if tr, _ := trie.New(root, pm.chainDb); tr != nil { 759 var encNumber [8]byte 760 binary.BigEndian.PutUint64(encNumber[:], req.BlockNum) 761 proof := tr.Prove(encNumber[:]) 762 proofs = append(proofs, ChtResp{Header: header, Proof: proof}) 763 bytes += len(proof) + estHeaderRlpSize 764 } 765 } 766 } 767 } 768 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 769 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 770 return p.SendHeaderProofs(req.ReqID, bv, proofs) 771 772 case HeaderProofsMsg: 773 if pm.odr == nil { 774 return errResp(ErrUnexpectedResponse, "") 775 } 776 777 p.Log().Trace("Received headers proof response") 778 var resp struct { 779 ReqID, BV uint64 780 Data []ChtResp 781 } 782 if err := msg.Decode(&resp); err != nil { 783 return errResp(ErrDecode, "msg %v: %v", msg, err) 784 } 785 p.fcServer.GotReply(resp.ReqID, resp.BV) 786 deliverMsg = &Msg{ 787 MsgType: MsgHeaderProofs, 788 ReqID: resp.ReqID, 789 Obj: resp.Data, 790 } 791 792 case SendTxMsg: 793 if pm.txpool == nil { 794 return errResp(ErrUnexpectedResponse, "") 795 } 796 // Transactions arrived, parse all of them and deliver to the pool 797 var txs []*types.Transaction 798 if err := msg.Decode(&txs); err != nil { 799 return errResp(ErrDecode, "msg %v: %v", msg, err) 800 } 801 reqCnt := len(txs) 802 if reject(uint64(reqCnt), MaxTxSend) { 803 return errResp(ErrRequestRejected, "") 804 } 805 806 if err := pm.txpool.AddBatch(txs); err != nil { 807 return errResp(ErrUnexpectedResponse, "msg: %v", err) 808 } 809 810 _, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 811 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 812 813 default: 814 p.Log().Trace("Received unknown message", "code", msg.Code) 815 return errResp(ErrInvalidMsgCode, "%v", msg.Code) 816 } 817 818 if deliverMsg != nil { 819 err := pm.retriever.deliver(p, deliverMsg) 820 if err != nil { 821 p.responseErrors++ 822 if p.responseErrors > maxResponseErrors { 823 return err 824 } 825 } 826 } 827 return nil 828 } 829 830 // NodeInfo retrieves some protocol metadata about the running host node. 831 func (self *ProtocolManager) NodeInfo() *eth.EthNodeInfo { 832 return ð.EthNodeInfo{ 833 Network: self.networkId, 834 Difficulty: self.blockchain.GetTdByHash(self.blockchain.LastBlockHash()), 835 Genesis: self.blockchain.Genesis().Hash(), 836 Head: self.blockchain.LastBlockHash(), 837 } 838 } 839 840 // downloaderPeerNotify implements peerSetNotify 841 type downloaderPeerNotify ProtocolManager 842 843 func (d *downloaderPeerNotify) registerPeer(p *peer) { 844 pm := (*ProtocolManager)(d) 845 846 requestHeadersByHash := func(origin common.Hash, amount int, skip int, reverse bool) error { 847 reqID := genReqID() 848 rq := &distReq{ 849 getCost: func(dp distPeer) uint64 { 850 peer := dp.(*peer) 851 return peer.GetRequestCost(GetBlockHeadersMsg, amount) 852 }, 853 canSend: func(dp distPeer) bool { 854 return dp.(*peer) == p 855 }, 856 request: func(dp distPeer) func() { 857 peer := dp.(*peer) 858 cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) 859 peer.fcServer.QueueRequest(reqID, cost) 860 return func() { peer.RequestHeadersByHash(reqID, cost, origin, amount, skip, reverse) } 861 }, 862 } 863 _, ok := <-pm.reqDist.queue(rq) 864 if !ok { 865 return ErrNoPeers 866 } 867 return nil 868 } 869 requestHeadersByNumber := func(origin uint64, amount int, skip int, reverse bool) error { 870 reqID := genReqID() 871 rq := &distReq{ 872 getCost: func(dp distPeer) uint64 { 873 peer := dp.(*peer) 874 return peer.GetRequestCost(GetBlockHeadersMsg, amount) 875 }, 876 canSend: func(dp distPeer) bool { 877 return dp.(*peer) == p 878 }, 879 request: func(dp distPeer) func() { 880 peer := dp.(*peer) 881 cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) 882 peer.fcServer.QueueRequest(reqID, cost) 883 return func() { peer.RequestHeadersByNumber(reqID, cost, origin, amount, skip, reverse) } 884 }, 885 } 886 _, ok := <-pm.reqDist.queue(rq) 887 if !ok { 888 return ErrNoPeers 889 } 890 return nil 891 } 892 893 pm.downloader.RegisterPeer(p.id, ethVersion, p.HeadAndTd, requestHeadersByHash, requestHeadersByNumber, nil, nil, nil) 894 } 895 896 func (d *downloaderPeerNotify) unregisterPeer(p *peer) { 897 pm := (*ProtocolManager)(d) 898 pm.downloader.UnregisterPeer(p.id) 899 }