github.com/codingfuture/orig-energi3@v0.8.4/les/handler.go (about) 1 // Copyright 2018 The Energi Core Authors 2 // Copyright 2016 The go-ethereum Authors 3 // This file is part of the Energi Core library. 4 // 5 // The Energi Core library is free software: you can redistribute it and/or modify 6 // it under the terms of the GNU Lesser General Public License as published by 7 // the Free Software Foundation, either version 3 of the License, or 8 // (at your option) any later version. 9 // 10 // The Energi Core library is distributed in the hope that it will be useful, 11 // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 // GNU Lesser General Public License for more details. 14 // 15 // You should have received a copy of the GNU Lesser General Public License 16 // along with the Energi Core library. If not, see <http://www.gnu.org/licenses/>. 17 18 // Package les implements the Light Ethereum Subprotocol. 19 package les 20 21 import ( 22 "encoding/binary" 23 "encoding/json" 24 "fmt" 25 "math/big" 26 "net" 27 "sync" 28 "time" 29 30 "github.com/ethereum/go-ethereum/common" 31 "github.com/ethereum/go-ethereum/common/mclock" 32 "github.com/ethereum/go-ethereum/consensus" 33 "github.com/ethereum/go-ethereum/core" 34 "github.com/ethereum/go-ethereum/core/rawdb" 35 "github.com/ethereum/go-ethereum/core/state" 36 "github.com/ethereum/go-ethereum/core/types" 37 "github.com/ethereum/go-ethereum/eth/downloader" 38 "github.com/ethereum/go-ethereum/ethdb" 39 "github.com/ethereum/go-ethereum/event" 40 "github.com/ethereum/go-ethereum/light" 41 "github.com/ethereum/go-ethereum/log" 42 "github.com/ethereum/go-ethereum/p2p" 43 "github.com/ethereum/go-ethereum/p2p/discv5" 44 "github.com/ethereum/go-ethereum/params" 45 "github.com/ethereum/go-ethereum/rlp" 46 "github.com/ethereum/go-ethereum/trie" 47 ) 48 49 const ( 50 softResponseLimit = 2 * 1024 * 1024 // Target maximum size of returned blocks, headers or node data. 51 estHeaderRlpSize = 500 // Approximate size of an RLP encoded block header 52 53 ethVersion = 63 // equivalent eth version for the downloader 54 55 MaxHeaderFetch = 192 // Amount of block headers to be fetched per retrieval request 56 MaxBodyFetch = 32 // Amount of block bodies to be fetched per retrieval request 57 MaxReceiptFetch = 128 // Amount of transaction receipts to allow fetching per request 58 MaxCodeFetch = 64 // Amount of contract codes to allow fetching per request 59 MaxProofsFetch = 64 // Amount of merkle proofs to be fetched per retrieval request 60 MaxHelperTrieProofsFetch = 64 // Amount of merkle proofs to be fetched per retrieval request 61 MaxTxSend = 64 // Amount of transactions to be send per request 62 MaxTxStatus = 256 // Amount of transactions to queried per request 63 64 disableClientRemovePeer = false 65 ) 66 67 func errResp(code errCode, format string, v ...interface{}) error { 68 return fmt.Errorf("%v - %v", code, fmt.Sprintf(format, v...)) 69 } 70 71 type BlockChain interface { 72 Config() *params.ChainConfig 73 HasHeader(hash common.Hash, number uint64) bool 74 GetHeader(hash common.Hash, number uint64) *types.Header 75 GetHeaderByHash(hash common.Hash) *types.Header 76 CurrentHeader() *types.Header 77 GetTd(hash common.Hash, number uint64) *big.Int 78 State() (*state.StateDB, error) 79 InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) 80 Rollback(chain []common.Hash) 81 GetHeaderByNumber(number uint64) *types.Header 82 GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64) 83 Genesis() *types.Block 84 SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription 85 } 86 87 type txPool interface { 88 AddRemotes(txs []*types.Transaction) []error 89 Status(hashes []common.Hash) []core.TxStatus 90 PreBlacklistHook(blocks types.Blocks) types.Blocks 91 } 92 93 type ProtocolManager struct { 94 lightSync bool 95 txpool txPool 96 txrelay *LesTxRelay 97 networkId uint64 98 chainConfig *params.ChainConfig 99 iConfig *light.IndexerConfig 100 blockchain BlockChain 101 chainDb ethdb.Database 102 odr *LesOdr 103 server *LesServer 104 serverPool *serverPool 105 clientPool *freeClientPool 106 lesTopic discv5.Topic 107 reqDist *requestDistributor 108 retriever *retrieveManager 109 110 downloader *downloader.Downloader 111 fetcher *lightFetcher 112 peers *peerSet 113 maxPeers int 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 // wait group is used for graceful shutdowns during downloading 123 // and processing 124 wg *sync.WaitGroup 125 } 126 127 // NewProtocolManager returns a new ethereum sub protocol manager. The Ethereum sub protocol manages peers capable 128 // with the ethereum network. 129 func NewProtocolManager(chainConfig *params.ChainConfig, indexerConfig *light.IndexerConfig, lightSync bool, networkId uint64, mux *event.TypeMux, engine consensus.Engine, peers *peerSet, blockchain BlockChain, txpool txPool, chainDb ethdb.Database, odr *LesOdr, txrelay *LesTxRelay, serverPool *serverPool, quitSync chan struct{}, wg *sync.WaitGroup) (*ProtocolManager, error) { 130 // Create the protocol manager with the base fields 131 manager := &ProtocolManager{ 132 lightSync: lightSync, 133 eventMux: mux, 134 blockchain: blockchain, 135 chainConfig: chainConfig, 136 iConfig: indexerConfig, 137 chainDb: chainDb, 138 odr: odr, 139 networkId: networkId, 140 txpool: txpool, 141 txrelay: txrelay, 142 serverPool: serverPool, 143 peers: peers, 144 newPeerCh: make(chan *peer), 145 quitSync: quitSync, 146 wg: wg, 147 noMorePeers: make(chan struct{}), 148 } 149 if odr != nil { 150 manager.retriever = odr.retriever 151 manager.reqDist = odr.retriever.dist 152 } 153 154 removePeer := manager.removePeer 155 if disableClientRemovePeer { 156 removePeer = func(id string) {} 157 } 158 if lightSync { 159 var checkpoint uint64 160 if cht, ok := params.TrustedCheckpoints[blockchain.Genesis().Hash()]; ok { 161 checkpoint = (cht.SectionIndex+1)*params.CHTFrequencyClient - 1 162 } 163 manager.downloader = downloader.New(downloader.LightSync, checkpoint, chainDb, manager.eventMux, nil, blockchain, txpool, removePeer) 164 manager.peers.notify((*downloaderPeerNotify)(manager)) 165 manager.fetcher = newLightFetcher(manager) 166 } 167 168 return manager, nil 169 } 170 171 // removePeer initiates disconnection from a peer by removing it from the peer set 172 func (pm *ProtocolManager) removePeer(id string) { 173 pm.peers.Unregister(id) 174 } 175 176 func (pm *ProtocolManager) Start(maxPeers int) { 177 pm.maxPeers = maxPeers 178 179 if pm.lightSync { 180 go pm.syncer() 181 } else { 182 pm.clientPool = newFreeClientPool(pm.chainDb, maxPeers, 10000, mclock.System{}) 183 go func() { 184 for range pm.newPeerCh { 185 } 186 }() 187 } 188 } 189 190 func (pm *ProtocolManager) Stop() { 191 // Showing a log message. During download / process this could actually 192 // take between 5 to 10 seconds and therefor feedback is required. 193 log.Info("Stopping light Energi protocol") 194 195 // Quit the sync loop. 196 // After this send has completed, no new peers will be accepted. 197 pm.noMorePeers <- struct{}{} 198 199 close(pm.quitSync) // quits syncer, fetcher 200 if pm.clientPool != nil { 201 pm.clientPool.stop() 202 } 203 204 // Disconnect existing sessions. 205 // This also closes the gate for any new registrations on the peer set. 206 // sessions which are already established but not added to pm.peers yet 207 // will exit when they try to register. 208 pm.peers.Close() 209 210 // Wait for any process action 211 pm.wg.Wait() 212 213 log.Info("Light Energi protocol stopped") 214 } 215 216 // runPeer is the p2p protocol run function for the given version. 217 func (pm *ProtocolManager) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) error { 218 var entry *poolEntry 219 peer := pm.newPeer(int(version), pm.networkId, p, rw) 220 if pm.serverPool != nil { 221 entry = pm.serverPool.connect(peer, peer.Node()) 222 } 223 peer.poolEntry = entry 224 select { 225 case pm.newPeerCh <- peer: 226 pm.wg.Add(1) 227 defer pm.wg.Done() 228 err := pm.handle(peer) 229 if entry != nil { 230 pm.serverPool.disconnect(entry) 231 } 232 return err 233 case <-pm.quitSync: 234 if entry != nil { 235 pm.serverPool.disconnect(entry) 236 } 237 return p2p.DiscQuitting 238 } 239 } 240 241 func (pm *ProtocolManager) newPeer(pv int, nv uint64, p *p2p.Peer, rw p2p.MsgReadWriter) *peer { 242 return newPeer(pv, nv, p, newMeteredMsgWriter(rw)) 243 } 244 245 // handle is the callback invoked to manage the life cycle of a les peer. When 246 // this function terminates, the peer is disconnected. 247 func (pm *ProtocolManager) handle(p *peer) error { 248 // Ignore maxPeers if this is a trusted peer 249 // In server mode we try to check into the client pool after handshake 250 if pm.lightSync && pm.peers.Len() >= pm.maxPeers && !p.Peer.Info().Network.Trusted { 251 return p2p.DiscTooManyPeers 252 } 253 254 p.Log().Debug("Light Energi peer connected", "name", p.Name()) 255 256 // Execute the LES handshake 257 var ( 258 genesis = pm.blockchain.Genesis() 259 head = pm.blockchain.CurrentHeader() 260 hash = head.Hash() 261 number = head.Number.Uint64() 262 td = pm.blockchain.GetTd(hash, number) 263 ) 264 if err := p.Handshake(td, hash, number, genesis.Hash(), pm.server); err != nil { 265 p.Log().Debug("Light Energi handshake failed", "err", err) 266 return err 267 } 268 269 if !pm.lightSync && !p.Peer.Info().Network.Trusted { 270 addr, ok := p.RemoteAddr().(*net.TCPAddr) 271 // test peer address is not a tcp address, don't use client pool if can not typecast 272 if ok { 273 id := addr.IP.String() 274 if !pm.clientPool.connect(id, func() { go pm.removePeer(p.id) }) { 275 return p2p.DiscTooManyPeers 276 } 277 defer pm.clientPool.disconnect(id) 278 } 279 } 280 281 if rw, ok := p.rw.(*meteredMsgReadWriter); ok { 282 rw.Init(p.version) 283 } 284 // Register the peer locally 285 if err := pm.peers.Register(p); err != nil { 286 p.Log().Error("Light Energi peer registration failed", "err", err) 287 return err 288 } 289 defer func() { 290 if pm.server != nil && pm.server.fcManager != nil && p.fcClient != nil { 291 p.fcClient.Remove(pm.server.fcManager) 292 } 293 pm.removePeer(p.id) 294 }() 295 // Register the peer in the downloader. If the downloader considers it banned, we disconnect 296 if pm.lightSync { 297 p.lock.Lock() 298 head := p.headInfo 299 p.lock.Unlock() 300 if pm.fetcher != nil { 301 pm.fetcher.announce(p, head) 302 } 303 304 if p.poolEntry != nil { 305 pm.serverPool.registered(p.poolEntry) 306 } 307 } 308 309 stop := make(chan struct{}) 310 defer close(stop) 311 go func() { 312 // new block announce loop 313 for { 314 select { 315 case announce := <-p.announceChn: 316 p.SendAnnounce(announce) 317 case <-stop: 318 return 319 } 320 } 321 }() 322 323 // main loop. handle incoming messages. 324 for { 325 if err := pm.handleMsg(p); err != nil { 326 p.Log().Debug("Light Energi message handling failed", "err", err) 327 return err 328 } 329 } 330 } 331 332 var ( 333 reqList = []uint64{GetBlockHeadersMsg, GetBlockBodiesMsg, GetCodeMsg, GetReceiptsMsg, GetProofsV1Msg, SendTxMsg, SendTxV2Msg, GetTxStatusMsg, GetHeaderProofsMsg, GetProofsV2Msg, GetHelperTrieProofsMsg} 334 reqListV1 = []uint64{GetBlockHeadersMsg, GetBlockBodiesMsg, GetCodeMsg, GetReceiptsMsg, GetProofsV1Msg, SendTxMsg, GetHeaderProofsMsg} 335 reqListV2 = []uint64{GetBlockHeadersMsg, GetBlockBodiesMsg, GetCodeMsg, GetReceiptsMsg, SendTxV2Msg, GetTxStatusMsg, GetProofsV2Msg, GetHelperTrieProofsMsg} 336 ) 337 338 // handleMsg is invoked whenever an inbound message is received from a remote 339 // peer. The remote connection is torn down upon returning any error. 340 func (pm *ProtocolManager) handleMsg(p *peer) error { 341 // Read the next message from the remote peer, and ensure it's fully consumed 342 msg, err := p.rw.ReadMsg() 343 if err != nil { 344 return err 345 } 346 p.Log().Trace("Light Energi message arrived", "code", msg.Code, "bytes", msg.Size) 347 348 costs := p.fcCosts[msg.Code] 349 reject := func(reqCnt, maxCnt uint64) bool { 350 if p.fcClient == nil || reqCnt > maxCnt { 351 return true 352 } 353 bufValue, _ := p.fcClient.AcceptRequest() 354 cost := costs.baseCost + reqCnt*costs.reqCost 355 if cost > pm.server.defParams.BufLimit { 356 cost = pm.server.defParams.BufLimit 357 } 358 if cost > bufValue { 359 recharge := time.Duration((cost - bufValue) * 1000000 / pm.server.defParams.MinRecharge) 360 p.Log().Error("Request came too early", "recharge", common.PrettyDuration(recharge)) 361 return true 362 } 363 return false 364 } 365 366 if msg.Size > ProtocolMaxMsgSize { 367 return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize) 368 } 369 defer msg.Discard() 370 371 var deliverMsg *Msg 372 373 // Handle the message depending on its contents 374 switch msg.Code { 375 case StatusMsg: 376 p.Log().Trace("Received status message") 377 // Status messages should never arrive after the handshake 378 return errResp(ErrExtraStatusMsg, "uncontrolled status message") 379 380 // Block header query, collect the requested headers and reply 381 case AnnounceMsg: 382 p.Log().Trace("Received announce message") 383 if p.requestAnnounceType == announceTypeNone { 384 return errResp(ErrUnexpectedResponse, "") 385 } 386 387 var req announceData 388 if err := msg.Decode(&req); err != nil { 389 return errResp(ErrDecode, "%v: %v", msg, err) 390 } 391 392 if p.requestAnnounceType == announceTypeSigned { 393 if err := req.checkSignature(p.ID()); err != nil { 394 p.Log().Trace("Invalid announcement signature", "err", err) 395 return err 396 } 397 p.Log().Trace("Valid announcement signature") 398 } 399 400 p.Log().Trace("Announce message content", "number", req.Number, "hash", req.Hash, "td", req.Td, "reorg", req.ReorgDepth) 401 if pm.fetcher != nil { 402 pm.fetcher.announce(p, &req) 403 } 404 405 case GetBlockHeadersMsg: 406 p.Log().Trace("Received block header request") 407 // Decode the complex header query 408 var req struct { 409 ReqID uint64 410 Query getBlockHeadersData 411 } 412 if err := msg.Decode(&req); err != nil { 413 return errResp(ErrDecode, "%v: %v", msg, err) 414 } 415 416 query := req.Query 417 if reject(query.Amount, MaxHeaderFetch) { 418 return errResp(ErrRequestRejected, "") 419 } 420 421 hashMode := query.Origin.Hash != (common.Hash{}) 422 first := true 423 maxNonCanonical := uint64(100) 424 425 // Gather headers until the fetch or network limits is reached 426 var ( 427 bytes common.StorageSize 428 headers []*types.Header 429 unknown bool 430 ) 431 for !unknown && len(headers) < int(query.Amount) && bytes < softResponseLimit { 432 // Retrieve the next header satisfying the query 433 var origin *types.Header 434 if hashMode { 435 if first { 436 first = false 437 origin = pm.blockchain.GetHeaderByHash(query.Origin.Hash) 438 if origin != nil { 439 query.Origin.Number = origin.Number.Uint64() 440 } 441 } else { 442 origin = pm.blockchain.GetHeader(query.Origin.Hash, query.Origin.Number) 443 } 444 } else { 445 origin = pm.blockchain.GetHeaderByNumber(query.Origin.Number) 446 } 447 if origin == nil { 448 break 449 } 450 headers = append(headers, origin) 451 bytes += estHeaderRlpSize 452 453 // Advance to the next header of the query 454 switch { 455 case hashMode && query.Reverse: 456 // Hash based traversal towards the genesis block 457 ancestor := query.Skip + 1 458 if ancestor == 0 { 459 unknown = true 460 } else { 461 query.Origin.Hash, query.Origin.Number = pm.blockchain.GetAncestor(query.Origin.Hash, query.Origin.Number, ancestor, &maxNonCanonical) 462 unknown = (query.Origin.Hash == common.Hash{}) 463 } 464 case hashMode && !query.Reverse: 465 // Hash based traversal towards the leaf block 466 var ( 467 current = origin.Number.Uint64() 468 next = current + query.Skip + 1 469 ) 470 if next <= current { 471 infos, _ := json.MarshalIndent(p.Peer.Info(), "", " ") 472 p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next, "attacker", infos) 473 unknown = true 474 } else { 475 if header := pm.blockchain.GetHeaderByNumber(next); header != nil { 476 nextHash := header.Hash() 477 expOldHash, _ := pm.blockchain.GetAncestor(nextHash, next, query.Skip+1, &maxNonCanonical) 478 if expOldHash == query.Origin.Hash { 479 query.Origin.Hash, query.Origin.Number = nextHash, next 480 } else { 481 unknown = true 482 } 483 } else { 484 unknown = true 485 } 486 } 487 case query.Reverse: 488 // Number based traversal towards the genesis block 489 if query.Origin.Number >= query.Skip+1 { 490 query.Origin.Number -= query.Skip + 1 491 } else { 492 unknown = true 493 } 494 495 case !query.Reverse: 496 // Number based traversal towards the leaf block 497 query.Origin.Number += query.Skip + 1 498 } 499 } 500 501 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + query.Amount*costs.reqCost) 502 pm.server.fcCostStats.update(msg.Code, query.Amount, rcost) 503 return p.SendBlockHeaders(req.ReqID, bv, headers) 504 505 case BlockHeadersMsg: 506 if pm.downloader == nil { 507 return errResp(ErrUnexpectedResponse, "") 508 } 509 510 p.Log().Trace("Received block header response message") 511 // A batch of headers arrived to one of our previous requests 512 var resp struct { 513 ReqID, BV uint64 514 Headers []*types.Header 515 } 516 if err := msg.Decode(&resp); err != nil { 517 return errResp(ErrDecode, "msg %v: %v", msg, err) 518 } 519 p.fcServer.GotReply(resp.ReqID, resp.BV) 520 if pm.fetcher != nil && pm.fetcher.requestedID(resp.ReqID) { 521 pm.fetcher.deliverHeaders(p, resp.ReqID, resp.Headers) 522 } else { 523 err := pm.downloader.DeliverHeaders(p.id, resp.Headers) 524 if err != nil { 525 log.Debug(fmt.Sprint(err)) 526 } 527 } 528 529 case GetBlockBodiesMsg: 530 p.Log().Trace("Received block bodies request") 531 // Decode the retrieval message 532 var req struct { 533 ReqID uint64 534 Hashes []common.Hash 535 } 536 if err := msg.Decode(&req); err != nil { 537 return errResp(ErrDecode, "msg %v: %v", msg, err) 538 } 539 // Gather blocks until the fetch or network limits is reached 540 var ( 541 bytes int 542 bodies []rlp.RawValue 543 ) 544 reqCnt := len(req.Hashes) 545 if reject(uint64(reqCnt), MaxBodyFetch) { 546 return errResp(ErrRequestRejected, "") 547 } 548 for _, hash := range req.Hashes { 549 if bytes >= softResponseLimit { 550 break 551 } 552 // Retrieve the requested block body, stopping if enough was found 553 if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil { 554 if data := rawdb.ReadBodyRLP(pm.chainDb, hash, *number); len(data) != 0 { 555 bodies = append(bodies, data) 556 bytes += len(data) 557 } 558 } 559 } 560 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 561 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 562 return p.SendBlockBodiesRLP(req.ReqID, bv, bodies) 563 564 case BlockBodiesMsg: 565 if pm.odr == nil { 566 return errResp(ErrUnexpectedResponse, "") 567 } 568 569 p.Log().Trace("Received block bodies response") 570 // A batch of block bodies arrived to one of our previous requests 571 var resp struct { 572 ReqID, BV uint64 573 Data []*types.Body 574 } 575 if err := msg.Decode(&resp); err != nil { 576 return errResp(ErrDecode, "msg %v: %v", msg, err) 577 } 578 p.fcServer.GotReply(resp.ReqID, resp.BV) 579 deliverMsg = &Msg{ 580 MsgType: MsgBlockBodies, 581 ReqID: resp.ReqID, 582 Obj: resp.Data, 583 } 584 585 case GetCodeMsg: 586 p.Log().Trace("Received code request") 587 // Decode the retrieval message 588 var req struct { 589 ReqID uint64 590 Reqs []CodeReq 591 } 592 if err := msg.Decode(&req); err != nil { 593 return errResp(ErrDecode, "msg %v: %v", msg, err) 594 } 595 // Gather state data until the fetch or network limits is reached 596 var ( 597 bytes int 598 data [][]byte 599 ) 600 reqCnt := len(req.Reqs) 601 if reject(uint64(reqCnt), MaxCodeFetch) { 602 return errResp(ErrRequestRejected, "") 603 } 604 for _, req := range req.Reqs { 605 // Retrieve the requested state entry, stopping if enough was found 606 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 607 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 608 statedb, err := pm.blockchain.State() 609 if err != nil { 610 continue 611 } 612 account, err := pm.getAccount(statedb, header.Root, common.BytesToHash(req.AccKey)) 613 if err != nil { 614 continue 615 } 616 code, _ := statedb.Database().TrieDB().Node(common.BytesToHash(account.CodeHash)) 617 618 data = append(data, code) 619 if bytes += len(code); bytes >= softResponseLimit { 620 break 621 } 622 } 623 } 624 } 625 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 626 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 627 return p.SendCode(req.ReqID, bv, data) 628 629 case CodeMsg: 630 if pm.odr == nil { 631 return errResp(ErrUnexpectedResponse, "") 632 } 633 634 p.Log().Trace("Received code response") 635 // A batch of node state data arrived to one of our previous requests 636 var resp struct { 637 ReqID, BV uint64 638 Data [][]byte 639 } 640 if err := msg.Decode(&resp); err != nil { 641 return errResp(ErrDecode, "msg %v: %v", msg, err) 642 } 643 p.fcServer.GotReply(resp.ReqID, resp.BV) 644 deliverMsg = &Msg{ 645 MsgType: MsgCode, 646 ReqID: resp.ReqID, 647 Obj: resp.Data, 648 } 649 650 case GetReceiptsMsg: 651 p.Log().Trace("Received receipts request") 652 // Decode the retrieval message 653 var req struct { 654 ReqID uint64 655 Hashes []common.Hash 656 } 657 if err := msg.Decode(&req); err != nil { 658 return errResp(ErrDecode, "msg %v: %v", msg, err) 659 } 660 // Gather state data until the fetch or network limits is reached 661 var ( 662 bytes int 663 receipts []rlp.RawValue 664 ) 665 reqCnt := len(req.Hashes) 666 if reject(uint64(reqCnt), MaxReceiptFetch) { 667 return errResp(ErrRequestRejected, "") 668 } 669 for _, hash := range req.Hashes { 670 if bytes >= softResponseLimit { 671 break 672 } 673 // Retrieve the requested block's receipts, skipping if unknown to us 674 var results types.Receipts 675 if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil { 676 results = rawdb.ReadReceipts(pm.chainDb, hash, *number) 677 } 678 if results == nil { 679 if header := pm.blockchain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash { 680 continue 681 } 682 } 683 // If known, encode and queue for response packet 684 if encoded, err := rlp.EncodeToBytes(results); err != nil { 685 log.Error("Failed to encode receipt", "err", err) 686 } else { 687 receipts = append(receipts, encoded) 688 bytes += len(encoded) 689 } 690 } 691 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 692 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 693 return p.SendReceiptsRLP(req.ReqID, bv, receipts) 694 695 case ReceiptsMsg: 696 if pm.odr == nil { 697 return errResp(ErrUnexpectedResponse, "") 698 } 699 700 p.Log().Trace("Received receipts response") 701 // A batch of receipts arrived to one of our previous requests 702 var resp struct { 703 ReqID, BV uint64 704 Receipts []types.Receipts 705 } 706 if err := msg.Decode(&resp); err != nil { 707 return errResp(ErrDecode, "msg %v: %v", msg, err) 708 } 709 p.fcServer.GotReply(resp.ReqID, resp.BV) 710 deliverMsg = &Msg{ 711 MsgType: MsgReceipts, 712 ReqID: resp.ReqID, 713 Obj: resp.Receipts, 714 } 715 716 case GetProofsV1Msg: 717 p.Log().Trace("Received proofs request") 718 // Decode the retrieval message 719 var req struct { 720 ReqID uint64 721 Reqs []ProofReq 722 } 723 if err := msg.Decode(&req); err != nil { 724 return errResp(ErrDecode, "msg %v: %v", msg, err) 725 } 726 // Gather state data until the fetch or network limits is reached 727 var ( 728 bytes int 729 proofs proofsData 730 ) 731 reqCnt := len(req.Reqs) 732 if reject(uint64(reqCnt), MaxProofsFetch) { 733 return errResp(ErrRequestRejected, "") 734 } 735 for _, req := range req.Reqs { 736 // Retrieve the requested state entry, stopping if enough was found 737 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 738 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 739 statedb, err := pm.blockchain.State() 740 if err != nil { 741 continue 742 } 743 var trie state.Trie 744 if len(req.AccKey) > 0 { 745 account, err := pm.getAccount(statedb, header.Root, common.BytesToHash(req.AccKey)) 746 if err != nil { 747 continue 748 } 749 trie, _ = statedb.Database().OpenStorageTrie(common.BytesToHash(req.AccKey), account.Root) 750 } else { 751 trie, _ = statedb.Database().OpenTrie(header.Root) 752 } 753 if trie != nil { 754 var proof light.NodeList 755 trie.Prove(req.Key, 0, &proof) 756 757 proofs = append(proofs, proof) 758 if bytes += proof.DataSize(); bytes >= softResponseLimit { 759 break 760 } 761 } 762 } 763 } 764 } 765 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 766 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 767 return p.SendProofs(req.ReqID, bv, proofs) 768 769 case GetProofsV2Msg: 770 p.Log().Trace("Received les/2 proofs request") 771 // Decode the retrieval message 772 var req struct { 773 ReqID uint64 774 Reqs []ProofReq 775 } 776 if err := msg.Decode(&req); err != nil { 777 return errResp(ErrDecode, "msg %v: %v", msg, err) 778 } 779 // Gather state data until the fetch or network limits is reached 780 var ( 781 lastBHash common.Hash 782 statedb *state.StateDB 783 root common.Hash 784 ) 785 reqCnt := len(req.Reqs) 786 if reject(uint64(reqCnt), MaxProofsFetch) { 787 return errResp(ErrRequestRejected, "") 788 } 789 790 nodes := light.NewNodeSet() 791 792 for _, req := range req.Reqs { 793 // Look up the state belonging to the request 794 if statedb == nil || req.BHash != lastBHash { 795 statedb, root, lastBHash = nil, common.Hash{}, req.BHash 796 797 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 798 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 799 statedb, _ = pm.blockchain.State() 800 root = header.Root 801 } 802 } 803 } 804 if statedb == nil { 805 continue 806 } 807 // Pull the account or storage trie of the request 808 var trie state.Trie 809 if len(req.AccKey) > 0 { 810 account, err := pm.getAccount(statedb, root, common.BytesToHash(req.AccKey)) 811 if err != nil { 812 continue 813 } 814 trie, _ = statedb.Database().OpenStorageTrie(common.BytesToHash(req.AccKey), account.Root) 815 } else { 816 trie, _ = statedb.Database().OpenTrie(root) 817 } 818 if trie == nil { 819 continue 820 } 821 // Prove the user's request from the account or stroage trie 822 trie.Prove(req.Key, req.FromLevel, nodes) 823 if nodes.DataSize() >= softResponseLimit { 824 break 825 } 826 } 827 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 828 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 829 return p.SendProofsV2(req.ReqID, bv, nodes.NodeList()) 830 831 case ProofsV1Msg: 832 if pm.odr == nil { 833 return errResp(ErrUnexpectedResponse, "") 834 } 835 836 p.Log().Trace("Received proofs response") 837 // A batch of merkle proofs arrived to one of our previous requests 838 var resp struct { 839 ReqID, BV uint64 840 Data []light.NodeList 841 } 842 if err := msg.Decode(&resp); err != nil { 843 return errResp(ErrDecode, "msg %v: %v", msg, err) 844 } 845 p.fcServer.GotReply(resp.ReqID, resp.BV) 846 deliverMsg = &Msg{ 847 MsgType: MsgProofsV1, 848 ReqID: resp.ReqID, 849 Obj: resp.Data, 850 } 851 852 case ProofsV2Msg: 853 if pm.odr == nil { 854 return errResp(ErrUnexpectedResponse, "") 855 } 856 857 p.Log().Trace("Received les/2 proofs response") 858 // A batch of merkle proofs arrived to one of our previous requests 859 var resp struct { 860 ReqID, BV uint64 861 Data light.NodeList 862 } 863 if err := msg.Decode(&resp); err != nil { 864 return errResp(ErrDecode, "msg %v: %v", msg, err) 865 } 866 p.fcServer.GotReply(resp.ReqID, resp.BV) 867 deliverMsg = &Msg{ 868 MsgType: MsgProofsV2, 869 ReqID: resp.ReqID, 870 Obj: resp.Data, 871 } 872 873 case GetHeaderProofsMsg: 874 p.Log().Trace("Received headers proof request") 875 // Decode the retrieval message 876 var req struct { 877 ReqID uint64 878 Reqs []ChtReq 879 } 880 if err := msg.Decode(&req); err != nil { 881 return errResp(ErrDecode, "msg %v: %v", msg, err) 882 } 883 // Gather state data until the fetch or network limits is reached 884 var ( 885 bytes int 886 proofs []ChtResp 887 ) 888 reqCnt := len(req.Reqs) 889 if reject(uint64(reqCnt), MaxHelperTrieProofsFetch) { 890 return errResp(ErrRequestRejected, "") 891 } 892 trieDb := trie.NewDatabase(ethdb.NewTable(pm.chainDb, light.ChtTablePrefix)) 893 for _, req := range req.Reqs { 894 if header := pm.blockchain.GetHeaderByNumber(req.BlockNum); header != nil { 895 sectionHead := rawdb.ReadCanonicalHash(pm.chainDb, req.ChtNum*pm.iConfig.ChtSize-1) 896 if root := light.GetChtRoot(pm.chainDb, req.ChtNum-1, sectionHead); root != (common.Hash{}) { 897 trie, err := trie.New(root, trieDb) 898 if err != nil { 899 continue 900 } 901 var encNumber [8]byte 902 binary.BigEndian.PutUint64(encNumber[:], req.BlockNum) 903 904 var proof light.NodeList 905 trie.Prove(encNumber[:], 0, &proof) 906 907 proofs = append(proofs, ChtResp{Header: header, Proof: proof}) 908 if bytes += proof.DataSize() + estHeaderRlpSize; bytes >= softResponseLimit { 909 break 910 } 911 } 912 } 913 } 914 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 915 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 916 return p.SendHeaderProofs(req.ReqID, bv, proofs) 917 918 case GetHelperTrieProofsMsg: 919 p.Log().Trace("Received helper trie proof request") 920 // Decode the retrieval message 921 var req struct { 922 ReqID uint64 923 Reqs []HelperTrieReq 924 } 925 if err := msg.Decode(&req); err != nil { 926 return errResp(ErrDecode, "msg %v: %v", msg, err) 927 } 928 // Gather state data until the fetch or network limits is reached 929 var ( 930 auxBytes int 931 auxData [][]byte 932 ) 933 reqCnt := len(req.Reqs) 934 if reject(uint64(reqCnt), MaxHelperTrieProofsFetch) { 935 return errResp(ErrRequestRejected, "") 936 } 937 938 var ( 939 lastIdx uint64 940 lastType uint 941 root common.Hash 942 auxTrie *trie.Trie 943 ) 944 nodes := light.NewNodeSet() 945 for _, req := range req.Reqs { 946 if auxTrie == nil || req.Type != lastType || req.TrieIdx != lastIdx { 947 auxTrie, lastType, lastIdx = nil, req.Type, req.TrieIdx 948 949 var prefix string 950 if root, prefix = pm.getHelperTrie(req.Type, req.TrieIdx); root != (common.Hash{}) { 951 auxTrie, _ = trie.New(root, trie.NewDatabase(ethdb.NewTable(pm.chainDb, prefix))) 952 } 953 } 954 if req.AuxReq == auxRoot { 955 var data []byte 956 if root != (common.Hash{}) { 957 data = root[:] 958 } 959 auxData = append(auxData, data) 960 auxBytes += len(data) 961 } else { 962 if auxTrie != nil { 963 auxTrie.Prove(req.Key, req.FromLevel, nodes) 964 } 965 if req.AuxReq != 0 { 966 data := pm.getHelperTrieAuxData(req) 967 auxData = append(auxData, data) 968 auxBytes += len(data) 969 } 970 } 971 if nodes.DataSize()+auxBytes >= softResponseLimit { 972 break 973 } 974 } 975 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 976 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 977 return p.SendHelperTrieProofs(req.ReqID, bv, HelperTrieResps{Proofs: nodes.NodeList(), AuxData: auxData}) 978 979 case HeaderProofsMsg: 980 if pm.odr == nil { 981 return errResp(ErrUnexpectedResponse, "") 982 } 983 984 p.Log().Trace("Received headers proof response") 985 var resp struct { 986 ReqID, BV uint64 987 Data []ChtResp 988 } 989 if err := msg.Decode(&resp); err != nil { 990 return errResp(ErrDecode, "msg %v: %v", msg, err) 991 } 992 p.fcServer.GotReply(resp.ReqID, resp.BV) 993 deliverMsg = &Msg{ 994 MsgType: MsgHeaderProofs, 995 ReqID: resp.ReqID, 996 Obj: resp.Data, 997 } 998 999 case HelperTrieProofsMsg: 1000 if pm.odr == nil { 1001 return errResp(ErrUnexpectedResponse, "") 1002 } 1003 1004 p.Log().Trace("Received helper trie proof response") 1005 var resp struct { 1006 ReqID, BV uint64 1007 Data HelperTrieResps 1008 } 1009 if err := msg.Decode(&resp); err != nil { 1010 return errResp(ErrDecode, "msg %v: %v", msg, err) 1011 } 1012 1013 p.fcServer.GotReply(resp.ReqID, resp.BV) 1014 deliverMsg = &Msg{ 1015 MsgType: MsgHelperTrieProofs, 1016 ReqID: resp.ReqID, 1017 Obj: resp.Data, 1018 } 1019 1020 case SendTxMsg: 1021 if pm.txpool == nil { 1022 return errResp(ErrRequestRejected, "") 1023 } 1024 // Transactions arrived, parse all of them and deliver to the pool 1025 var txs []*types.Transaction 1026 if err := msg.Decode(&txs); err != nil { 1027 return errResp(ErrDecode, "msg %v: %v", msg, err) 1028 } 1029 reqCnt := len(txs) 1030 if reject(uint64(reqCnt), MaxTxSend) { 1031 return errResp(ErrRequestRejected, "") 1032 } 1033 pm.txpool.AddRemotes(txs) 1034 1035 _, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 1036 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 1037 1038 case SendTxV2Msg: 1039 if pm.txpool == nil { 1040 return errResp(ErrRequestRejected, "") 1041 } 1042 // Transactions arrived, parse all of them and deliver to the pool 1043 var req struct { 1044 ReqID uint64 1045 Txs []*types.Transaction 1046 } 1047 if err := msg.Decode(&req); err != nil { 1048 return errResp(ErrDecode, "msg %v: %v", msg, err) 1049 } 1050 reqCnt := len(req.Txs) 1051 if reject(uint64(reqCnt), MaxTxSend) { 1052 return errResp(ErrRequestRejected, "") 1053 } 1054 1055 hashes := make([]common.Hash, len(req.Txs)) 1056 for i, tx := range req.Txs { 1057 hashes[i] = tx.Hash() 1058 } 1059 stats := pm.txStatus(hashes) 1060 for i, stat := range stats { 1061 if stat.Status == core.TxStatusUnknown { 1062 if errs := pm.txpool.AddRemotes([]*types.Transaction{req.Txs[i]}); errs[0] != nil { 1063 stats[i].Error = errs[0].Error() 1064 continue 1065 } 1066 stats[i] = pm.txStatus([]common.Hash{hashes[i]})[0] 1067 } 1068 } 1069 1070 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 1071 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 1072 1073 return p.SendTxStatus(req.ReqID, bv, stats) 1074 1075 case GetTxStatusMsg: 1076 if pm.txpool == nil { 1077 return errResp(ErrUnexpectedResponse, "") 1078 } 1079 // Transactions arrived, parse all of them and deliver to the pool 1080 var req struct { 1081 ReqID uint64 1082 Hashes []common.Hash 1083 } 1084 if err := msg.Decode(&req); err != nil { 1085 return errResp(ErrDecode, "msg %v: %v", msg, err) 1086 } 1087 reqCnt := len(req.Hashes) 1088 if reject(uint64(reqCnt), MaxTxStatus) { 1089 return errResp(ErrRequestRejected, "") 1090 } 1091 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 1092 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 1093 1094 return p.SendTxStatus(req.ReqID, bv, pm.txStatus(req.Hashes)) 1095 1096 case TxStatusMsg: 1097 if pm.odr == nil { 1098 return errResp(ErrUnexpectedResponse, "") 1099 } 1100 1101 p.Log().Trace("Received tx status response") 1102 var resp struct { 1103 ReqID, BV uint64 1104 Status []txStatus 1105 } 1106 if err := msg.Decode(&resp); err != nil { 1107 return errResp(ErrDecode, "msg %v: %v", msg, err) 1108 } 1109 1110 p.fcServer.GotReply(resp.ReqID, resp.BV) 1111 1112 default: 1113 p.Log().Trace("Received unknown message", "code", msg.Code) 1114 return errResp(ErrInvalidMsgCode, "%v", msg.Code) 1115 } 1116 1117 if deliverMsg != nil { 1118 err := pm.retriever.deliver(p, deliverMsg) 1119 if err != nil { 1120 p.responseErrors++ 1121 if p.responseErrors > maxResponseErrors { 1122 return err 1123 } 1124 } 1125 } 1126 return nil 1127 } 1128 1129 // getAccount retrieves an account from the state based at root. 1130 func (pm *ProtocolManager) getAccount(statedb *state.StateDB, root, hash common.Hash) (state.Account, error) { 1131 trie, err := trie.New(root, statedb.Database().TrieDB()) 1132 if err != nil { 1133 return state.Account{}, err 1134 } 1135 blob, err := trie.TryGet(hash[:]) 1136 if err != nil { 1137 return state.Account{}, err 1138 } 1139 var account state.Account 1140 if err = rlp.DecodeBytes(blob, &account); err != nil { 1141 return state.Account{}, err 1142 } 1143 return account, nil 1144 } 1145 1146 // getHelperTrie returns the post-processed trie root for the given trie ID and section index 1147 func (pm *ProtocolManager) getHelperTrie(id uint, idx uint64) (common.Hash, string) { 1148 switch id { 1149 case htCanonical: 1150 idxV1 := (idx+1)*(pm.iConfig.PairChtSize/pm.iConfig.ChtSize) - 1 1151 sectionHead := rawdb.ReadCanonicalHash(pm.chainDb, (idxV1+1)*pm.iConfig.ChtSize-1) 1152 return light.GetChtRoot(pm.chainDb, idxV1, sectionHead), light.ChtTablePrefix 1153 case htBloomBits: 1154 sectionHead := rawdb.ReadCanonicalHash(pm.chainDb, (idx+1)*pm.iConfig.BloomTrieSize-1) 1155 return light.GetBloomTrieRoot(pm.chainDb, idx, sectionHead), light.BloomTrieTablePrefix 1156 } 1157 return common.Hash{}, "" 1158 } 1159 1160 // getHelperTrieAuxData returns requested auxiliary data for the given HelperTrie request 1161 func (pm *ProtocolManager) getHelperTrieAuxData(req HelperTrieReq) []byte { 1162 if req.Type == htCanonical && req.AuxReq == auxHeader && len(req.Key) == 8 { 1163 blockNum := binary.BigEndian.Uint64(req.Key) 1164 hash := rawdb.ReadCanonicalHash(pm.chainDb, blockNum) 1165 return rawdb.ReadHeaderRLP(pm.chainDb, hash, blockNum) 1166 } 1167 return nil 1168 } 1169 1170 func (pm *ProtocolManager) txStatus(hashes []common.Hash) []txStatus { 1171 stats := make([]txStatus, len(hashes)) 1172 for i, stat := range pm.txpool.Status(hashes) { 1173 // Save the status we've got from the transaction pool 1174 stats[i].Status = stat 1175 1176 // If the transaction is unknown to the pool, try looking it up locally 1177 if stat == core.TxStatusUnknown { 1178 if block, number, index := rawdb.ReadTxLookupEntry(pm.chainDb, hashes[i]); block != (common.Hash{}) { 1179 stats[i].Status = core.TxStatusIncluded 1180 stats[i].Lookup = &rawdb.TxLookupEntry{BlockHash: block, BlockIndex: number, Index: index} 1181 } 1182 } 1183 } 1184 return stats 1185 } 1186 1187 // downloaderPeerNotify implements peerSetNotify 1188 type downloaderPeerNotify ProtocolManager 1189 1190 type peerConnection struct { 1191 manager *ProtocolManager 1192 peer *peer 1193 } 1194 1195 func (pc *peerConnection) Head() (common.Hash, *big.Int) { 1196 return pc.peer.HeadAndTd() 1197 } 1198 1199 func (pc *peerConnection) RequestHeadersByHash(origin common.Hash, amount int, skip int, reverse bool) error { 1200 reqID := genReqID() 1201 rq := &distReq{ 1202 getCost: func(dp distPeer) uint64 { 1203 peer := dp.(*peer) 1204 return peer.GetRequestCost(GetBlockHeadersMsg, amount) 1205 }, 1206 canSend: func(dp distPeer) bool { 1207 return dp.(*peer) == pc.peer 1208 }, 1209 request: func(dp distPeer) func() { 1210 peer := dp.(*peer) 1211 cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) 1212 peer.fcServer.QueueRequest(reqID, cost) 1213 return func() { peer.RequestHeadersByHash(reqID, cost, origin, amount, skip, reverse) } 1214 }, 1215 } 1216 _, ok := <-pc.manager.reqDist.queue(rq) 1217 if !ok { 1218 return light.ErrNoPeers 1219 } 1220 return nil 1221 } 1222 1223 func (pc *peerConnection) RequestHeadersByNumber(origin uint64, amount int, skip int, reverse bool) error { 1224 reqID := genReqID() 1225 rq := &distReq{ 1226 getCost: func(dp distPeer) uint64 { 1227 peer := dp.(*peer) 1228 return peer.GetRequestCost(GetBlockHeadersMsg, amount) 1229 }, 1230 canSend: func(dp distPeer) bool { 1231 return dp.(*peer) == pc.peer 1232 }, 1233 request: func(dp distPeer) func() { 1234 peer := dp.(*peer) 1235 cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) 1236 peer.fcServer.QueueRequest(reqID, cost) 1237 return func() { peer.RequestHeadersByNumber(reqID, cost, origin, amount, skip, reverse) } 1238 }, 1239 } 1240 _, ok := <-pc.manager.reqDist.queue(rq) 1241 if !ok { 1242 return light.ErrNoPeers 1243 } 1244 return nil 1245 } 1246 1247 func (d *downloaderPeerNotify) registerPeer(p *peer) { 1248 pm := (*ProtocolManager)(d) 1249 pc := &peerConnection{ 1250 manager: pm, 1251 peer: p, 1252 } 1253 pm.downloader.RegisterLightPeer(p.id, ethVersion, pc) 1254 } 1255 1256 func (d *downloaderPeerNotify) unregisterPeer(p *peer) { 1257 pm := (*ProtocolManager)(d) 1258 pm.downloader.UnregisterPeer(p.id) 1259 }