func get_best_peer() (peer *peersdb.PeerAddr) {
adrs := peersdb.GetBestPeers(100, is_connected)
if len(adrs) == 0 {
return nil
}
return adrs[rand.Int31n(int32(len(adrs)))]
}
func (c *OneConnection) SendAddr() {
pers := peersdb.GetBestPeers(MaxAddrsPerMessage, nil)
if len(pers) > 0 {
buf := new(bytes.Buffer)
btc.WriteVlen(buf, uint64(len(pers)))
for i := range pers {
binary.Write(buf, binary.LittleEndian, pers[i].Time)
buf.Write(pers[i].NetAddr.Bytes())
}
c.SendRawMsg("addr", buf.Bytes())
}
}
func NetworkTick() {
if common.IsListenTCP() {
if !TCPServerStarted {
TCPServerStarted = true
go tcp_server()
}
}
Mutex_net.Lock()
conn_cnt := OutConsActive
Mutex_net.Unlock()
if next_drop_slowest.IsZero() {
next_drop_slowest = time.Now().Add(DropSlowestEvery)
} else if conn_cnt >= atomic.LoadUint32(&common.CFG.Net.MaxOutCons) {
// Having max number of outgoing connections, check to drop the slowest one
if time.Now().After(next_drop_slowest) {
drop_slowest_peer()
next_drop_slowest = time.Now().Add(DropSlowestEvery)
}
}
// hammering protection - expire recently disconnected
if next_clean_hammers.IsZero() {
next_clean_hammers = time.Now().Add(HammeringMinReconnect)
} else if time.Now().After(next_clean_hammers) {
HammeringMutex.Lock()
for k, t := range RecentlyDisconencted {
if time.Now().Sub(t) >= HammeringMinReconnect {
delete(RecentlyDisconencted, k)
}
}
HammeringMutex.Unlock()
ExpireCachedBlocks()
next_clean_hammers = time.Now().Add(HammeringMinReconnect)
}
for conn_cnt < atomic.LoadUint32(&common.CFG.Net.MaxOutCons) {
adrs := peersdb.GetBestPeers(16, ConnectionActive)
if len(adrs) == 0 {
common.LockCfg()
if common.CFG.ConnectOnly == "" && common.DebugLevel > 0 {
println("no new peers", len(OpenCons), conn_cnt)
}
common.UnlockCfg()
break
}
DoNetwork(adrs[rand.Int31n(int32(len(adrs)))])
Mutex_net.Lock()
conn_cnt = OutConsActive
Mutex_net.Unlock()
}
}
func show_addresses(par string) {
fmt.Println(peersdb.PeerDB.Count(), "peers in the database")
if par == "list" {
cnt := 0
peersdb.PeerDB.Browse(func(k qdb.KeyType, v []byte) uint32 {
cnt++
fmt.Printf("%4d) %s\n", cnt, peersdb.NewPeer(v).String())
return 0
})
} else if par == "ban" {
cnt := 0
peersdb.PeerDB.Browse(func(k qdb.KeyType, v []byte) uint32 {
pr := peersdb.NewPeer(v)
if pr.Banned != 0 {
cnt++
fmt.Printf("%4d) %s\n", cnt, pr.String())
}
return 0
})
if cnt == 0 {
fmt.Println("No banned peers in the DB")
}
} else if par != "" {
limit, er := strconv.ParseUint(par, 10, 32)
if er != nil {
fmt.Println("Specify number of best peers to display")
return
}
prs := peersdb.GetBestPeers(uint(limit), nil)
for i := range prs {
fmt.Printf("%4d) %s", i+1, prs[i].String())
if network.ConnectionActive(prs[i]) {
fmt.Print(" CONNECTED")
}
fmt.Print("\n")
}
} else {
fmt.Println("Use 'peers list' to list them")
fmt.Println("Use 'peers ban' to list the benned ones")
fmt.Println("Use 'peers <number>' to show the most recent ones")
}
}
func NetworkTick() {
if common.IsListenTCP() {
if !TCPServerStarted {
TCPServerStarted = true
go tcp_server()
}
}
// Push GetHeaders if not in progress
Mutex_net.Lock()
var cnt_headers_in_progress int
var max_headers_got_cnt int
var _v *OneConnection
for _, v := range OpenCons {
v.Mutex.Lock()
if !v.X.AllHeadersReceived || v.X.GetHeadersInProgress {
cnt_headers_in_progress++
} else if !v.X.LastHeadersEmpty {
if _v == nil || v.X.TotalNewHeadersCount > max_headers_got_cnt {
max_headers_got_cnt = v.X.TotalNewHeadersCount
_v = v
}
}
v.Mutex.Unlock()
}
conn_cnt := OutConsActive
Mutex_net.Unlock()
if cnt_headers_in_progress == 0 {
if _v != nil {
common.CountSafe("GetHeadersPush")
/*println("No headers_in_progress, so take it from", _v.ConnID,
_v.X.TotalNewHeadersCount, _v.X.LastHeadersEmpty)*/
_v.Mutex.Lock()
_v.X.AllHeadersReceived = false
_v.Mutex.Unlock()
} else {
common.CountSafe("GetHeadersNone")
}
}
if common.CFG.DropPeers.DropEachMinutes != 0 {
if next_drop_peer.IsZero() {
next_drop_peer = time.Now().Add(common.DropSlowestEvery)
} else if time.Now().After(next_drop_peer) {
drop_worst_peer()
next_drop_peer = time.Now().Add(common.DropSlowestEvery)
}
}
// hammering protection - expire recently disconnected
if next_clean_hammers.IsZero() {
next_clean_hammers = time.Now().Add(HammeringMinReconnect)
} else if time.Now().After(next_clean_hammers) {
HammeringMutex.Lock()
for k, t := range RecentlyDisconencted {
if time.Now().Sub(t) >= HammeringMinReconnect {
delete(RecentlyDisconencted, k)
}
}
HammeringMutex.Unlock()
next_clean_hammers = time.Now().Add(HammeringMinReconnect)
}
for conn_cnt < atomic.LoadUint32(&common.CFG.Net.MaxOutCons) {
var segwit_conns uint32
if common.CFG.Net.MinSegwitCons > 0 {
Mutex_net.Lock()
for _, cc := range OpenCons {
if (cc.Node.Services & SERVICE_SEGWIT) != 0 {
segwit_conns++
}
}
Mutex_net.Unlock()
}
adrs := peersdb.GetBestPeers(128, func(ad *peersdb.PeerAddr) bool {
if segwit_conns < common.CFG.Net.MinSegwitCons && (ad.Services&SERVICE_SEGWIT) == 0 {
return true
}
return ConnectionActive(ad)
})
if len(adrs) == 0 {
common.LockCfg()
if common.CFG.ConnectOnly == "" && common.DebugLevel > 0 {
println("no new peers", len(OpenCons), conn_cnt)
}
common.UnlockCfg()
break
}
DoNetwork(adrs[rand.Int31n(int32(len(adrs)))])
Mutex_net.Lock()
conn_cnt = OutConsActive
Mutex_net.Unlock()
}
}