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