|
|
@@ -34,6 +34,7 @@ import (
|
|
|
"github.com/ethereum/go-ethereum/eth/downloader"
|
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
|
"github.com/ethereum/go-ethereum/event"
|
|
|
+ "github.com/ethereum/go-ethereum/les/csvlogger"
|
|
|
"github.com/ethereum/go-ethereum/light"
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
|
"github.com/ethereum/go-ethereum/p2p"
|
|
|
@@ -118,6 +119,7 @@ type ProtocolManager struct {
|
|
|
|
|
|
wg *sync.WaitGroup
|
|
|
eventMux *event.TypeMux
|
|
|
+ logger *csvlogger.Logger
|
|
|
|
|
|
// Callbacks
|
|
|
synced func() bool
|
|
|
@@ -165,8 +167,6 @@ func NewProtocolManager(
|
|
|
if odr != nil {
|
|
|
manager.retriever = odr.retriever
|
|
|
manager.reqDist = odr.retriever.dist
|
|
|
- } else {
|
|
|
- manager.servingQueue = newServingQueue(int64(time.Millisecond * 10))
|
|
|
}
|
|
|
|
|
|
if ulcConfig != nil {
|
|
|
@@ -272,6 +272,7 @@ func (pm *ProtocolManager) handle(p *peer) error {
|
|
|
// Ignore maxPeers if this is a trusted peer
|
|
|
// In server mode we try to check into the client pool after handshake
|
|
|
if pm.client && pm.peers.Len() >= pm.maxPeers && !p.Peer.Info().Network.Trusted {
|
|
|
+ pm.logger.Event("Rejected (too many peers), " + p.id)
|
|
|
return p2p.DiscTooManyPeers
|
|
|
}
|
|
|
// Reject light clients if server is not synced.
|
|
|
@@ -290,6 +291,7 @@ func (pm *ProtocolManager) handle(p *peer) error {
|
|
|
)
|
|
|
if err := p.Handshake(td, hash, number, genesis.Hash(), pm.server); err != nil {
|
|
|
p.Log().Debug("Light Ethereum handshake failed", "err", err)
|
|
|
+ pm.logger.Event("Handshake error: " + err.Error() + ", " + p.id)
|
|
|
return err
|
|
|
}
|
|
|
if p.fcClient != nil {
|
|
|
@@ -303,9 +305,12 @@ func (pm *ProtocolManager) handle(p *peer) error {
|
|
|
// Register the peer locally
|
|
|
if err := pm.peers.Register(p); err != nil {
|
|
|
p.Log().Error("Light Ethereum peer registration failed", "err", err)
|
|
|
+ pm.logger.Event("Peer registration error: " + err.Error() + ", " + p.id)
|
|
|
return err
|
|
|
}
|
|
|
+ pm.logger.Event("Connection established, " + p.id)
|
|
|
defer func() {
|
|
|
+ pm.logger.Event("Closed connection, " + p.id)
|
|
|
pm.removePeer(p.id)
|
|
|
}()
|
|
|
|
|
|
@@ -326,6 +331,7 @@ func (pm *ProtocolManager) handle(p *peer) error {
|
|
|
// main loop. handle incoming messages.
|
|
|
for {
|
|
|
if err := pm.handleMsg(p); err != nil {
|
|
|
+ pm.logger.Event("Message handling error: " + err.Error() + ", " + p.id)
|
|
|
p.Log().Debug("Light Ethereum message handling failed", "err", err)
|
|
|
if p.fcServer != nil {
|
|
|
p.fcServer.DumpLogs()
|
|
|
@@ -358,23 +364,40 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
)
|
|
|
|
|
|
accept := func(reqID, reqCnt, maxCnt uint64) bool {
|
|
|
- if reqCnt == 0 {
|
|
|
- return false
|
|
|
+ inSizeCost := func() uint64 {
|
|
|
+ if pm.server.costTracker != nil {
|
|
|
+ return pm.server.costTracker.realCost(0, msg.Size, 0)
|
|
|
+ }
|
|
|
+ return 0
|
|
|
}
|
|
|
- if p.fcClient == nil || reqCnt > maxCnt {
|
|
|
+ if p.isFrozen() || reqCnt == 0 || p.fcClient == nil || reqCnt > maxCnt {
|
|
|
+ p.fcClient.OneTimeCost(inSizeCost())
|
|
|
return false
|
|
|
}
|
|
|
- maxCost = p.fcCosts.getCost(msg.Code, reqCnt)
|
|
|
+ maxCost = p.fcCosts.getMaxCost(msg.Code, reqCnt)
|
|
|
+ gf := float64(1)
|
|
|
+ if pm.server.costTracker != nil {
|
|
|
+ gf = pm.server.costTracker.globalFactor()
|
|
|
+ if gf < 0.001 {
|
|
|
+ p.Log().Error("Invalid global cost factor", "globalFactor", gf)
|
|
|
+ gf = 1
|
|
|
+ }
|
|
|
+ }
|
|
|
+ maxTime := uint64(float64(maxCost) / gf)
|
|
|
|
|
|
if accepted, bufShort, servingPriority := p.fcClient.AcceptRequest(reqID, responseCount, maxCost); !accepted {
|
|
|
- if bufShort > 0 {
|
|
|
- p.Log().Error("Request came too early", "remaining", common.PrettyDuration(time.Duration(bufShort*1000000/p.fcParams.MinRecharge)))
|
|
|
- }
|
|
|
+ p.freezeClient()
|
|
|
+ p.Log().Warn("Request came too early", "remaining", common.PrettyDuration(time.Duration(bufShort*1000000/p.fcParams.MinRecharge)))
|
|
|
+ p.fcClient.OneTimeCost(inSizeCost())
|
|
|
return false
|
|
|
} else {
|
|
|
- task = pm.servingQueue.newTask(servingPriority)
|
|
|
+ task = pm.servingQueue.newTask(p, maxTime, servingPriority)
|
|
|
+ }
|
|
|
+ if task.start() {
|
|
|
+ return true
|
|
|
}
|
|
|
- return task.start()
|
|
|
+ p.fcClient.RequestProcessed(reqID, responseCount, maxCost, inSizeCost())
|
|
|
+ return false
|
|
|
}
|
|
|
|
|
|
if msg.Size > ProtocolMaxMsgSize {
|
|
|
@@ -388,6 +411,10 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
p.responseLock.Lock()
|
|
|
defer p.responseLock.Unlock()
|
|
|
|
|
|
+ if p.isFrozen() {
|
|
|
+ amount = 0
|
|
|
+ reply = nil
|
|
|
+ }
|
|
|
var replySize uint32
|
|
|
if reply != nil {
|
|
|
replySize = reply.size()
|
|
|
@@ -395,7 +422,9 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
var realCost uint64
|
|
|
if pm.server.costTracker != nil {
|
|
|
realCost = pm.server.costTracker.realCost(servingTime, msg.Size, replySize)
|
|
|
- pm.server.costTracker.updateStats(msg.Code, amount, servingTime, realCost)
|
|
|
+ if amount != 0 {
|
|
|
+ pm.server.costTracker.updateStats(msg.Code, amount, servingTime, realCost)
|
|
|
+ }
|
|
|
} else {
|
|
|
realCost = maxCost
|
|
|
}
|
|
|
@@ -463,94 +492,94 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
}
|
|
|
|
|
|
query := req.Query
|
|
|
- if !accept(req.ReqID, query.Amount, MaxHeaderFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- hashMode := query.Origin.Hash != (common.Hash{})
|
|
|
- first := true
|
|
|
- maxNonCanonical := uint64(100)
|
|
|
-
|
|
|
- // Gather headers until the fetch or network limits is reached
|
|
|
- var (
|
|
|
- bytes common.StorageSize
|
|
|
- headers []*types.Header
|
|
|
- unknown bool
|
|
|
- )
|
|
|
- for !unknown && len(headers) < int(query.Amount) && bytes < softResponseLimit {
|
|
|
- if !first && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- // Retrieve the next header satisfying the query
|
|
|
- var origin *types.Header
|
|
|
- if hashMode {
|
|
|
- if first {
|
|
|
- origin = pm.blockchain.GetHeaderByHash(query.Origin.Hash)
|
|
|
- if origin != nil {
|
|
|
- query.Origin.Number = origin.Number.Uint64()
|
|
|
+ if accept(req.ReqID, query.Amount, MaxHeaderFetch) {
|
|
|
+ go func() {
|
|
|
+ hashMode := query.Origin.Hash != (common.Hash{})
|
|
|
+ first := true
|
|
|
+ maxNonCanonical := uint64(100)
|
|
|
+
|
|
|
+ // Gather headers until the fetch or network limits is reached
|
|
|
+ var (
|
|
|
+ bytes common.StorageSize
|
|
|
+ headers []*types.Header
|
|
|
+ unknown bool
|
|
|
+ )
|
|
|
+ for !unknown && len(headers) < int(query.Amount) && bytes < softResponseLimit {
|
|
|
+ if !first && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ // Retrieve the next header satisfying the query
|
|
|
+ var origin *types.Header
|
|
|
+ if hashMode {
|
|
|
+ if first {
|
|
|
+ origin = pm.blockchain.GetHeaderByHash(query.Origin.Hash)
|
|
|
+ if origin != nil {
|
|
|
+ query.Origin.Number = origin.Number.Uint64()
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ origin = pm.blockchain.GetHeader(query.Origin.Hash, query.Origin.Number)
|
|
|
}
|
|
|
} else {
|
|
|
- origin = pm.blockchain.GetHeader(query.Origin.Hash, query.Origin.Number)
|
|
|
+ origin = pm.blockchain.GetHeaderByNumber(query.Origin.Number)
|
|
|
}
|
|
|
- } else {
|
|
|
- origin = pm.blockchain.GetHeaderByNumber(query.Origin.Number)
|
|
|
- }
|
|
|
- if origin == nil {
|
|
|
- break
|
|
|
- }
|
|
|
- headers = append(headers, origin)
|
|
|
- bytes += estHeaderRlpSize
|
|
|
-
|
|
|
- // Advance to the next header of the query
|
|
|
- switch {
|
|
|
- case hashMode && query.Reverse:
|
|
|
- // Hash based traversal towards the genesis block
|
|
|
- ancestor := query.Skip + 1
|
|
|
- if ancestor == 0 {
|
|
|
- unknown = true
|
|
|
- } else {
|
|
|
- query.Origin.Hash, query.Origin.Number = pm.blockchain.GetAncestor(query.Origin.Hash, query.Origin.Number, ancestor, &maxNonCanonical)
|
|
|
- unknown = (query.Origin.Hash == common.Hash{})
|
|
|
+ if origin == nil {
|
|
|
+ break
|
|
|
}
|
|
|
- case hashMode && !query.Reverse:
|
|
|
- // Hash based traversal towards the leaf block
|
|
|
- var (
|
|
|
- current = origin.Number.Uint64()
|
|
|
- next = current + query.Skip + 1
|
|
|
- )
|
|
|
- if next <= current {
|
|
|
- infos, _ := json.MarshalIndent(p.Peer.Info(), "", " ")
|
|
|
- p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next, "attacker", infos)
|
|
|
- unknown = true
|
|
|
- } else {
|
|
|
- if header := pm.blockchain.GetHeaderByNumber(next); header != nil {
|
|
|
- nextHash := header.Hash()
|
|
|
- expOldHash, _ := pm.blockchain.GetAncestor(nextHash, next, query.Skip+1, &maxNonCanonical)
|
|
|
- if expOldHash == query.Origin.Hash {
|
|
|
- query.Origin.Hash, query.Origin.Number = nextHash, next
|
|
|
+ headers = append(headers, origin)
|
|
|
+ bytes += estHeaderRlpSize
|
|
|
+
|
|
|
+ // Advance to the next header of the query
|
|
|
+ switch {
|
|
|
+ case hashMode && query.Reverse:
|
|
|
+ // Hash based traversal towards the genesis block
|
|
|
+ ancestor := query.Skip + 1
|
|
|
+ if ancestor == 0 {
|
|
|
+ unknown = true
|
|
|
+ } else {
|
|
|
+ query.Origin.Hash, query.Origin.Number = pm.blockchain.GetAncestor(query.Origin.Hash, query.Origin.Number, ancestor, &maxNonCanonical)
|
|
|
+ unknown = (query.Origin.Hash == common.Hash{})
|
|
|
+ }
|
|
|
+ case hashMode && !query.Reverse:
|
|
|
+ // Hash based traversal towards the leaf block
|
|
|
+ var (
|
|
|
+ current = origin.Number.Uint64()
|
|
|
+ next = current + query.Skip + 1
|
|
|
+ )
|
|
|
+ if next <= current {
|
|
|
+ infos, _ := json.MarshalIndent(p.Peer.Info(), "", " ")
|
|
|
+ p.Log().Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next, "attacker", infos)
|
|
|
+ unknown = true
|
|
|
+ } else {
|
|
|
+ if header := pm.blockchain.GetHeaderByNumber(next); header != nil {
|
|
|
+ nextHash := header.Hash()
|
|
|
+ expOldHash, _ := pm.blockchain.GetAncestor(nextHash, next, query.Skip+1, &maxNonCanonical)
|
|
|
+ if expOldHash == query.Origin.Hash {
|
|
|
+ query.Origin.Hash, query.Origin.Number = nextHash, next
|
|
|
+ } else {
|
|
|
+ unknown = true
|
|
|
+ }
|
|
|
} else {
|
|
|
unknown = true
|
|
|
}
|
|
|
+ }
|
|
|
+ case query.Reverse:
|
|
|
+ // Number based traversal towards the genesis block
|
|
|
+ if query.Origin.Number >= query.Skip+1 {
|
|
|
+ query.Origin.Number -= query.Skip + 1
|
|
|
} else {
|
|
|
unknown = true
|
|
|
}
|
|
|
- }
|
|
|
- case query.Reverse:
|
|
|
- // Number based traversal towards the genesis block
|
|
|
- if query.Origin.Number >= query.Skip+1 {
|
|
|
- query.Origin.Number -= query.Skip + 1
|
|
|
- } else {
|
|
|
- unknown = true
|
|
|
- }
|
|
|
|
|
|
- case !query.Reverse:
|
|
|
- // Number based traversal towards the leaf block
|
|
|
- query.Origin.Number += query.Skip + 1
|
|
|
+ case !query.Reverse:
|
|
|
+ // Number based traversal towards the leaf block
|
|
|
+ query.Origin.Number += query.Skip + 1
|
|
|
+ }
|
|
|
+ first = false
|
|
|
}
|
|
|
- first = false
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, query.Amount, p.ReplyBlockHeaders(req.ReqID, headers), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, query.Amount, p.ReplyBlockHeaders(req.ReqID, headers), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case BlockHeadersMsg:
|
|
|
if pm.downloader == nil {
|
|
|
@@ -592,27 +621,27 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
bodies []rlp.RawValue
|
|
|
)
|
|
|
reqCnt := len(req.Hashes)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxBodyFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- for i, hash := range req.Hashes {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- if bytes >= softResponseLimit {
|
|
|
- break
|
|
|
- }
|
|
|
- // Retrieve the requested block body, stopping if enough was found
|
|
|
- if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil {
|
|
|
- if data := rawdb.ReadBodyRLP(pm.chainDb, hash, *number); len(data) != 0 {
|
|
|
- bodies = append(bodies, data)
|
|
|
- bytes += len(data)
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxBodyFetch) {
|
|
|
+ go func() {
|
|
|
+ for i, hash := range req.Hashes {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ if bytes >= softResponseLimit {
|
|
|
+ break
|
|
|
+ }
|
|
|
+ // Retrieve the requested block body, stopping if enough was found
|
|
|
+ if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil {
|
|
|
+ if data := rawdb.ReadBodyRLP(pm.chainDb, hash, *number); len(data) != 0 {
|
|
|
+ bodies = append(bodies, data)
|
|
|
+ bytes += len(data)
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyBlockBodiesRLP(req.ReqID, bodies), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyBlockBodiesRLP(req.ReqID, bodies), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case BlockBodiesMsg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -651,45 +680,45 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
data [][]byte
|
|
|
)
|
|
|
reqCnt := len(req.Reqs)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxCodeFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- for i, req := range req.Reqs {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- // Look up the root hash belonging to the request
|
|
|
- number := rawdb.ReadHeaderNumber(pm.chainDb, req.BHash)
|
|
|
- if number == nil {
|
|
|
- p.Log().Warn("Failed to retrieve block num for code", "hash", req.BHash)
|
|
|
- continue
|
|
|
- }
|
|
|
- header := rawdb.ReadHeader(pm.chainDb, req.BHash, *number)
|
|
|
- if header == nil {
|
|
|
- p.Log().Warn("Failed to retrieve header for code", "block", *number, "hash", req.BHash)
|
|
|
- continue
|
|
|
- }
|
|
|
- triedb := pm.blockchain.StateCache().TrieDB()
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxCodeFetch) {
|
|
|
+ go func() {
|
|
|
+ for i, request := range req.Reqs {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ // Look up the root hash belonging to the request
|
|
|
+ number := rawdb.ReadHeaderNumber(pm.chainDb, request.BHash)
|
|
|
+ if number == nil {
|
|
|
+ p.Log().Warn("Failed to retrieve block num for code", "hash", request.BHash)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ header := rawdb.ReadHeader(pm.chainDb, request.BHash, *number)
|
|
|
+ if header == nil {
|
|
|
+ p.Log().Warn("Failed to retrieve header for code", "block", *number, "hash", request.BHash)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ triedb := pm.blockchain.StateCache().TrieDB()
|
|
|
|
|
|
- account, err := pm.getAccount(triedb, header.Root, common.BytesToHash(req.AccKey))
|
|
|
- if err != nil {
|
|
|
- p.Log().Warn("Failed to retrieve account for code", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(req.AccKey), "err", err)
|
|
|
- continue
|
|
|
- }
|
|
|
- code, err := triedb.Node(common.BytesToHash(account.CodeHash))
|
|
|
- if err != nil {
|
|
|
- p.Log().Warn("Failed to retrieve account code", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(req.AccKey), "codehash", common.BytesToHash(account.CodeHash), "err", err)
|
|
|
- continue
|
|
|
- }
|
|
|
- // Accumulate the code and abort if enough data was retrieved
|
|
|
- data = append(data, code)
|
|
|
- if bytes += len(code); bytes >= softResponseLimit {
|
|
|
- break
|
|
|
+ account, err := pm.getAccount(triedb, header.Root, common.BytesToHash(request.AccKey))
|
|
|
+ if err != nil {
|
|
|
+ p.Log().Warn("Failed to retrieve account for code", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(request.AccKey), "err", err)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ code, err := triedb.Node(common.BytesToHash(account.CodeHash))
|
|
|
+ if err != nil {
|
|
|
+ p.Log().Warn("Failed to retrieve account code", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(request.AccKey), "codehash", common.BytesToHash(account.CodeHash), "err", err)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ // Accumulate the code and abort if enough data was retrieved
|
|
|
+ data = append(data, code)
|
|
|
+ if bytes += len(code); bytes >= softResponseLimit {
|
|
|
+ break
|
|
|
+ }
|
|
|
}
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyCode(req.ReqID, data), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyCode(req.ReqID, data), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case CodeMsg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -728,37 +757,37 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
receipts []rlp.RawValue
|
|
|
)
|
|
|
reqCnt := len(req.Hashes)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxReceiptFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- for i, hash := range req.Hashes {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- if bytes >= softResponseLimit {
|
|
|
- break
|
|
|
- }
|
|
|
- // Retrieve the requested block's receipts, skipping if unknown to us
|
|
|
- var results types.Receipts
|
|
|
- if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil {
|
|
|
- results = rawdb.ReadRawReceipts(pm.chainDb, hash, *number)
|
|
|
- }
|
|
|
- if results == nil {
|
|
|
- if header := pm.blockchain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash {
|
|
|
- continue
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxReceiptFetch) {
|
|
|
+ go func() {
|
|
|
+ for i, hash := range req.Hashes {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ if bytes >= softResponseLimit {
|
|
|
+ break
|
|
|
+ }
|
|
|
+ // Retrieve the requested block's receipts, skipping if unknown to us
|
|
|
+ var results types.Receipts
|
|
|
+ if number := rawdb.ReadHeaderNumber(pm.chainDb, hash); number != nil {
|
|
|
+ results = rawdb.ReadRawReceipts(pm.chainDb, hash, *number)
|
|
|
+ }
|
|
|
+ if results == nil {
|
|
|
+ if header := pm.blockchain.GetHeaderByHash(hash); header == nil || header.ReceiptHash != types.EmptyRootHash {
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // If known, encode and queue for response packet
|
|
|
+ if encoded, err := rlp.EncodeToBytes(results); err != nil {
|
|
|
+ log.Error("Failed to encode receipt", "err", err)
|
|
|
+ } else {
|
|
|
+ receipts = append(receipts, encoded)
|
|
|
+ bytes += len(encoded)
|
|
|
}
|
|
|
}
|
|
|
- // If known, encode and queue for response packet
|
|
|
- if encoded, err := rlp.EncodeToBytes(results); err != nil {
|
|
|
- log.Error("Failed to encode receipt", "err", err)
|
|
|
- } else {
|
|
|
- receipts = append(receipts, encoded)
|
|
|
- bytes += len(encoded)
|
|
|
- }
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyReceiptsRLP(req.ReqID, receipts), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyReceiptsRLP(req.ReqID, receipts), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case ReceiptsMsg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -797,70 +826,70 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
root common.Hash
|
|
|
)
|
|
|
reqCnt := len(req.Reqs)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxProofsFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- nodes := light.NewNodeSet()
|
|
|
-
|
|
|
- for i, req := range req.Reqs {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- // Look up the root hash belonging to the request
|
|
|
- var (
|
|
|
- number *uint64
|
|
|
- header *types.Header
|
|
|
- trie state.Trie
|
|
|
- )
|
|
|
- if req.BHash != lastBHash {
|
|
|
- root, lastBHash = common.Hash{}, req.BHash
|
|
|
-
|
|
|
- if number = rawdb.ReadHeaderNumber(pm.chainDb, req.BHash); number == nil {
|
|
|
- p.Log().Warn("Failed to retrieve block num for proof", "hash", req.BHash)
|
|
|
- continue
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxProofsFetch) {
|
|
|
+ go func() {
|
|
|
+ nodes := light.NewNodeSet()
|
|
|
+
|
|
|
+ for i, request := range req.Reqs {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
}
|
|
|
- if header = rawdb.ReadHeader(pm.chainDb, req.BHash, *number); header == nil {
|
|
|
- p.Log().Warn("Failed to retrieve header for proof", "block", *number, "hash", req.BHash)
|
|
|
- continue
|
|
|
+ // Look up the root hash belonging to the request
|
|
|
+ var (
|
|
|
+ number *uint64
|
|
|
+ header *types.Header
|
|
|
+ trie state.Trie
|
|
|
+ )
|
|
|
+ if request.BHash != lastBHash {
|
|
|
+ root, lastBHash = common.Hash{}, request.BHash
|
|
|
+
|
|
|
+ if number = rawdb.ReadHeaderNumber(pm.chainDb, request.BHash); number == nil {
|
|
|
+ p.Log().Warn("Failed to retrieve block num for proof", "hash", request.BHash)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ if header = rawdb.ReadHeader(pm.chainDb, request.BHash, *number); header == nil {
|
|
|
+ p.Log().Warn("Failed to retrieve header for proof", "block", *number, "hash", request.BHash)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ root = header.Root
|
|
|
}
|
|
|
- root = header.Root
|
|
|
- }
|
|
|
- // Open the account or storage trie for the request
|
|
|
- statedb := pm.blockchain.StateCache()
|
|
|
-
|
|
|
- switch len(req.AccKey) {
|
|
|
- case 0:
|
|
|
- // No account key specified, open an account trie
|
|
|
- trie, err = statedb.OpenTrie(root)
|
|
|
- if trie == nil || err != nil {
|
|
|
- p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "root", root, "err", err)
|
|
|
- continue
|
|
|
+ // Open the account or storage trie for the request
|
|
|
+ statedb := pm.blockchain.StateCache()
|
|
|
+
|
|
|
+ switch len(request.AccKey) {
|
|
|
+ case 0:
|
|
|
+ // No account key specified, open an account trie
|
|
|
+ trie, err = statedb.OpenTrie(root)
|
|
|
+ if trie == nil || err != nil {
|
|
|
+ p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "root", root, "err", err)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ default:
|
|
|
+ // Account key specified, open a storage trie
|
|
|
+ account, err := pm.getAccount(statedb.TrieDB(), root, common.BytesToHash(request.AccKey))
|
|
|
+ if err != nil {
|
|
|
+ p.Log().Warn("Failed to retrieve account for proof", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(request.AccKey), "err", err)
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ trie, err = statedb.OpenStorageTrie(common.BytesToHash(request.AccKey), account.Root)
|
|
|
+ if trie == nil || err != nil {
|
|
|
+ p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(request.AccKey), "root", account.Root, "err", err)
|
|
|
+ continue
|
|
|
+ }
|
|
|
}
|
|
|
- default:
|
|
|
- // Account key specified, open a storage trie
|
|
|
- account, err := pm.getAccount(statedb.TrieDB(), root, common.BytesToHash(req.AccKey))
|
|
|
- if err != nil {
|
|
|
- p.Log().Warn("Failed to retrieve account for proof", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(req.AccKey), "err", err)
|
|
|
+ // Prove the user's request from the account or stroage trie
|
|
|
+ if err := trie.Prove(request.Key, request.FromLevel, nodes); err != nil {
|
|
|
+ p.Log().Warn("Failed to prove state request", "block", header.Number, "hash", header.Hash(), "err", err)
|
|
|
continue
|
|
|
}
|
|
|
- trie, err = statedb.OpenStorageTrie(common.BytesToHash(req.AccKey), account.Root)
|
|
|
- if trie == nil || err != nil {
|
|
|
- p.Log().Warn("Failed to open storage trie for proof", "block", header.Number, "hash", header.Hash(), "account", common.BytesToHash(req.AccKey), "root", account.Root, "err", err)
|
|
|
- continue
|
|
|
+ if nodes.DataSize() >= softResponseLimit {
|
|
|
+ break
|
|
|
}
|
|
|
}
|
|
|
- // Prove the user's request from the account or stroage trie
|
|
|
- if err := trie.Prove(req.Key, req.FromLevel, nodes); err != nil {
|
|
|
- p.Log().Warn("Failed to prove state request", "block", header.Number, "hash", header.Hash(), "err", err)
|
|
|
- continue
|
|
|
- }
|
|
|
- if nodes.DataSize() >= softResponseLimit {
|
|
|
- break
|
|
|
- }
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyProofsV2(req.ReqID, nodes.NodeList()), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyProofsV2(req.ReqID, nodes.NodeList()), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case ProofsV2Msg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -899,53 +928,53 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
auxData [][]byte
|
|
|
)
|
|
|
reqCnt := len(req.Reqs)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxHelperTrieProofsFetch) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
-
|
|
|
- var (
|
|
|
- lastIdx uint64
|
|
|
- lastType uint
|
|
|
- root common.Hash
|
|
|
- auxTrie *trie.Trie
|
|
|
- )
|
|
|
- nodes := light.NewNodeSet()
|
|
|
- for i, req := range req.Reqs {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- if auxTrie == nil || req.Type != lastType || req.TrieIdx != lastIdx {
|
|
|
- auxTrie, lastType, lastIdx = nil, req.Type, req.TrieIdx
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxHelperTrieProofsFetch) {
|
|
|
+ go func() {
|
|
|
|
|
|
- var prefix string
|
|
|
- if root, prefix = pm.getHelperTrie(req.Type, req.TrieIdx); root != (common.Hash{}) {
|
|
|
- auxTrie, _ = trie.New(root, trie.NewDatabase(rawdb.NewTable(pm.chainDb, prefix)))
|
|
|
- }
|
|
|
- }
|
|
|
- if req.AuxReq == auxRoot {
|
|
|
- var data []byte
|
|
|
- if root != (common.Hash{}) {
|
|
|
- data = root[:]
|
|
|
+ var (
|
|
|
+ lastIdx uint64
|
|
|
+ lastType uint
|
|
|
+ root common.Hash
|
|
|
+ auxTrie *trie.Trie
|
|
|
+ )
|
|
|
+ nodes := light.NewNodeSet()
|
|
|
+ for i, request := range req.Reqs {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
}
|
|
|
- auxData = append(auxData, data)
|
|
|
- auxBytes += len(data)
|
|
|
- } else {
|
|
|
- if auxTrie != nil {
|
|
|
- auxTrie.Prove(req.Key, req.FromLevel, nodes)
|
|
|
+ if auxTrie == nil || request.Type != lastType || request.TrieIdx != lastIdx {
|
|
|
+ auxTrie, lastType, lastIdx = nil, request.Type, request.TrieIdx
|
|
|
+
|
|
|
+ var prefix string
|
|
|
+ if root, prefix = pm.getHelperTrie(request.Type, request.TrieIdx); root != (common.Hash{}) {
|
|
|
+ auxTrie, _ = trie.New(root, trie.NewDatabase(rawdb.NewTable(pm.chainDb, prefix)))
|
|
|
+ }
|
|
|
}
|
|
|
- if req.AuxReq != 0 {
|
|
|
- data := pm.getHelperTrieAuxData(req)
|
|
|
+ if request.AuxReq == auxRoot {
|
|
|
+ var data []byte
|
|
|
+ if root != (common.Hash{}) {
|
|
|
+ data = root[:]
|
|
|
+ }
|
|
|
auxData = append(auxData, data)
|
|
|
auxBytes += len(data)
|
|
|
+ } else {
|
|
|
+ if auxTrie != nil {
|
|
|
+ auxTrie.Prove(request.Key, request.FromLevel, nodes)
|
|
|
+ }
|
|
|
+ if request.AuxReq != 0 {
|
|
|
+ data := pm.getHelperTrieAuxData(request)
|
|
|
+ auxData = append(auxData, data)
|
|
|
+ auxBytes += len(data)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if nodes.DataSize()+auxBytes >= softResponseLimit {
|
|
|
+ break
|
|
|
}
|
|
|
}
|
|
|
- if nodes.DataSize()+auxBytes >= softResponseLimit {
|
|
|
- break
|
|
|
- }
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyHelperTrieProofs(req.ReqID, HelperTrieResps{Proofs: nodes.NodeList(), AuxData: auxData}), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyHelperTrieProofs(req.ReqID, HelperTrieResps{Proofs: nodes.NodeList(), AuxData: auxData}), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case HelperTrieProofsMsg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -981,27 +1010,27 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
return errResp(ErrDecode, "msg %v: %v", msg, err)
|
|
|
}
|
|
|
reqCnt := len(req.Txs)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxTxSend) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- stats := make([]light.TxStatus, len(req.Txs))
|
|
|
- for i, tx := range req.Txs {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
- }
|
|
|
- hash := tx.Hash()
|
|
|
- stats[i] = pm.txStatus(hash)
|
|
|
- if stats[i].Status == core.TxStatusUnknown {
|
|
|
- if errs := pm.txpool.AddRemotes([]*types.Transaction{tx}); errs[0] != nil {
|
|
|
- stats[i].Error = errs[0].Error()
|
|
|
- continue
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxTxSend) {
|
|
|
+ go func() {
|
|
|
+ stats := make([]light.TxStatus, len(req.Txs))
|
|
|
+ for i, tx := range req.Txs {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
}
|
|
|
+ hash := tx.Hash()
|
|
|
stats[i] = pm.txStatus(hash)
|
|
|
+ if stats[i].Status == core.TxStatusUnknown {
|
|
|
+ if errs := pm.txpool.AddRemotes([]*types.Transaction{tx}); errs[0] != nil {
|
|
|
+ stats[i].Error = errs[0].Error()
|
|
|
+ continue
|
|
|
+ }
|
|
|
+ stats[i] = pm.txStatus(hash)
|
|
|
+ }
|
|
|
}
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyTxStatus(req.ReqID, stats), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyTxStatus(req.ReqID, stats), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case GetTxStatusMsg:
|
|
|
if pm.txpool == nil {
|
|
|
@@ -1016,19 +1045,19 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
return errResp(ErrDecode, "msg %v: %v", msg, err)
|
|
|
}
|
|
|
reqCnt := len(req.Hashes)
|
|
|
- if !accept(req.ReqID, uint64(reqCnt), MaxTxStatus) {
|
|
|
- return errResp(ErrRequestRejected, "")
|
|
|
- }
|
|
|
- go func() {
|
|
|
- stats := make([]light.TxStatus, len(req.Hashes))
|
|
|
- for i, hash := range req.Hashes {
|
|
|
- if i != 0 && !task.waitOrStop() {
|
|
|
- return
|
|
|
+ if accept(req.ReqID, uint64(reqCnt), MaxTxStatus) {
|
|
|
+ go func() {
|
|
|
+ stats := make([]light.TxStatus, len(req.Hashes))
|
|
|
+ for i, hash := range req.Hashes {
|
|
|
+ if i != 0 && !task.waitOrStop() {
|
|
|
+ sendResponse(req.ReqID, 0, nil, task.servingTime)
|
|
|
+ return
|
|
|
+ }
|
|
|
+ stats[i] = pm.txStatus(hash)
|
|
|
}
|
|
|
- stats[i] = pm.txStatus(hash)
|
|
|
- }
|
|
|
- sendResponse(req.ReqID, uint64(reqCnt), p.ReplyTxStatus(req.ReqID, stats), task.done())
|
|
|
- }()
|
|
|
+ sendResponse(req.ReqID, uint64(reqCnt), p.ReplyTxStatus(req.ReqID, stats), task.done())
|
|
|
+ }()
|
|
|
+ }
|
|
|
|
|
|
case TxStatusMsg:
|
|
|
if pm.odr == nil {
|
|
|
@@ -1053,6 +1082,26 @@ func (pm *ProtocolManager) handleMsg(p *peer) error {
|
|
|
Obj: resp.Status,
|
|
|
}
|
|
|
|
|
|
+ case StopMsg:
|
|
|
+ if pm.odr == nil {
|
|
|
+ return errResp(ErrUnexpectedResponse, "")
|
|
|
+ }
|
|
|
+ p.freezeServer(true)
|
|
|
+ pm.retriever.frozen(p)
|
|
|
+ p.Log().Warn("Service stopped")
|
|
|
+
|
|
|
+ case ResumeMsg:
|
|
|
+ if pm.odr == nil {
|
|
|
+ return errResp(ErrUnexpectedResponse, "")
|
|
|
+ }
|
|
|
+ var bv uint64
|
|
|
+ if err := msg.Decode(&bv); err != nil {
|
|
|
+ return errResp(ErrDecode, "msg %v: %v", msg, err)
|
|
|
+ }
|
|
|
+ p.fcServer.ResumeFreeze(bv)
|
|
|
+ p.freezeServer(false)
|
|
|
+ p.Log().Warn("Service resumed")
|
|
|
+
|
|
|
default:
|
|
|
p.Log().Trace("Received unknown message", "code", msg.Code)
|
|
|
return errResp(ErrInvalidMsgCode, "%v", msg.Code)
|
Felföldi Zsolt