func get_headers() {
if SeedNode != "" {
pr, e := peersdb.NewPeerFromString(SeedNode, false)
if e != nil {
fmt.Println("Seed node error:", e.Error())
} else {
fmt.Println("Seed node:", pr.Ip())
new_connection(pr)
}
}
LastBlock.Mutex.Lock()
LastBlock.node = MemBlockChain.BlockTreeEnd
LastBlock.Mutex.Unlock()
tickTick := time.Tick(100 * time.Millisecond)
tickStat := time.Tick(6 * time.Second)
for !GlobalExit() && !GetAllHeadersDone() {
select {
case <-tickTick:
add_new_connections()
case <-tickStat:
LastBlock.Mutex.Lock()
fmt.Println("Last Header Height:", LastBlock.node.Height, "...")
LastBlock.Mutex.Unlock()
usif_prompt()
}
}
}
func net_conn(par string) {
ad, er := peersdb.NewPeerFromString(par, false)
if er != nil {
fmt.Println(par, er.Error())
return
}
fmt.Println("Conencting to", ad.Ip())
network.DoNetwork(ad)
}
// TCP server
func tcp_server() {
ad, e := net.ResolveTCPAddr("tcp4", fmt.Sprint("0.0.0.0:", common.DefaultTcpPort))
if e != nil {
println("ResolveTCPAddr", e.Error())
return
}
lis, e := net.ListenTCP("tcp4", ad)
if e != nil {
println("ListenTCP", e.Error())
return
}
defer lis.Close()
//fmt.Println("TCP server started at", ad.String())
for common.IsListenTCP() {
common.CountSafe("NetServerLoops")
Mutex_net.Lock()
ica := InConsActive
Mutex_net.Unlock()
if ica < atomic.LoadUint32(&common.CFG.Net.MaxInCons) {
lis.SetDeadline(time.Now().Add(time.Second))
tc, e := lis.AcceptTCP()
if e == nil {
var terminate bool
if common.DebugLevel > 0 {
fmt.Println("Incoming connection from", tc.RemoteAddr().String())
}
// set port to default, for incomming connections
ad, e := peersdb.NewPeerFromString(tc.RemoteAddr().String(), true)
if e == nil {
// Hammering protection
HammeringMutex.Lock()
ti, ok := RecentlyDisconencted[ad.NetAddr.Ip4]
HammeringMutex.Unlock()
if ok && time.Now().Sub(ti) < HammeringMinReconnect {
//println(ad.Ip(), "is hammering within", time.Now().Sub(ti).String())
common.CountSafe("BanHammerIn")
ad.Ban()
terminate = true
}
if !terminate {
// Incoming IP passed all the initial checks - talk to it
conn := NewConnection(ad)
conn.X.ConnectedAt = time.Now()
conn.X.Incomming = true
conn.Conn = tc
Mutex_net.Lock()
if _, ok := OpenCons[ad.UniqID()]; ok {
//fmt.Println(ad.Ip(), "already connected")
common.CountSafe("SameIpReconnect")
Mutex_net.Unlock()
terminate = true
} else {
OpenCons[ad.UniqID()] = conn
InConsActive++
Mutex_net.Unlock()
go func() {
conn.Run()
Mutex_net.Lock()
delete(OpenCons, ad.UniqID())
InConsActive--
Mutex_net.Unlock()
}()
}
}
} else {
if common.DebugLevel > 0 {
println("NewPeerFromString:", e.Error())
}
common.CountSafe("InConnRefused")
terminate = true
}
// had any error occured - close teh TCP connection
if terminate {
tc.Close()
}
}
} else {
time.Sleep(1e9)
}
}
Mutex_net.Lock()
for _, c := range OpenCons {
if c.X.Incomming {
c.Disconnect()
}
}
TCPServerStarted = false
Mutex_net.Unlock()
//fmt.Println("TCP server stopped")
}