func main() {
var dir string
if len(os.Args) > 1 {
dir = os.Args[1]
} else {
dir = sys.BitcoinHome() + "gocoin" + string(os.PathSeparator) + "btcnet" + string(os.PathSeparator) + "peers3"
}
db, er := qdb.NewDB(dir, true)
if er != nil {
println(er.Error())
os.Exit(1)
}
println(db.Count(), "peers in databse", dir)
if db.Count() == 0 {
return
}
tmp := make(manyPeers, db.Count())
cnt := 0
db.Browse(func(k qdb.KeyType, v []byte) uint32 {
np := utils.NewPeer(v)
if !sys.ValidIp4(np.Ip4[:]) {
return 0
}
if cnt < len(tmp) {
tmp[cnt] = np
cnt++
}
return 0
})
sort.Sort(tmp[:cnt])
for cnt = 0; cnt < len(tmp) && cnt < 2500; cnt++ {
ad := tmp[cnt]
fmt.Printf("%3d) %16s %5d - seen %5d min ago\n", cnt+1,
fmt.Sprintf("%d.%d.%d.%d", ad.Ip4[0], ad.Ip4[1], ad.Ip4[2], ad.Ip4[3]),
ad.Port, (time.Now().Unix()-int64(ad.Time))/60)
}
}
func main() {
var ptr *byte
if unsafe.Sizeof(ptr) < 8 {
fmt.Println("WARNING: Gocoin client shall be build for 64-bit arch. It will likely crash now.")
}
fmt.Println("Gocoin client version", gocoin.Version)
runtime.GOMAXPROCS(runtime.NumCPU()) // It seems that Go does not do it by default
// Disable Ctrl+C
signal.Notify(killchan, os.Interrupt, os.Kill)
defer func() {
if r := recover(); r != nil {
err, ok := r.(error)
if !ok {
err = fmt.Errorf("pkg: %v", r)
}
fmt.Println("main panic recovered:", err.Error())
fmt.Println(string(debug.Stack()))
network.NetCloseAll()
common.CloseBlockChain(false)
peersdb.ClosePeerDB()
sys.UnlockDatabaseDir()
os.Exit(1)
}
}()
common.InitConfig()
if common.FLAG.VolatileUTXO {
fmt.Println("WARNING! Using UTXO database in a volatile mode. Make sure to close the client properly (do not kill it!)")
}
if common.FLAG.TrustAll {
fmt.Println("WARNING! Assuming all scripts inside new blocks to PASS. Verify the last block's hash when finished.")
}
host_init() // This will create the DB lock file and keep it open
if common.FLAG.UndoBlocks > 0 {
usif.Exit_now = true
}
if common.FLAG.Rescan && common.FLAG.VolatileUTXO {
fmt.Println("UTXO database rebuilt complete in the volatile mode, so flush DB to disk and exit...")
} else if !usif.Exit_now {
common.RecalcAverageBlockSize(true)
peersTick := time.Tick(5 * time.Minute)
txPoolTick := time.Tick(time.Minute)
netTick := time.Tick(time.Second)
peersdb.Testnet = common.Testnet
peersdb.ConnectOnly = common.CFG.ConnectOnly
peersdb.Services = common.Services
peersdb.InitPeers(common.GocoinHomeDir)
if common.FLAG.UnbanAllPeers {
var keys []qdb.KeyType
var vals [][]byte
peersdb.PeerDB.Browse(func(k qdb.KeyType, v []byte) uint32 {
peer := utils.NewPeer(v)
if peer.Banned != 0 {
fmt.Println("Unban", peer.NetAddr.String())
peer.Banned = 0
keys = append(keys, k)
vals = append(vals, peer.Bytes())
}
return 0
})
for i := range keys {
peersdb.PeerDB.Put(keys[i], vals[i])
}
fmt.Println(len(keys), "peerts un-baned")
}
common.Last.Block = common.BlockChain.BlockTreeEnd
common.Last.Time = time.Unix(int64(common.Last.Block.Timestamp()), 0)
if common.Last.Time.After(time.Now()) {
common.Last.Time = time.Now()
}
for k, v := range common.BlockChain.BlockIndex {
network.ReceivedBlocks[k] = &network.OneReceivedBlock{TmStart: time.Unix(int64(v.Timestamp()), 0)}
}
network.LastCommitedHeader = common.Last.Block
if common.CFG.TextUI.Enabled {
go textui.MainThread()
}
if common.CFG.WebUI.Interface != "" {
fmt.Println("Starting WebUI at", common.CFG.WebUI.Interface, "...")
go webui.ServerThread(common.CFG.WebUI.Interface)
}
if common.CFG.RPC.Enabled {
go rpcapi.StartServer(common.RPCPort())
}
for !usif.Exit_now {
common.CountSafe("MainThreadLoops")
for retryCachedBlocks {
retryCachedBlocks = retry_cached_blocks()
// We have done one per loop - now do something else if pending...
if len(network.NetBlocks) > 0 || len(usif.UiChannel) > 0 {
break
}
}
common.Busy("")
select {
case s := <-killchan:
fmt.Println("Got signal:", s)
usif.Exit_now = true
continue
case rpcbl := <-rpcapi.RpcBlocks:
common.CountSafe("RPCNewBlock")
common.Busy("HandleRpcBlock()")
HandleRpcBlock(rpcbl)
case rec := <-usif.LocksChan:
common.CountSafe("MainLocks")
common.Busy("LockedByRequest")
rec.In.Done()
rec.Out.Wait()
continue
case newbl := <-network.NetBlocks:
common.CountSafe("MainNetBlock")
common.Busy("HandleNetBlock()")
HandleNetBlock(newbl)
case <-syncNow:
common.CountSafe("MainChainSync")
common.Busy("BlockChain.Sync()")
common.BlockChain.Sync()
case newtx := <-network.NetTxs:
common.CountSafe("MainNetTx")
common.Busy("network.HandleNetTx()")
network.HandleNetTx(newtx, false)
case <-netTick:
common.CountSafe("MainNetTick")
common.Busy("network.NetworkTick()")
network.NetworkTick()
case cmd := <-usif.UiChannel:
common.CountSafe("MainUICmd")
common.Busy("UI command")
cmd.Handler(cmd.Param)
cmd.Done.Done()
continue
case <-peersTick:
common.Busy("peersdb.ExpirePeers()")
peersdb.ExpirePeers()
case <-txPoolTick:
common.Busy("network.ExpireTxs()")
network.ExpireTxs()
case <-time.After(time.Second / 2):
common.CountSafe("MainThreadTouts")
if !retryCachedBlocks {
if usif.DefragUTXO {
usif.Exit_now = true
break
}
common.Busy("BlockChain.Idle()")
if common.BlockChain.Idle() {
common.CountSafe("ChainIdleUsed")
}
}
continue
}
}
network.NetCloseAll()
}
if usif.DefragUTXO {
fmt.Println("Closing blockchain while defragmenting UTXO")
} else {
fmt.Println("Closing blockchain")
}
sta := time.Now()
common.CloseBlockChain(usif.DefragUTXO)
fmt.Println("Blockchain closed in", time.Now().Sub(sta).String())
peersdb.ClosePeerDB()
sys.UnlockDatabaseDir()
}
func NewPeer(v []byte) (p *PeerAddr) {
p = new(PeerAddr)
p.OnePeer = utils.NewPeer(v)
return
}
func NewPeer(v []byte) (p *onePeer) {
p = new(onePeer)
p.OnePeer = utils.NewPeer(v)
return
}
