You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

940 lines
24 KiB

p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
abci: localClient improvements & bugfixes & pubsub Unsubscribe issues (#2748) * use READ lock/unlock in ConsensusState#GetLastHeight Refs #2721 * do not use defers when there's no need * fix peer formatting (output its address instead of the pointer) ``` [54310]: E[11-02|11:59:39.851] Connection failed @ sendRoutine module=p2p peer=0xb78f00 conn=MConn{74.207.236.148:26656} err="pong timeout" ``` https://github.com/tendermint/tendermint/issues/2721#issuecomment-435326581 * panic if peer has no state https://github.com/tendermint/tendermint/issues/2721#issuecomment-435347165 It's confusing that sometimes we check if peer has a state, but most of the times we expect it to be there 1. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/mempool/reactor.go#L138 2. https://github.com/tendermint/tendermint/blob/add79700b5fe84417538202b6c927c8cc5383672/rpc/core/consensus.go#L196 (edited) I will change everything to always assume peer has a state and panic otherwise that should help identify issues earlier * abci/localclient: extend lock on app callback App callback should be protected by lock as well (note this was already done for InitChainAsync, why not for others???). Otherwise, when we execute the block, tx might come in and call the callback in the same time we're updating it in execBlockOnProxyApp => DATA RACE Fixes #2721 Consensus state is locked ``` goroutine 113333 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00180009c, 0xc0000c7e00) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*RWMutex).RLock(0xc001800090) /usr/local/go/src/sync/rwmutex.go:50 +0x4e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).GetRoundState(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:218 +0x46 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).queryMaj23Routine(0xc0017def80, 0x11104a0, 0xc0072488f0, 0xc007248 9c0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:735 +0x16d created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusReactor).AddPeer /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/reactor.go:172 +0x236 ``` because localClient is locked ``` goroutine 1899 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0xc0000cb500) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).SetResponseCallback(0xc0001fb560, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:32 +0x33 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnConsensus).SetResponseCallback(0xc00002f750, 0xc007868540) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:57 +0x40 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.execBlockOnProxyApp(0x1104e20, 0xc002ca0ba0, 0x11092a0, 0xc00002f750, 0xc0001fe960, 0xc000bfc660, 0x110cfe0, 0xc000090330, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:230 +0x1fd github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state.(*BlockExecutor).ApplyBlock(0xc002c2a230, 0x7, 0x0, 0xc000eae880, 0x6, 0xc002e52c60, 0x16, 0x1f927, 0xc9d12, 0xc000d9d5a0, ...) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/state/execution.go:96 +0x142 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).finalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1339 +0xa3e github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryFinalizeCommit(0xc001800000, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1270 +0x451 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit.func1(0xc001800000, 0x0, 0x1f928) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1218 +0x90 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).enterCommit(0xc001800000, 0x1f928, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1247 +0x6b8 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).addVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xc003bc7ad0, 0xc003bc7b10) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1659 +0xbad github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).tryAddVote(0xc001800000, 0xc003d8dea0, 0xc000cf4cc0, 0x28, 0xf1, 0xf1, 0xf1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:1517 +0x59 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).handleMsg(0xc001800000, 0xd98200, 0xc0070dbed0, 0xc000cf4cc0, 0x28) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:660 +0x64b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).receiveRoutine(0xc001800000, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:617 +0x670 created by github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus.(*ConsensusState).OnStart /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/consensus/state.go:311 +0x132 ``` tx comes in and CheckTx is executed right when we execute the block ``` goroutine 111044 [semacquire, 309 minutes]: sync.runtime_SemacquireMutex(0xc00003363c, 0x0) /usr/local/go/src/runtime/sema.go:71 +0x3d sync.(*Mutex).Lock(0xc000033638) /usr/local/go/src/sync/mutex.go:134 +0xff github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client.(*localClient).CheckTxAsync(0xc0001fb0e0, 0xc002d94500, 0x13f, 0x280, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/abci/client/local_client.go:85 +0x47 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy.(*appConnMempool).CheckTxAsync(0xc00002f720, 0xc002d94500, 0x13f, 0x280, 0x1) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/proxy/app_conn.go:114 +0x51 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool.(*Mempool).CheckTx(0xc002d3a320, 0xc002d94500, 0x13f, 0x280, 0xc0072355f0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/mempool/mempool.go:316 +0x17b github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core.BroadcastTxSync(0xc002d94500, 0x13f, 0x280, 0x0, 0x0, 0x0) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/core/mempool.go:93 +0xb8 reflect.Value.call(0xd85560, 0x10326c0, 0x13, 0xec7b8b, 0x4, 0xc00663f180, 0x1, 0x1, 0xc00663f180, 0xc00663f188, ...) /usr/local/go/src/reflect/value.go:447 +0x449 reflect.Value.Call(0xd85560, 0x10326c0, 0x13, 0xc00663f180, 0x1, 0x1, 0x0, 0x0, 0xc005cc9344) /usr/local/go/src/reflect/value.go:308 +0xa4 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.makeHTTPHandler.func2(0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/handlers.go:269 +0x188 net/http.HandlerFunc.ServeHTTP(0xc002c81f20, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.(*ServeMux).ServeHTTP(0xc002c81b60, 0x1102060, 0xc00663f100, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2361 +0x127 github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.maxBytesHandler.ServeHTTP(0x10f8a40, 0xc002c81b60, 0xf4240, 0x1102060, 0xc00663f100, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:219 +0xcf github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server.RecoverAndLogHandler.func1(0x1103220, 0xc00121e620, 0xc0082d7900) /root/go/src/github.com/MinterTeam/minter-go-node/vendor/github.com/tendermint/tendermint/rpc/lib/server/http_server.go:192 +0x394 net/http.HandlerFunc.ServeHTTP(0xc002c06ea0, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:1964 +0x44 net/http.serverHandler.ServeHTTP(0xc001a1aa90, 0x1103220, 0xc00121e620, 0xc0082d7900) /usr/local/go/src/net/http/server.go:2741 +0xab net/http.(*conn).serve(0xc00785a3c0, 0x11041a0, 0xc000f844c0) /usr/local/go/src/net/http/server.go:1847 +0x646 created by net/http.(*Server).Serve /usr/local/go/src/net/http/server.go:2851 +0x2f5 ``` * consensus: use read lock in Receive#VoteMessage * use defer to unlock mutex because application might panic * use defer in every method of the localClient * add a changelog entry * drain channels before Unsubscribe(All) Read https://github.com/tendermint/tendermint/blob/55362ed76630f3e1ebec159a598f6a9fb5892cb1/libs/pubsub/pubsub.go#L13 for the detailed explanation of the issue. We'll need to fix it someday. Make sure to keep an eye on https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md * retry instead of panic when peer has no state in reactors other than consensus in /dump_consensus_state RPC endpoint, skip a peer with no state * rpc/core/mempool: simplify error messages * rpc/core/mempool: use time.After instead of timer also, do not log DeliverTx result (to be consistent with other memthods) * unlock before calling the callback in reqRes#SetCallback
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: fix infinite loop in addrbook (#3232) * failing test * fix infinite loop in addrbook There are cases where we only have a small number of addresses marked good ("old"), but the selection mechanism keeps trying to select more of these addresses, and hence ends up in an infinite loop. Here we fix this to only try and select such "old" addresses if we have enough of them. Note this means, if we don't have enough of them, we may return more "new" addresses than otherwise expected by the newSelectionBias. This whole GetSelectionWithBias method probably needs to be rewritten, but this is a quick fix for the issue. * changelog * fix infinite loop if not enough new addrs * fix another potential infinite loop if a.nNew == 0 -> pickFromOldBucket=true, but we don't have enough items (a.nOld > len(oldBucketToAddrsMap) false) * Revert "fix another potential infinite loop" This reverts commit 146540c1125597162bd89820d611f6531f5e5e4b. * check num addresses instead of buckets, new test * fixed the int division * add slack to bias % in test, lint fixes * Added checks for selection content in test * test cleanup * Apply suggestions from code review Co-Authored-By: ebuchman <ethan@coinculture.info> * address review comments * change after Anton's review comments * use the same docker image we use for testing when building a binary for localnet * switch back to circleci classic * more review comments * more review comments * refactor addrbook_test * build linux binary inside docker in attempt to fix ``` --> Running dep + make build-linux GOOS=linux GOARCH=amd64 make build make[1]: Entering directory `/home/circleci/.go_workspace/src/github.com/tendermint/tendermint' CGO_ENABLED=0 go build -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`" -tags 'tendermint' -o build/tendermint ./cmd/tendermint/ p2p/pex/addrbook.go:373:13: undefined: math.Round ``` * change dir from /usr to /go * use concrete Go version for localnet binary * check for nil addresses just to be sure
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
p2p: fix infinite loop in addrbook (#3232) * failing test * fix infinite loop in addrbook There are cases where we only have a small number of addresses marked good ("old"), but the selection mechanism keeps trying to select more of these addresses, and hence ends up in an infinite loop. Here we fix this to only try and select such "old" addresses if we have enough of them. Note this means, if we don't have enough of them, we may return more "new" addresses than otherwise expected by the newSelectionBias. This whole GetSelectionWithBias method probably needs to be rewritten, but this is a quick fix for the issue. * changelog * fix infinite loop if not enough new addrs * fix another potential infinite loop if a.nNew == 0 -> pickFromOldBucket=true, but we don't have enough items (a.nOld > len(oldBucketToAddrsMap) false) * Revert "fix another potential infinite loop" This reverts commit 146540c1125597162bd89820d611f6531f5e5e4b. * check num addresses instead of buckets, new test * fixed the int division * add slack to bias % in test, lint fixes * Added checks for selection content in test * test cleanup * Apply suggestions from code review Co-Authored-By: ebuchman <ethan@coinculture.info> * address review comments * change after Anton's review comments * use the same docker image we use for testing when building a binary for localnet * switch back to circleci classic * more review comments * more review comments * refactor addrbook_test * build linux binary inside docker in attempt to fix ``` --> Running dep + make build-linux GOOS=linux GOARCH=amd64 make build make[1]: Entering directory `/home/circleci/.go_workspace/src/github.com/tendermint/tendermint' CGO_ENABLED=0 go build -ldflags "-X github.com/tendermint/tendermint/version.GitCommit=`git rev-parse --short=8 HEAD`" -tags 'tendermint' -o build/tendermint ./cmd/tendermint/ p2p/pex/addrbook.go:373:13: undefined: math.Round ``` * change dir from /usr to /go * use concrete Go version for localnet binary * check for nil addresses just to be sure
6 years ago
p2p: seed mode refactoring (#3011) ListOfKnownAddresses is removed panic if addrbook size is less than zero CrawlPeers does not attempt to connect to existing or peers we're currently dialing various perf. fixes improved tests (though not complete) move IsDialingOrExistingAddress check into DialPeerWithAddress (Fixes #2716) * addrbook: preallocate memory when saving addrbook to file * addrbook: remove oldestFirst struct and check for ID * oldestFirst replaced with sort.Slice * ID is now mandatory, so no need to check * addrbook: remove ListOfKnownAddresses GetSelection is used instead in seed mode. * addrbook: panic if size is less than 0 * rewrite addrbook#saveToFile to not use a counter * test AttemptDisconnects func * move IsDialingOrExistingAddress check into DialPeerWithAddress * save and cleanup crawl peer data * get rid of DefaultSeedDisconnectWaitPeriod * make linter happy * fix TestPEXReactorSeedMode * fix comment * add a changelog entry * Apply suggestions from code review Co-Authored-By: melekes <anton.kalyaev@gmail.com> * rename ErrDialingOrExistingAddress to ErrCurrentlyDialingOrExistingAddress * lowercase errors * do not persist seed data pros: - no extra files - less IO cons: - if the node crashes, seed might crawl a peer too soon * fixes after Ethan's review * add a changelog entry * we should only consult Switch about peers checking addrbook size does not make sense since only PEX reactor uses it for dialing peers! https://github.com/tendermint/tendermint/pull/3011#discussion_r270948875
6 years ago
  1. // Modified for Tendermint
  2. // Originally Copyright (c) 2013-2014 Conformal Systems LLC.
  3. // https://github.com/conformal/btcd/blob/master/LICENSE
  4. package pex
  5. import (
  6. crand "crypto/rand"
  7. "encoding/binary"
  8. "fmt"
  9. "math"
  10. "math/rand"
  11. "net"
  12. "sync"
  13. "time"
  14. "github.com/minio/highwayhash"
  15. "github.com/tendermint/tendermint/crypto"
  16. tmmath "github.com/tendermint/tendermint/libs/math"
  17. tmrand "github.com/tendermint/tendermint/libs/rand"
  18. "github.com/tendermint/tendermint/libs/service"
  19. tmsync "github.com/tendermint/tendermint/libs/sync"
  20. "github.com/tendermint/tendermint/p2p"
  21. )
  22. const (
  23. bucketTypeNew = 0x01
  24. bucketTypeOld = 0x02
  25. )
  26. // AddrBook is an address book used for tracking peers
  27. // so we can gossip about them to others and select
  28. // peers to dial.
  29. // TODO: break this up?
  30. type AddrBook interface {
  31. service.Service
  32. // Add our own addresses so we don't later add ourselves
  33. AddOurAddress(*p2p.NetAddress)
  34. // Check if it is our address
  35. OurAddress(*p2p.NetAddress) bool
  36. AddPrivateIDs([]string)
  37. // Add and remove an address
  38. AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error
  39. RemoveAddress(*p2p.NetAddress)
  40. // Check if the address is in the book
  41. HasAddress(*p2p.NetAddress) bool
  42. // Do we need more peers?
  43. NeedMoreAddrs() bool
  44. // Is Address Book Empty? Answer should not depend on being in your own
  45. // address book, or private peers
  46. Empty() bool
  47. // Pick an address to dial
  48. PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress
  49. // Mark address
  50. MarkGood(p2p.ID)
  51. MarkAttempt(*p2p.NetAddress)
  52. MarkBad(*p2p.NetAddress, time.Duration) // Move peer to bad peers list
  53. // Add bad peers back to addrBook
  54. ReinstateBadPeers()
  55. IsGood(*p2p.NetAddress) bool
  56. IsBanned(*p2p.NetAddress) bool
  57. // Send a selection of addresses to peers
  58. GetSelection() []*p2p.NetAddress
  59. // Send a selection of addresses with bias
  60. GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress
  61. Size() int
  62. // Persist to disk
  63. Save()
  64. }
  65. var _ AddrBook = (*addrBook)(nil)
  66. // addrBook - concurrency safe peer address manager.
  67. // Implements AddrBook.
  68. type addrBook struct {
  69. service.BaseService
  70. // accessed concurrently
  71. mtx tmsync.Mutex
  72. rand *tmrand.Rand
  73. ourAddrs map[string]struct{}
  74. privateIDs map[p2p.ID]struct{}
  75. addrLookup map[p2p.ID]*knownAddress // new & old
  76. badPeers map[p2p.ID]*knownAddress // blacklisted peers
  77. bucketsOld []map[string]*knownAddress
  78. bucketsNew []map[string]*knownAddress
  79. nOld int
  80. nNew int
  81. // immutable after creation
  82. filePath string
  83. key string // random prefix for bucket placement
  84. routabilityStrict bool
  85. hashKey []byte
  86. wg sync.WaitGroup
  87. }
  88. func newHashKey() []byte {
  89. result := make([]byte, highwayhash.Size)
  90. crand.Read(result)
  91. return result
  92. }
  93. // NewAddrBook creates a new address book.
  94. // Use Start to begin processing asynchronous address updates.
  95. func NewAddrBook(filePath string, routabilityStrict bool) AddrBook {
  96. am := &addrBook{
  97. rand: tmrand.NewRand(),
  98. ourAddrs: make(map[string]struct{}),
  99. privateIDs: make(map[p2p.ID]struct{}),
  100. addrLookup: make(map[p2p.ID]*knownAddress),
  101. badPeers: make(map[p2p.ID]*knownAddress),
  102. filePath: filePath,
  103. routabilityStrict: routabilityStrict,
  104. hashKey: newHashKey(),
  105. }
  106. am.init()
  107. am.BaseService = *service.NewBaseService(nil, "AddrBook", am)
  108. return am
  109. }
  110. // Initialize the buckets.
  111. // When modifying this, don't forget to update loadFromFile()
  112. func (a *addrBook) init() {
  113. a.key = crypto.CRandHex(24) // 24/2 * 8 = 96 bits
  114. // New addr buckets
  115. a.bucketsNew = make([]map[string]*knownAddress, newBucketCount)
  116. for i := range a.bucketsNew {
  117. a.bucketsNew[i] = make(map[string]*knownAddress)
  118. }
  119. // Old addr buckets
  120. a.bucketsOld = make([]map[string]*knownAddress, oldBucketCount)
  121. for i := range a.bucketsOld {
  122. a.bucketsOld[i] = make(map[string]*knownAddress)
  123. }
  124. }
  125. // OnStart implements Service.
  126. func (a *addrBook) OnStart() error {
  127. if err := a.BaseService.OnStart(); err != nil {
  128. return err
  129. }
  130. a.loadFromFile(a.filePath)
  131. // wg.Add to ensure that any invocation of .Wait()
  132. // later on will wait for saveRoutine to terminate.
  133. a.wg.Add(1)
  134. go a.saveRoutine()
  135. return nil
  136. }
  137. // OnStop implements Service.
  138. func (a *addrBook) OnStop() {
  139. a.BaseService.OnStop()
  140. }
  141. func (a *addrBook) Wait() {
  142. a.wg.Wait()
  143. }
  144. func (a *addrBook) FilePath() string {
  145. return a.filePath
  146. }
  147. //-------------------------------------------------------
  148. // AddOurAddress one of our addresses.
  149. func (a *addrBook) AddOurAddress(addr *p2p.NetAddress) {
  150. a.mtx.Lock()
  151. defer a.mtx.Unlock()
  152. a.Logger.Info("Add our address to book", "addr", addr)
  153. a.ourAddrs[addr.String()] = struct{}{}
  154. }
  155. // OurAddress returns true if it is our address.
  156. func (a *addrBook) OurAddress(addr *p2p.NetAddress) bool {
  157. a.mtx.Lock()
  158. defer a.mtx.Unlock()
  159. _, ok := a.ourAddrs[addr.String()]
  160. return ok
  161. }
  162. func (a *addrBook) AddPrivateIDs(ids []string) {
  163. a.mtx.Lock()
  164. defer a.mtx.Unlock()
  165. for _, id := range ids {
  166. a.privateIDs[p2p.ID(id)] = struct{}{}
  167. }
  168. }
  169. // AddAddress implements AddrBook
  170. // Add address to a "new" bucket. If it's already in one, only add it probabilistically.
  171. // Returns error if the addr is non-routable. Does not add self.
  172. // NOTE: addr must not be nil
  173. func (a *addrBook) AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error {
  174. a.mtx.Lock()
  175. defer a.mtx.Unlock()
  176. return a.addAddress(addr, src)
  177. }
  178. // RemoveAddress implements AddrBook - removes the address from the book.
  179. func (a *addrBook) RemoveAddress(addr *p2p.NetAddress) {
  180. a.mtx.Lock()
  181. defer a.mtx.Unlock()
  182. a.removeAddress(addr)
  183. }
  184. // IsGood returns true if peer was ever marked as good and haven't
  185. // done anything wrong since then.
  186. func (a *addrBook) IsGood(addr *p2p.NetAddress) bool {
  187. a.mtx.Lock()
  188. defer a.mtx.Unlock()
  189. return a.addrLookup[addr.ID].isOld()
  190. }
  191. // IsBanned returns true if the peer is currently banned
  192. func (a *addrBook) IsBanned(addr *p2p.NetAddress) bool {
  193. a.mtx.Lock()
  194. _, ok := a.badPeers[addr.ID]
  195. a.mtx.Unlock()
  196. return ok
  197. }
  198. // HasAddress returns true if the address is in the book.
  199. func (a *addrBook) HasAddress(addr *p2p.NetAddress) bool {
  200. a.mtx.Lock()
  201. defer a.mtx.Unlock()
  202. ka := a.addrLookup[addr.ID]
  203. return ka != nil
  204. }
  205. // NeedMoreAddrs implements AddrBook - returns true if there are not have enough addresses in the book.
  206. func (a *addrBook) NeedMoreAddrs() bool {
  207. return a.Size() < needAddressThreshold
  208. }
  209. // Empty implements AddrBook - returns true if there are no addresses in the address book.
  210. // Does not count the peer appearing in its own address book, or private peers.
  211. func (a *addrBook) Empty() bool {
  212. return a.Size() == 0
  213. }
  214. // PickAddress implements AddrBook. It picks an address to connect to.
  215. // The address is picked randomly from an old or new bucket according
  216. // to the biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to that range)
  217. // and determines how biased we are to pick an address from a new bucket.
  218. // PickAddress returns nil if the AddrBook is empty or if we try to pick
  219. // from an empty bucket.
  220. func (a *addrBook) PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress {
  221. a.mtx.Lock()
  222. defer a.mtx.Unlock()
  223. bookSize := a.size()
  224. if bookSize <= 0 {
  225. if bookSize < 0 {
  226. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  227. }
  228. return nil
  229. }
  230. if biasTowardsNewAddrs > 100 {
  231. biasTowardsNewAddrs = 100
  232. }
  233. if biasTowardsNewAddrs < 0 {
  234. biasTowardsNewAddrs = 0
  235. }
  236. // Bias between new and old addresses.
  237. oldCorrelation := math.Sqrt(float64(a.nOld)) * (100.0 - float64(biasTowardsNewAddrs))
  238. newCorrelation := math.Sqrt(float64(a.nNew)) * float64(biasTowardsNewAddrs)
  239. // pick a random peer from a random bucket
  240. var bucket map[string]*knownAddress
  241. pickFromOldBucket := (newCorrelation+oldCorrelation)*a.rand.Float64() < oldCorrelation
  242. if (pickFromOldBucket && a.nOld == 0) ||
  243. (!pickFromOldBucket && a.nNew == 0) {
  244. return nil
  245. }
  246. // loop until we pick a random non-empty bucket
  247. for len(bucket) == 0 {
  248. if pickFromOldBucket {
  249. bucket = a.bucketsOld[a.rand.Intn(len(a.bucketsOld))]
  250. } else {
  251. bucket = a.bucketsNew[a.rand.Intn(len(a.bucketsNew))]
  252. }
  253. }
  254. // pick a random index and loop over the map to return that index
  255. randIndex := a.rand.Intn(len(bucket))
  256. for _, ka := range bucket {
  257. if randIndex == 0 {
  258. return ka.Addr
  259. }
  260. randIndex--
  261. }
  262. return nil
  263. }
  264. // MarkGood implements AddrBook - it marks the peer as good and
  265. // moves it into an "old" bucket.
  266. func (a *addrBook) MarkGood(id p2p.ID) {
  267. a.mtx.Lock()
  268. defer a.mtx.Unlock()
  269. ka := a.addrLookup[id]
  270. if ka == nil {
  271. return
  272. }
  273. ka.markGood()
  274. if ka.isNew() {
  275. a.moveToOld(ka)
  276. }
  277. }
  278. // MarkAttempt implements AddrBook - it marks that an attempt was made to connect to the address.
  279. func (a *addrBook) MarkAttempt(addr *p2p.NetAddress) {
  280. a.mtx.Lock()
  281. defer a.mtx.Unlock()
  282. ka := a.addrLookup[addr.ID]
  283. if ka == nil {
  284. return
  285. }
  286. ka.markAttempt()
  287. }
  288. // MarkBad implements AddrBook. Kicks address out from book, places
  289. // the address in the badPeers pool.
  290. func (a *addrBook) MarkBad(addr *p2p.NetAddress, banTime time.Duration) {
  291. a.mtx.Lock()
  292. defer a.mtx.Unlock()
  293. if a.addBadPeer(addr, banTime) {
  294. a.removeAddress(addr)
  295. }
  296. }
  297. // ReinstateBadPeers removes bad peers from ban list and places them into a new
  298. // bucket.
  299. func (a *addrBook) ReinstateBadPeers() {
  300. a.mtx.Lock()
  301. defer a.mtx.Unlock()
  302. for _, ka := range a.badPeers {
  303. if ka.isBanned() {
  304. continue
  305. }
  306. bucket, err := a.calcNewBucket(ka.Addr, ka.Src)
  307. if err != nil {
  308. a.Logger.Error("Failed to calculate new bucket (bad peer won't be reinstantiated)",
  309. "addr", ka.Addr, "err", err)
  310. continue
  311. }
  312. a.addToNewBucket(ka, bucket)
  313. delete(a.badPeers, ka.ID())
  314. a.Logger.Info("Reinstated address", "addr", ka.Addr)
  315. }
  316. }
  317. // GetSelection implements AddrBook.
  318. // It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
  319. // Must never return a nil address.
  320. func (a *addrBook) GetSelection() []*p2p.NetAddress {
  321. a.mtx.Lock()
  322. defer a.mtx.Unlock()
  323. bookSize := a.size()
  324. if bookSize <= 0 {
  325. if bookSize < 0 {
  326. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  327. }
  328. return nil
  329. }
  330. numAddresses := tmmath.MaxInt(
  331. tmmath.MinInt(minGetSelection, bookSize),
  332. bookSize*getSelectionPercent/100)
  333. numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
  334. // XXX: instead of making a list of all addresses, shuffling, and slicing a random chunk,
  335. // could we just select a random numAddresses of indexes?
  336. allAddr := make([]*p2p.NetAddress, bookSize)
  337. i := 0
  338. for _, ka := range a.addrLookup {
  339. allAddr[i] = ka.Addr
  340. i++
  341. }
  342. // Fisher-Yates shuffle the array. We only need to do the first
  343. // `numAddresses' since we are throwing the rest.
  344. for i := 0; i < numAddresses; i++ {
  345. // pick a number between current index and the end
  346. j := tmrand.Intn(len(allAddr)-i) + i
  347. allAddr[i], allAddr[j] = allAddr[j], allAddr[i]
  348. }
  349. // slice off the limit we are willing to share.
  350. return allAddr[:numAddresses]
  351. }
  352. func percentageOfNum(p, n int) int {
  353. return int(math.Round((float64(p) / float64(100)) * float64(n)))
  354. }
  355. // GetSelectionWithBias implements AddrBook.
  356. // It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
  357. // Must never return a nil address.
  358. //
  359. // Each address is picked randomly from an old or new bucket according to the
  360. // biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to
  361. // that range) and determines how biased we are to pick an address from a new
  362. // bucket.
  363. func (a *addrBook) GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress {
  364. a.mtx.Lock()
  365. defer a.mtx.Unlock()
  366. bookSize := a.size()
  367. if bookSize <= 0 {
  368. if bookSize < 0 {
  369. panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
  370. }
  371. return nil
  372. }
  373. if biasTowardsNewAddrs > 100 {
  374. biasTowardsNewAddrs = 100
  375. }
  376. if biasTowardsNewAddrs < 0 {
  377. biasTowardsNewAddrs = 0
  378. }
  379. numAddresses := tmmath.MaxInt(
  380. tmmath.MinInt(minGetSelection, bookSize),
  381. bookSize*getSelectionPercent/100)
  382. numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
  383. // number of new addresses that, if possible, should be in the beginning of the selection
  384. // if there are no enough old addrs, will choose new addr instead.
  385. numRequiredNewAdd := tmmath.MaxInt(percentageOfNum(biasTowardsNewAddrs, numAddresses), numAddresses-a.nOld)
  386. selection := a.randomPickAddresses(bucketTypeNew, numRequiredNewAdd)
  387. selection = append(selection, a.randomPickAddresses(bucketTypeOld, numAddresses-len(selection))...)
  388. return selection
  389. }
  390. //------------------------------------------------
  391. // Size returns the number of addresses in the book.
  392. func (a *addrBook) Size() int {
  393. a.mtx.Lock()
  394. defer a.mtx.Unlock()
  395. return a.size()
  396. }
  397. func (a *addrBook) size() int {
  398. return a.nNew + a.nOld
  399. }
  400. //----------------------------------------------------------
  401. // Save persists the address book to disk.
  402. func (a *addrBook) Save() {
  403. a.saveToFile(a.filePath) // thread safe
  404. }
  405. func (a *addrBook) saveRoutine() {
  406. defer a.wg.Done()
  407. saveFileTicker := time.NewTicker(dumpAddressInterval)
  408. out:
  409. for {
  410. select {
  411. case <-saveFileTicker.C:
  412. a.saveToFile(a.filePath)
  413. case <-a.Quit():
  414. break out
  415. }
  416. }
  417. saveFileTicker.Stop()
  418. a.saveToFile(a.filePath)
  419. }
  420. //----------------------------------------------------------
  421. func (a *addrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAddress {
  422. switch bucketType {
  423. case bucketTypeNew:
  424. return a.bucketsNew[bucketIdx]
  425. case bucketTypeOld:
  426. return a.bucketsOld[bucketIdx]
  427. default:
  428. panic("Invalid bucket type")
  429. }
  430. }
  431. // Adds ka to new bucket. Returns false if it couldn't do it cuz buckets full.
  432. // NOTE: currently it always returns true.
  433. func (a *addrBook) addToNewBucket(ka *knownAddress, bucketIdx int) error {
  434. // Consistency check to ensure we don't add an already known address
  435. if ka.isOld() {
  436. return errAddrBookOldAddressNewBucket{ka.Addr, bucketIdx}
  437. }
  438. addrStr := ka.Addr.String()
  439. bucket := a.getBucket(bucketTypeNew, bucketIdx)
  440. // Already exists?
  441. if _, ok := bucket[addrStr]; ok {
  442. return nil
  443. }
  444. // Enforce max addresses.
  445. if len(bucket) > newBucketSize {
  446. a.Logger.Info("new bucket is full, expiring new")
  447. a.expireNew(bucketIdx)
  448. }
  449. // Add to bucket.
  450. bucket[addrStr] = ka
  451. // increment nNew if the peer doesnt already exist in a bucket
  452. if ka.addBucketRef(bucketIdx) == 1 {
  453. a.nNew++
  454. }
  455. // Add it to addrLookup
  456. a.addrLookup[ka.ID()] = ka
  457. return nil
  458. }
  459. // Adds ka to old bucket. Returns false if it couldn't do it cuz buckets full.
  460. func (a *addrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
  461. // Sanity check
  462. if ka.isNew() {
  463. a.Logger.Error(fmt.Sprintf("Cannot add new address to old bucket: %v", ka))
  464. return false
  465. }
  466. if len(ka.Buckets) != 0 {
  467. a.Logger.Error(fmt.Sprintf("Cannot add already old address to another old bucket: %v", ka))
  468. return false
  469. }
  470. addrStr := ka.Addr.String()
  471. bucket := a.getBucket(bucketTypeOld, bucketIdx)
  472. // Already exists?
  473. if _, ok := bucket[addrStr]; ok {
  474. return true
  475. }
  476. // Enforce max addresses.
  477. if len(bucket) > oldBucketSize {
  478. return false
  479. }
  480. // Add to bucket.
  481. bucket[addrStr] = ka
  482. if ka.addBucketRef(bucketIdx) == 1 {
  483. a.nOld++
  484. }
  485. // Ensure in addrLookup
  486. a.addrLookup[ka.ID()] = ka
  487. return true
  488. }
  489. func (a *addrBook) removeFromBucket(ka *knownAddress, bucketType byte, bucketIdx int) {
  490. if ka.BucketType != bucketType {
  491. a.Logger.Error(fmt.Sprintf("Bucket type mismatch: %v", ka))
  492. return
  493. }
  494. bucket := a.getBucket(bucketType, bucketIdx)
  495. delete(bucket, ka.Addr.String())
  496. if ka.removeBucketRef(bucketIdx) == 0 {
  497. if bucketType == bucketTypeNew {
  498. a.nNew--
  499. } else {
  500. a.nOld--
  501. }
  502. delete(a.addrLookup, ka.ID())
  503. }
  504. }
  505. func (a *addrBook) removeFromAllBuckets(ka *knownAddress) {
  506. for _, bucketIdx := range ka.Buckets {
  507. bucket := a.getBucket(ka.BucketType, bucketIdx)
  508. delete(bucket, ka.Addr.String())
  509. }
  510. ka.Buckets = nil
  511. if ka.BucketType == bucketTypeNew {
  512. a.nNew--
  513. } else {
  514. a.nOld--
  515. }
  516. delete(a.addrLookup, ka.ID())
  517. }
  518. //----------------------------------------------------------
  519. func (a *addrBook) pickOldest(bucketType byte, bucketIdx int) *knownAddress {
  520. bucket := a.getBucket(bucketType, bucketIdx)
  521. var oldest *knownAddress
  522. for _, ka := range bucket {
  523. if oldest == nil || ka.LastAttempt.Before(oldest.LastAttempt) {
  524. oldest = ka
  525. }
  526. }
  527. return oldest
  528. }
  529. // adds the address to a "new" bucket. if its already in one,
  530. // it only adds it probabilistically
  531. func (a *addrBook) addAddress(addr, src *p2p.NetAddress) error {
  532. if addr == nil || src == nil {
  533. return ErrAddrBookNilAddr{addr, src}
  534. }
  535. if err := addr.Valid(); err != nil {
  536. return ErrAddrBookInvalidAddr{Addr: addr, AddrErr: err}
  537. }
  538. if _, ok := a.badPeers[addr.ID]; ok {
  539. return ErrAddressBanned{addr}
  540. }
  541. if _, ok := a.privateIDs[addr.ID]; ok {
  542. return ErrAddrBookPrivate{addr}
  543. }
  544. if _, ok := a.privateIDs[src.ID]; ok {
  545. return ErrAddrBookPrivateSrc{src}
  546. }
  547. // TODO: we should track ourAddrs by ID and by IP:PORT and refuse both.
  548. if _, ok := a.ourAddrs[addr.String()]; ok {
  549. return ErrAddrBookSelf{addr}
  550. }
  551. if a.routabilityStrict && !addr.Routable() {
  552. return ErrAddrBookNonRoutable{addr}
  553. }
  554. ka := a.addrLookup[addr.ID]
  555. if ka != nil {
  556. // If its already old and the address ID's are the same, ignore it.
  557. // Thereby avoiding issues with a node on the network attempting to change
  558. // the IP of a known node ID. (Which could yield an eclipse attack on the node)
  559. if ka.isOld() && ka.Addr.ID == addr.ID {
  560. return nil
  561. }
  562. // Already in max new buckets.
  563. if len(ka.Buckets) == maxNewBucketsPerAddress {
  564. return nil
  565. }
  566. // The more entries we have, the less likely we are to add more.
  567. factor := int32(2 * len(ka.Buckets))
  568. if a.rand.Int31n(factor) != 0 {
  569. return nil
  570. }
  571. } else {
  572. ka = newKnownAddress(addr, src)
  573. }
  574. bucket, err := a.calcNewBucket(addr, src)
  575. if err != nil {
  576. return err
  577. }
  578. return a.addToNewBucket(ka, bucket)
  579. }
  580. func (a *addrBook) randomPickAddresses(bucketType byte, num int) []*p2p.NetAddress {
  581. var buckets []map[string]*knownAddress
  582. switch bucketType {
  583. case bucketTypeNew:
  584. buckets = a.bucketsNew
  585. case bucketTypeOld:
  586. buckets = a.bucketsOld
  587. default:
  588. panic("unexpected bucketType")
  589. }
  590. total := 0
  591. for _, bucket := range buckets {
  592. total += len(bucket)
  593. }
  594. addresses := make([]*knownAddress, 0, total)
  595. for _, bucket := range buckets {
  596. for _, ka := range bucket {
  597. addresses = append(addresses, ka)
  598. }
  599. }
  600. selection := make([]*p2p.NetAddress, 0, num)
  601. chosenSet := make(map[string]bool, num)
  602. rand.Shuffle(total, func(i, j int) {
  603. addresses[i], addresses[j] = addresses[j], addresses[i]
  604. })
  605. for _, addr := range addresses {
  606. if chosenSet[addr.Addr.String()] {
  607. continue
  608. }
  609. chosenSet[addr.Addr.String()] = true
  610. selection = append(selection, addr.Addr)
  611. if len(selection) >= num {
  612. return selection
  613. }
  614. }
  615. return selection
  616. }
  617. // Make space in the new buckets by expiring the really bad entries.
  618. // If no bad entries are available we remove the oldest.
  619. func (a *addrBook) expireNew(bucketIdx int) {
  620. for addrStr, ka := range a.bucketsNew[bucketIdx] {
  621. // If an entry is bad, throw it away
  622. if ka.isBad() {
  623. a.Logger.Info(fmt.Sprintf("expiring bad address %v", addrStr))
  624. a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
  625. return
  626. }
  627. }
  628. // If we haven't thrown out a bad entry, throw out the oldest entry
  629. oldest := a.pickOldest(bucketTypeNew, bucketIdx)
  630. a.removeFromBucket(oldest, bucketTypeNew, bucketIdx)
  631. }
  632. // Promotes an address from new to old. If the destination bucket is full,
  633. // demote the oldest one to a "new" bucket.
  634. // TODO: Demote more probabilistically?
  635. func (a *addrBook) moveToOld(ka *knownAddress) error {
  636. // Sanity check
  637. if ka.isOld() {
  638. a.Logger.Error(fmt.Sprintf("Cannot promote address that is already old %v", ka))
  639. return nil
  640. }
  641. if len(ka.Buckets) == 0 {
  642. a.Logger.Error(fmt.Sprintf("Cannot promote address that isn't in any new buckets %v", ka))
  643. return nil
  644. }
  645. // Remove from all (new) buckets.
  646. a.removeFromAllBuckets(ka)
  647. // It's officially old now.
  648. ka.BucketType = bucketTypeOld
  649. // Try to add it to its oldBucket destination.
  650. oldBucketIdx, err := a.calcOldBucket(ka.Addr)
  651. if err != nil {
  652. return err
  653. }
  654. added := a.addToOldBucket(ka, oldBucketIdx)
  655. if !added {
  656. // No room; move the oldest to a new bucket
  657. oldest := a.pickOldest(bucketTypeOld, oldBucketIdx)
  658. a.removeFromBucket(oldest, bucketTypeOld, oldBucketIdx)
  659. newBucketIdx, err := a.calcNewBucket(oldest.Addr, oldest.Src)
  660. if err != nil {
  661. return err
  662. }
  663. a.addToNewBucket(oldest, newBucketIdx)
  664. // Finally, add our ka to old bucket again.
  665. added = a.addToOldBucket(ka, oldBucketIdx)
  666. if !added {
  667. a.Logger.Error(fmt.Sprintf("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
  668. }
  669. }
  670. return nil
  671. }
  672. func (a *addrBook) removeAddress(addr *p2p.NetAddress) {
  673. ka := a.addrLookup[addr.ID]
  674. if ka == nil {
  675. return
  676. }
  677. a.Logger.Info("Remove address from book", "addr", addr)
  678. a.removeFromAllBuckets(ka)
  679. }
  680. func (a *addrBook) addBadPeer(addr *p2p.NetAddress, banTime time.Duration) bool {
  681. // check it exists in addrbook
  682. ka := a.addrLookup[addr.ID]
  683. // check address is not already there
  684. if ka == nil {
  685. return false
  686. }
  687. if _, alreadyBadPeer := a.badPeers[addr.ID]; !alreadyBadPeer {
  688. // add to bad peer list
  689. ka.ban(banTime)
  690. a.badPeers[addr.ID] = ka
  691. a.Logger.Info("Add address to blacklist", "addr", addr)
  692. }
  693. return true
  694. }
  695. //---------------------------------------------------------------------
  696. // calculate bucket placements
  697. // hash(key + sourcegroup + int64(hash(key + group + sourcegroup)) % bucket_per_group) % num_new_buckets
  698. func (a *addrBook) calcNewBucket(addr, src *p2p.NetAddress) (int, error) {
  699. data1 := []byte{}
  700. data1 = append(data1, []byte(a.key)...)
  701. data1 = append(data1, []byte(a.groupKey(addr))...)
  702. data1 = append(data1, []byte(a.groupKey(src))...)
  703. hash1, err := a.hash(data1)
  704. if err != nil {
  705. return 0, err
  706. }
  707. hash64 := binary.BigEndian.Uint64(hash1)
  708. hash64 %= newBucketsPerGroup
  709. var hashbuf [8]byte
  710. binary.BigEndian.PutUint64(hashbuf[:], hash64)
  711. data2 := []byte{}
  712. data2 = append(data2, []byte(a.key)...)
  713. data2 = append(data2, a.groupKey(src)...)
  714. data2 = append(data2, hashbuf[:]...)
  715. hash2, err := a.hash(data2)
  716. if err != nil {
  717. return 0, err
  718. }
  719. result := int(binary.BigEndian.Uint64(hash2) % newBucketCount)
  720. return result, nil
  721. }
  722. // hash(key + group + int64(hash(key + addr)) % buckets_per_group) % num_old_buckets
  723. func (a *addrBook) calcOldBucket(addr *p2p.NetAddress) (int, error) {
  724. data1 := []byte{}
  725. data1 = append(data1, []byte(a.key)...)
  726. data1 = append(data1, []byte(addr.String())...)
  727. hash1, err := a.hash(data1)
  728. if err != nil {
  729. return 0, err
  730. }
  731. hash64 := binary.BigEndian.Uint64(hash1)
  732. hash64 %= oldBucketsPerGroup
  733. var hashbuf [8]byte
  734. binary.BigEndian.PutUint64(hashbuf[:], hash64)
  735. data2 := []byte{}
  736. data2 = append(data2, []byte(a.key)...)
  737. data2 = append(data2, a.groupKey(addr)...)
  738. data2 = append(data2, hashbuf[:]...)
  739. hash2, err := a.hash(data2)
  740. if err != nil {
  741. return 0, err
  742. }
  743. result := int(binary.BigEndian.Uint64(hash2) % oldBucketCount)
  744. return result, nil
  745. }
  746. // Return a string representing the network group of this address.
  747. // This is the /16 for IPv4 (e.g. 1.2.0.0), the /32 (/36 for he.net) for IPv6, the string
  748. // "local" for a local address and the string "unroutable" for an unroutable
  749. // address.
  750. func (a *addrBook) groupKey(na *p2p.NetAddress) string {
  751. return groupKeyFor(na, a.routabilityStrict)
  752. }
  753. func groupKeyFor(na *p2p.NetAddress, routabilityStrict bool) string {
  754. if routabilityStrict && na.Local() {
  755. return "local"
  756. }
  757. if routabilityStrict && !na.Routable() {
  758. return "unroutable"
  759. }
  760. if ipv4 := na.IP.To4(); ipv4 != nil {
  761. return na.IP.Mask(net.CIDRMask(16, 32)).String()
  762. }
  763. if na.RFC6145() || na.RFC6052() {
  764. // last four bytes are the ip address
  765. ip := na.IP[12:16]
  766. return ip.Mask(net.CIDRMask(16, 32)).String()
  767. }
  768. if na.RFC3964() {
  769. ip := na.IP[2:6]
  770. return ip.Mask(net.CIDRMask(16, 32)).String()
  771. }
  772. if na.RFC4380() {
  773. // teredo tunnels have the last 4 bytes as the v4 address XOR
  774. // 0xff.
  775. ip := net.IP(make([]byte, 4))
  776. for i, byte := range na.IP[12:16] {
  777. ip[i] = byte ^ 0xff
  778. }
  779. return ip.Mask(net.CIDRMask(16, 32)).String()
  780. }
  781. if na.OnionCatTor() {
  782. // group is keyed off the first 4 bits of the actual onion key.
  783. return fmt.Sprintf("tor:%d", na.IP[6]&((1<<4)-1))
  784. }
  785. // OK, so now we know ourselves to be a IPv6 address.
  786. // bitcoind uses /32 for everything, except for Hurricane Electric's
  787. // (he.net) IP range, which it uses /36 for.
  788. bits := 32
  789. heNet := &net.IPNet{IP: net.ParseIP("2001:470::"), Mask: net.CIDRMask(32, 128)}
  790. if heNet.Contains(na.IP) {
  791. bits = 36
  792. }
  793. ipv6Mask := net.CIDRMask(bits, 128)
  794. return na.IP.Mask(ipv6Mask).String()
  795. }
  796. func (a *addrBook) hash(b []byte) ([]byte, error) {
  797. hasher, err := highwayhash.New64(a.hashKey)
  798. if err != nil {
  799. return nil, err
  800. }
  801. hasher.Write(b)
  802. return hasher.Sum(nil), nil
  803. }