github.com/edxfund/masterchain@v1.8.16-0.20190112084457-6ad8bdd0f74a/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 "encoding/json" 23 "fmt" 24 "math/big" 25 "net" 26 "reflect" 27 "sync" 28 "time" 29 30 "github.com/EDXFund/MasterChain/common" 31 "github.com/EDXFund/MasterChain/common/mclock" 32 "github.com/EDXFund/MasterChain/consensus" 33 "github.com/EDXFund/MasterChain/core" 34 "github.com/EDXFund/MasterChain/core/rawdb" 35 "github.com/EDXFund/MasterChain/core/state" 36 "github.com/EDXFund/MasterChain/core/types" 37 "github.com/EDXFund/MasterChain/eth/downloader" 38 "github.com/EDXFund/MasterChain/ethdb" 39 "github.com/EDXFund/MasterChain/event" 40 "github.com/EDXFund/MasterChain/light" 41 "github.com/EDXFund/MasterChain/log" 42 "github.com/EDXFund/MasterChain/p2p" 43 "github.com/EDXFund/MasterChain/p2p/discv5" 44 "github.com/EDXFund/MasterChain/params" 45 "github.com/EDXFund/MasterChain/rlp" 46 "github.com/EDXFund/MasterChain/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.HeaderIntf 75 GetHeaderByHash(hash common.Hash) types.HeaderIntf 76 CurrentHeader() types.HeaderIntf 77 GetTd(hash common.Hash, number uint64) *big.Int 78 State() (*state.StateDB, error) 79 InsertHeaderChain(chain []types.HeaderIntf, checkFreq int) (int, error) 80 Rollback(chain []common.Hash) 81 GetHeaderByNumber(number uint64) types.HeaderIntf 82 GetAncestor(hash common.Hash, number, ancestor uint64, maxNonCanonical *uint64) (common.Hash, uint64) 83 Genesis() types.BlockIntf 84 SubscribeChainHeadEvent(ch chan<- core.ChainHeadEvent) event.Subscription 85 ShardId() uint16 86 } 87 88 type txPool interface { 89 AddRemotes(txs []*types.Transaction) []error 90 Status(hashes []common.Hash) []core.TxStatus 91 } 92 93 type ProtocolManager struct { 94 lightSync bool 95 txpool core.TxPoolIntf 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 core.TxPoolIntf, 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 159 if lightSync { 160 manager.downloader = downloader.New(downloader.LightSync, chainDb, manager.eventMux, nil, blockchain, removePeer) 161 manager.peers.notify((*downloaderPeerNotify)(manager)) 162 manager.fetcher = newLightFetcher(manager) 163 } 164 165 return manager, nil 166 } 167 168 // removePeer initiates disconnection from a peer by removing it from the peer set 169 func (pm *ProtocolManager) removePeer(id string) { 170 pm.peers.Unregister(id) 171 } 172 173 func (pm *ProtocolManager) Start(maxPeers int) { 174 pm.maxPeers = maxPeers 175 176 if pm.lightSync { 177 go pm.syncer() 178 } else { 179 pm.clientPool = newFreeClientPool(pm.chainDb, maxPeers, 10000, mclock.System{}) 180 go func() { 181 for range pm.newPeerCh { 182 } 183 }() 184 } 185 } 186 187 func (pm *ProtocolManager) Stop() { 188 // Showing a log message. During download / process this could actually 189 // take between 5 to 10 seconds and therefor feedback is required. 190 log.Info("Stopping light Ethereum protocol") 191 192 // Quit the sync loop. 193 // After this send has completed, no new peers will be accepted. 194 pm.noMorePeers <- struct{}{} 195 196 close(pm.quitSync) // quits syncer, fetcher 197 if pm.clientPool != nil { 198 pm.clientPool.stop() 199 } 200 201 // Disconnect existing sessions. 202 // This also closes the gate for any new registrations on the peer set. 203 // sessions which are already established but not added to pm.peers yet 204 // will exit when they try to register. 205 pm.peers.Close() 206 207 // Wait for any process action 208 pm.wg.Wait() 209 210 log.Info("Light Ethereum protocol stopped") 211 } 212 213 // runPeer is the p2p protocol run function for the given version. 214 func (pm *ProtocolManager) runPeer(version uint, p *p2p.Peer, rw p2p.MsgReadWriter) error { 215 var entry *poolEntry 216 peer := pm.newPeer(int(version), pm.networkId, p, rw) 217 if pm.serverPool != nil { 218 entry = pm.serverPool.connect(peer, peer.Node()) 219 } 220 peer.poolEntry = entry 221 select { 222 case pm.newPeerCh <- peer: 223 pm.wg.Add(1) 224 defer pm.wg.Done() 225 err := pm.handle(peer) 226 if entry != nil { 227 pm.serverPool.disconnect(entry) 228 } 229 return err 230 case <-pm.quitSync: 231 if entry != nil { 232 pm.serverPool.disconnect(entry) 233 } 234 return p2p.DiscQuitting 235 } 236 } 237 238 func (pm *ProtocolManager) newPeer(pv int, nv uint64, p *p2p.Peer, rw p2p.MsgReadWriter) *peer { 239 return newPeer(pv, nv, p, newMeteredMsgWriter(rw)) 240 } 241 242 // handle is the callback invoked to manage the life cycle of a les peer. When 243 // this function terminates, the peer is disconnected. 244 func (pm *ProtocolManager) handle(p *peer) error { 245 // Ignore maxPeers if this is a trusted peer 246 // In server mode we try to check into the client pool after handshake 247 if pm.lightSync && pm.peers.Len() >= pm.maxPeers && !p.Peer.Info().Network.Trusted { 248 return p2p.DiscTooManyPeers 249 } 250 251 p.Log().Debug("Light Ethereum peer connected", "name", p.Name()) 252 253 // Execute the LES handshake 254 var ( 255 genesis = pm.blockchain.Genesis() 256 head = pm.blockchain.CurrentHeader() 257 hash = head.Hash() 258 number = head.NumberU64() 259 td = pm.blockchain.GetTd(hash, number) 260 ) 261 if err := p.Handshake(td, hash, number, genesis.Hash(), pm.server); err != nil { 262 p.Log().Debug("Light Ethereum handshake failed", "err", err) 263 return err 264 } 265 266 if !pm.lightSync && !p.Peer.Info().Network.Trusted { 267 addr, ok := p.RemoteAddr().(*net.TCPAddr) 268 // test peer address is not a tcp address, don't use client pool if can not typecast 269 if ok { 270 id := addr.IP.String() 271 if !pm.clientPool.connect(id, func() { go pm.removePeer(p.id) }) { 272 return p2p.DiscTooManyPeers 273 } 274 defer pm.clientPool.disconnect(id) 275 } 276 } 277 278 if rw, ok := p.rw.(*meteredMsgReadWriter); ok { 279 rw.Init(p.version) 280 } 281 // Register the peer locally 282 if err := pm.peers.Register(p); err != nil { 283 p.Log().Error("Light Ethereum peer registration failed", "err", err) 284 return err 285 } 286 defer func() { 287 if pm.server != nil && pm.server.fcManager != nil && p.fcClient != nil { 288 p.fcClient.Remove(pm.server.fcManager) 289 } 290 pm.removePeer(p.id) 291 }() 292 // Register the peer in the downloader. If the downloader considers it banned, we disconnect 293 if pm.lightSync { 294 p.lock.Lock() 295 head := p.headInfo 296 p.lock.Unlock() 297 if pm.fetcher != nil { 298 pm.fetcher.announce(p, head) 299 } 300 301 if p.poolEntry != nil { 302 pm.serverPool.registered(p.poolEntry) 303 } 304 } 305 306 stop := make(chan struct{}) 307 defer close(stop) 308 go func() { 309 // new block announce loop 310 for { 311 select { 312 case announce := <-p.announceChn: 313 p.SendAnnounce(announce) 314 case <-stop: 315 return 316 } 317 } 318 }() 319 320 // main loop. handle incoming messages. 321 for { 322 if err := pm.handleMsg(p); err != nil { 323 p.Log().Debug("Light Ethereum message handling failed", "err", err) 324 return err 325 } 326 } 327 } 328 329 var reqList = []uint64{GetBlockHeadersMsg, GetBlockBodiesMsg, GetCodeMsg, GetReceiptsMsg, GetProofsV1Msg, SendTxMsg, SendTxV2Msg, GetTxStatusMsg, GetHeaderProofsMsg, GetProofsV2Msg, GetHelperTrieProofsMsg} 330 331 // handleMsg is invoked whenever an inbound message is received from a remote 332 // peer. The remote connection is torn down upon returning any error. 333 func (pm *ProtocolManager) handleMsg(p *peer) error { 334 // Read the next message from the remote peer, and ensure it's fully consumed 335 msg, err := p.rw.ReadMsg() 336 if err != nil { 337 return err 338 } 339 p.Log().Trace("Light Ethereum message arrived", "code", msg.Code, "bytes", msg.Size) 340 341 costs := p.fcCosts[msg.Code] 342 reject := func(reqCnt, maxCnt uint64) bool { 343 if p.fcClient == nil || reqCnt > maxCnt { 344 return true 345 } 346 bufValue, _ := p.fcClient.AcceptRequest() 347 cost := costs.baseCost + reqCnt*costs.reqCost 348 if cost > pm.server.defParams.BufLimit { 349 cost = pm.server.defParams.BufLimit 350 } 351 if cost > bufValue { 352 recharge := time.Duration((cost - bufValue) * 1000000 / pm.server.defParams.MinRecharge) 353 p.Log().Error("Request came too early", "recharge", common.PrettyDuration(recharge)) 354 return true 355 } 356 return false 357 } 358 359 if msg.Size > ProtocolMaxMsgSize { 360 return errResp(ErrMsgTooLarge, "%v > %v", msg.Size, ProtocolMaxMsgSize) 361 } 362 defer msg.Discard() 363 364 var deliverMsg *Msg 365 366 // Handle the message depending on its contents 367 switch msg.Code { 368 case StatusMsg: 369 p.Log().Trace("Received status message") 370 // Status messages should never arrive after the handshake 371 return errResp(ErrExtraStatusMsg, "uncontrolled status message") 372 373 // Block header query, collect the requested headers and reply 374 case AnnounceMsg: 375 p.Log().Trace("Received announce message") 376 if p.requestAnnounceType == announceTypeNone { 377 return errResp(ErrUnexpectedResponse, "") 378 } 379 380 var req announceData 381 if err := msg.Decode(&req); err != nil { 382 return errResp(ErrDecode, "%v: %v", msg, err) 383 } 384 385 if p.requestAnnounceType == announceTypeSigned { 386 if err := req.checkSignature(p.ID()); err != nil { 387 p.Log().Trace("Invalid announcement signature", "err", err) 388 return err 389 } 390 p.Log().Trace("Valid announcement signature") 391 } 392 393 p.Log().Trace("Announce message content", "number", req.Number, "hash", req.Hash, "td", req.Td, "reorg", req.ReorgDepth) 394 if pm.fetcher != nil { 395 pm.fetcher.announce(p, &req) 396 } 397 398 case GetBlockHeadersMsg: 399 p.Log().Trace("Received block header request") 400 // Decode the complex header query 401 var req struct { 402 ReqID uint64 403 Query getBlockHeadersData 404 } 405 if err := msg.Decode(&req); err != nil { 406 return errResp(ErrDecode, "%v: %v", msg, err) 407 } 408 409 query := req.Query 410 if reject(query.Amount, MaxHeaderFetch) { 411 return errResp(ErrRequestRejected, "") 412 } 413 414 hashMode := query.Origin.Hash != (common.Hash{}) 415 first := true 416 maxNonCanonical := uint64(100) 417 418 // Gather headers until the fetch or network limits is reached 419 var ( 420 bytes common.StorageSize 421 headers []types.HeaderIntf 422 unknown bool 423 ) 424 for !unknown && len(headers) < int(query.Amount) && bytes < softResponseLimit { 425 // Retrieve the next header satisfying the query 426 var origin types.HeaderIntf 427 if hashMode { 428 if first { 429 first = false 430 origin = pm.blockchain.GetHeaderByHash(query.Origin.Hash) 431 if origin != nil { 432 query.Origin.Number = origin.NumberU64() 433 } 434 } else { 435 origin = pm.blockchain.GetHeader(query.Origin.Hash, query.Origin.Number) 436 } 437 } else { 438 origin = pm.blockchain.GetHeaderByNumber(query.Origin.Number) 439 } 440 if origin == nil || reflect.ValueOf(origin).IsNil() { 441 break 442 } 443 headers = append(headers, origin) 444 bytes += estHeaderRlpSize 445 446 // Advance to the next header of the query 447 switch { 448 case hashMode && query.Reverse: 449 // Hash based traversal towards the genesis block 450 ancestor := query.Skip + 1 451 if ancestor == 0 { 452 unknown = true 453 } else { 454 query.Origin.Hash, query.Origin.Number = pm.blockchain.GetAncestor(query.Origin.Hash, query.Origin.Number, ancestor, &maxNonCanonical) 455 unknown = (query.Origin.Hash == common.Hash{}) 456 } 457 case hashMode && !query.Reverse: 458 // Hash based traversal towards the leaf block 459 var ( 460 current = origin.NumberU64() 461 next = current + query.Skip + 1 462 ) 463 if next <= current { 464 infos, _ := json.MarshalIndent(p.Peer.Info(), "", " ") 465 p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next, "attacker", infos) 466 unknown = true 467 } else { 468 if header := pm.blockchain.GetHeaderByNumber(next); header != nil { 469 nextHash := header.Hash() 470 expOldHash, _ := pm.blockchain.GetAncestor(nextHash, next, query.Skip+1, &maxNonCanonical) 471 if expOldHash == query.Origin.Hash { 472 query.Origin.Hash, query.Origin.Number = nextHash, next 473 } else { 474 unknown = true 475 } 476 } else { 477 unknown = true 478 } 479 } 480 case query.Reverse: 481 // Number based traversal towards the genesis block 482 if query.Origin.Number >= query.Skip+1 { 483 query.Origin.Number -= query.Skip + 1 484 } else { 485 unknown = true 486 } 487 488 case !query.Reverse: 489 // Number based traversal towards the leaf block 490 query.Origin.Number += query.Skip + 1 491 } 492 } 493 494 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + query.Amount*costs.reqCost) 495 pm.server.fcCostStats.update(msg.Code, query.Amount, rcost) 496 return p.SendBlockHeaders(req.ReqID, bv, headers) 497 498 case BlockHeadersMsg: 499 if pm.downloader == nil { 500 return errResp(ErrUnexpectedResponse, "") 501 } 502 503 p.Log().Trace("Received block header response message") 504 // A batch of headers arrived to one of our previous requests 505 var resp struct { 506 ReqID, BV uint64 507 Headers []types.HeaderIntf 508 } 509 if err := msg.Decode(&resp); err != nil { 510 return errResp(ErrDecode, "msg %v: %v", msg, err) 511 } 512 p.fcServer.GotReply(resp.ReqID, resp.BV) 513 if pm.fetcher != nil && pm.fetcher.requestedID(resp.ReqID) { 514 pm.fetcher.deliverHeaders(p, resp.ReqID, resp.Headers) 515 } else { 516 err := pm.downloader.DeliverHeaders(p.id, resp.Headers) 517 if err != nil { 518 log.Debug(fmt.Sprint(err)) 519 } 520 } 521 522 case GetBlockBodiesMsg: 523 p.Log().Trace("Received block bodies request") 524 // Decode the retrieval message 525 var req struct { 526 ReqID uint64 527 ShardId uint16 528 Hashes []common.Hash 529 } 530 if err := msg.Decode(&req); err != nil { 531 return errResp(ErrDecode, "msg %v: %v", msg, err) 532 } 533 // Gather blocks until the fetch or network limits is reached 534 var ( 535 bytes int 536 bodies []rlp.RawValue 537 ) 538 reqCnt := len(req.Hashes) 539 if reject(uint64(reqCnt), MaxBodyFetch) { 540 return errResp(ErrRequestRejected, "") 541 } 542 for _, hash := range req.Hashes { 543 if bytes >= softResponseLimit { 544 break 545 } 546 // Retrieve the requested block body, stopping if enough was found 547 if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil { 548 if data := rawdb.ReadBodyRLP(pm.chainDb, hash, *number); len(data) != 0 { 549 bodies = append(bodies, data) 550 bytes += len(data) 551 } 552 } 553 } 554 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 555 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 556 return p.SendBlockBodiesRLP(req.ReqID, bv, bodies) 557 558 case BlockBodiesMsg: 559 if pm.odr == nil { 560 return errResp(ErrUnexpectedResponse, "") 561 } 562 563 p.Log().Trace("Received block bodies response") 564 // A batch of block bodies arrived to one of our previous requests 565 var resp struct { 566 ReqID, BV uint64 567 Data []*types.Body 568 } 569 if err := msg.Decode(&resp); err != nil { 570 return errResp(ErrDecode, "msg %v: %v", msg, err) 571 } 572 p.fcServer.GotReply(resp.ReqID, resp.BV) 573 deliverMsg = &Msg{ 574 MsgType: MsgBlockBodies, 575 ReqID: resp.ReqID, 576 Obj: resp.Data, 577 } 578 579 case GetCodeMsg: 580 p.Log().Trace("Received code request") 581 // Decode the retrieval message 582 var reqm struct { 583 ReqID uint64 584 ShardId uint16 585 Reqs []CodeReq 586 } 587 if err := msg.Decode(&reqm); err != nil { 588 return errResp(ErrDecode, "msg %v: %v", msg, err) 589 } 590 // Gather state data until the fetch or network limits is reached 591 var ( 592 bytes int 593 data [][]byte 594 ) 595 reqCnt := len(reqm.Reqs) 596 if reject(uint64(reqCnt), MaxCodeFetch) { 597 return errResp(ErrRequestRejected, "") 598 } 599 for _, req := range reqm.Reqs { 600 // Retrieve the requested state entry, stopping if enough was found 601 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 602 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 603 statedb, err := pm.blockchain.State() 604 if err != nil { 605 continue 606 } 607 account, err := pm.getAccount(statedb, header.Root(), common.BytesToHash(req.AccKey)) 608 if err != nil { 609 continue 610 } 611 code, _ := statedb.Database().TrieDB().Node(common.BytesToHash(account.CodeHash)) 612 613 data = append(data, code) 614 if bytes += len(code); bytes >= softResponseLimit { 615 break 616 } 617 } 618 } 619 } 620 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 621 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 622 return p.SendCode(reqm.ReqID, bv, data) 623 624 case CodeMsg: 625 if pm.odr == nil { 626 return errResp(ErrUnexpectedResponse, "") 627 } 628 629 p.Log().Trace("Received code response") 630 // A batch of node state data arrived to one of our previous requests 631 var resp struct { 632 ReqID, BV uint64 633 Data [][]byte 634 } 635 if err := msg.Decode(&resp); err != nil { 636 return errResp(ErrDecode, "msg %v: %v", msg, err) 637 } 638 p.fcServer.GotReply(resp.ReqID, resp.BV) 639 deliverMsg = &Msg{ 640 MsgType: MsgCode, 641 ReqID: resp.ReqID, 642 Obj: resp.Data, 643 } 644 645 case GetReceiptsMsg: 646 p.Log().Trace("Received receipts request") 647 // Decode the retrieval message 648 var req struct { 649 ReqID uint64 650 ShardId uint16 651 Hashes []common.Hash 652 } 653 if err := msg.Decode(&req); err != nil { 654 return errResp(ErrDecode, "msg %v: %v", msg, err) 655 } 656 // Gather state data until the fetch or network limits is reached 657 var ( 658 bytes int 659 receipts []rlp.RawValue 660 ) 661 reqCnt := len(req.Hashes) 662 if reject(uint64(reqCnt), MaxReceiptFetch) { 663 return errResp(ErrRequestRejected, "") 664 } 665 for _, hash := range req.Hashes { 666 if bytes >= softResponseLimit { 667 break 668 } 669 // Retrieve the requested block's receipts, skipping if unknown to us 670 var results types.Receipts 671 if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil { 672 results = rawdb.ReadReceipts(pm.chainDb, hash, *number) 673 } 674 if results == nil { 675 if header := pm.blockchain.GetHeaderByHash(hash); header == nil || reflect.ValueOf(header).IsNil() || header.ReceiptHash() != types.EmptyRootHash { 676 continue 677 } 678 } 679 // If known, encode and queue for response packet 680 if encoded, err := rlp.EncodeToBytes(results); err != nil { 681 log.Error("Failed to encode receipt", "err", err) 682 } else { 683 receipts = append(receipts, encoded) 684 bytes += len(encoded) 685 } 686 } 687 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 688 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 689 return p.SendReceiptsRLP(req.ReqID, bv, receipts) 690 691 case ReceiptsMsg: 692 if pm.odr == nil { 693 return errResp(ErrUnexpectedResponse, "") 694 } 695 696 p.Log().Trace("Received receipts response") 697 // A batch of receipts arrived to one of our previous requests 698 var resp struct { 699 ReqID, BV uint64 700 Receipts []types.Receipts 701 } 702 if err := msg.Decode(&resp); err != nil { 703 return errResp(ErrDecode, "msg %v: %v", msg, err) 704 } 705 p.fcServer.GotReply(resp.ReqID, resp.BV) 706 deliverMsg = &Msg{ 707 MsgType: MsgReceipts, 708 ReqID: resp.ReqID, 709 Obj: resp.Receipts, 710 } 711 712 case GetProofsV1Msg: 713 p.Log().Trace("Received proofs request") 714 // Decode the retrieval message 715 var reqm struct { 716 ReqID uint64 717 ShardId uint16 718 Reqs []ProofReq 719 } 720 if err := msg.Decode(&reqm); err != nil { 721 return errResp(ErrDecode, "msg %v: %v", msg, err) 722 } 723 // Gather state data until the fetch or network limits is reached 724 var ( 725 bytes int 726 proofs proofsData 727 ) 728 reqCnt := len(reqm.Reqs) 729 if reject(uint64(reqCnt), MaxProofsFetch) { 730 return errResp(ErrRequestRejected, "") 731 } 732 for _, req := range reqm.Reqs { 733 // Retrieve the requested state entry, stopping if enough was found 734 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 735 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 736 statedb, err := pm.blockchain.State() 737 if err != nil { 738 continue 739 } 740 var trie state.Trie 741 if len(req.AccKey) > 0 { 742 account, err := pm.getAccount(statedb, header.Root(), common.BytesToHash(req.AccKey)) 743 if err != nil { 744 continue 745 } 746 trie, _ = statedb.Database().OpenStorageTrie(common.BytesToHash(req.AccKey), account.Root) 747 } else { 748 trie, _ = statedb.Database().OpenTrie(header.Root()) 749 } 750 if trie != nil { 751 var proof light.NodeList 752 trie.Prove(req.Key, 0, &proof) 753 754 proofs = append(proofs, proof) 755 if bytes += proof.DataSize(); bytes >= softResponseLimit { 756 break 757 } 758 } 759 } 760 } 761 } 762 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 763 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 764 return p.SendProofs(reqm.ReqID, bv, proofs) 765 766 case GetProofsV2Msg: 767 p.Log().Trace("Received les/2 proofs request") 768 // Decode the retrieval message 769 var reqm struct { 770 ReqID uint64 771 ShardId uint16 772 Reqs []ProofReq 773 } 774 if err := msg.Decode(&reqm); err != nil { 775 return errResp(ErrDecode, "msg %v: %v", msg, err) 776 } 777 // Gather state data until the fetch or network limits is reached 778 var ( 779 lastBHash common.Hash 780 statedb *state.StateDB 781 root common.Hash 782 ) 783 reqCnt := len(reqm.Reqs) 784 if reject(uint64(reqCnt), MaxProofsFetch) { 785 return errResp(ErrRequestRejected, "") 786 } 787 788 nodes := light.NewNodeSet() 789 790 for _, req := range reqm.Reqs { 791 // Look up the state belonging to the request 792 if statedb == nil || req.BHash != lastBHash { 793 statedb, root, lastBHash = nil, common.Hash{}, req.BHash 794 795 if number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number != nil { 796 if header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header != nil { 797 statedb, _ = pm.blockchain.State() 798 root = header.Root() 799 } 800 } 801 } 802 if statedb == nil { 803 continue 804 } 805 // Pull the account or storage trie of the request 806 var trie state.Trie 807 if len(req.AccKey) > 0 { 808 account, err := pm.getAccount(statedb, root, common.BytesToHash(req.AccKey)) 809 if err != nil { 810 continue 811 } 812 trie, _ = statedb.Database().OpenStorageTrie(common.BytesToHash(req.AccKey), account.Root) 813 } else { 814 trie, _ = statedb.Database().OpenTrie(root) 815 } 816 if trie == nil { 817 continue 818 } 819 // Prove the user's request from the account or stroage trie 820 trie.Prove(req.Key, req.FromLevel, nodes) 821 if nodes.DataSize() >= softResponseLimit { 822 break 823 } 824 } 825 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 826 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 827 return p.SendProofsV2(reqm.ReqID, bv, nodes.NodeList()) 828 829 case ProofsV1Msg: 830 if pm.odr == nil { 831 return errResp(ErrUnexpectedResponse, "") 832 } 833 834 p.Log().Trace("Received proofs response") 835 // A batch of merkle proofs arrived to one of our previous requests 836 var resp struct { 837 ReqID, BV uint64 838 Data []light.NodeList 839 } 840 if err := msg.Decode(&resp); err != nil { 841 return errResp(ErrDecode, "msg %v: %v", msg, err) 842 } 843 p.fcServer.GotReply(resp.ReqID, resp.BV) 844 deliverMsg = &Msg{ 845 MsgType: MsgProofsV1, 846 ReqID: resp.ReqID, 847 Obj: resp.Data, 848 } 849 850 case ProofsV2Msg: 851 if pm.odr == nil { 852 return errResp(ErrUnexpectedResponse, "") 853 } 854 855 p.Log().Trace("Received les/2 proofs response") 856 // A batch of merkle proofs arrived to one of our previous requests 857 var resp struct { 858 ReqID, BV uint64 859 Data light.NodeList 860 } 861 if err := msg.Decode(&resp); err != nil { 862 return errResp(ErrDecode, "msg %v: %v", msg, err) 863 } 864 p.fcServer.GotReply(resp.ReqID, resp.BV) 865 deliverMsg = &Msg{ 866 MsgType: MsgProofsV2, 867 ReqID: resp.ReqID, 868 Obj: resp.Data, 869 } 870 871 case GetHeaderProofsMsg: 872 p.Log().Trace("Received headers proof request") 873 // Decode the retrieval message 874 var reqm struct { 875 ReqID uint64 876 ShardId uint16 877 Reqs []ChtReq 878 } 879 if err := msg.Decode(&reqm); err != nil { 880 return errResp(ErrDecode, "msg %v: %v", msg, err) 881 } 882 // Gather state data until the fetch or network limits is reached 883 var ( 884 bytes int 885 proofs []ChtResp 886 ) 887 reqCnt := len(reqm.Reqs) 888 if reject(uint64(reqCnt), MaxHelperTrieProofsFetch) { 889 return errResp(ErrRequestRejected, "") 890 } 891 trieDb := trie.NewDatabase(ethdb.NewTable(pm.chainDb, light.ChtTablePrefix)) 892 for _, req := range reqm.Reqs { 893 if header := pm.blockchain.GetHeaderByNumber(req.BlockNum); header != nil { 894 sectionHead := rawdb.ReadCanonicalHash(pm.chainDb, reqm.ShardId, req.ChtNum*pm.iConfig.ChtSize-1) 895 if root := light.GetChtRoot(pm.chainDb, req.ChtNum-1, sectionHead); root != (common.Hash{}) { 896 trie, err := trie.New(root, trieDb) 897 if err != nil { 898 continue 899 } 900 var encNumber [8]byte 901 binary.BigEndian.PutUint64(encNumber[:], req.BlockNum) 902 903 var proof light.NodeList 904 trie.Prove(encNumber[:], 0, &proof) 905 906 proofs = append(proofs, ChtResp{Header: header, Proof: proof}) 907 if bytes += proof.DataSize() + estHeaderRlpSize; bytes >= softResponseLimit { 908 break 909 } 910 } 911 } 912 } 913 bv, rcost := p.fcClient.RequestProcessed(costs.baseCost + uint64(reqCnt)*costs.reqCost) 914 pm.server.fcCostStats.update(msg.Code, uint64(reqCnt), rcost) 915 return p.SendHeaderProofs(reqm.ReqID, bv, proofs) 916 917 case GetHelperTrieProofsMsg: 918 p.Log().Trace("Received helper trie proof request") 919 // Decode the retrieval message 920 var reqm struct { 921 ReqID uint64 922 ShardId uint16 923 Reqs []HelperTrieReq 924 } 925 if err := msg.Decode(&reqm); 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(reqm.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 reqm.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, reqm.ShardId); 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, reqm.ShardId) 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(reqm.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, shardId uint16) (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, shardId, (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, shardId, (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, shardId uint16) []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, shardId, 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 shardId, block, number, index := rawdb.ReadTxLookupEntry(pm.chainDb, hashes[i]); block != (common.Hash{}) { 1179 // stats[i].Status = core.TxStatusIncluded 1180 // stats[i].Lookup = &rawdb.TxLookupEntry{ShardId: shardId, 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(shardId uint16) (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, shardId uint16) 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, shardId) } 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 }