func (c *one_net_conn) headers(d []byte) {
var hdr [81]byte
b := bytes.NewReader(d)
cnt, er := btc.ReadVLen(b)
if er != nil {
return
}
if cnt == 0 /*|| LastBlock.node.Height>=150e3*/ {
SetAllHeadersDone(true)
return
}
for i := uint64(0); i < cnt; i++ {
if _, er = b.Read(hdr[:]); er != nil {
return
}
if hdr[80] != 0 {
fmt.Println(LastBlock.node.Height, "Unexpected value of txn_count")
continue
}
bl, er := btc.NewBlock(hdr[:])
if er == nil {
er = chkblock(bl)
if er != nil {
fmt.Println(er.Error())
os.Exit(1)
}
} else {
fmt.Println(LastBlock.node.Height, er.Error())
}
}
//fmt.Println("Height:", LastBlock.node.Height)
}
// Parese network's "addr" message
func ParseAddr(pl []byte) {
b := bytes.NewBuffer(pl)
cnt, _ := btc.ReadVLen(b)
for i := 0; i < int(cnt); i++ {
var buf [30]byte
n, e := b.Read(buf[:])
if n != len(buf) || e != nil {
common.CountSafe("AddrError")
//println("ParseAddr:", n, e)
break
}
a := peersdb.NewPeer(buf[:])
if !sys.ValidIp4(a.Ip4[:]) {
common.CountSafe("AddrInvalid")
} else if time.Unix(int64(a.Time), 0).Before(time.Now().Add(time.Minute)) {
if time.Now().Before(time.Unix(int64(a.Time), 0).Add(peersdb.ExpirePeerAfter)) {
k := qdb.KeyType(a.UniqID())
v := peersdb.PeerDB.Get(k)
if v != nil {
a.Banned = peersdb.NewPeer(v[:]).Banned
}
peersdb.PeerDB.Put(k, a.Bytes())
} else {
common.CountSafe("AddrStale")
}
} else {
common.CountSafe("AddrInFuture")
}
}
}
func parse_addr(pl []byte) {
b := bytes.NewBuffer(pl)
cnt, _ := btc.ReadVLen(b)
for i := 0; i < int(cnt); i++ {
var buf [30]byte
n, e := b.Read(buf[:])
if n != len(buf) || e != nil {
COUNTER("ADER")
//println("ParseAddr:", n, e)
break
}
a := peersdb.NewPeer(buf[:])
if !sys.ValidIp4(a.Ip4[:]) {
COUNTER("ADNO")
} else if time.Unix(int64(a.Time), 0).Before(time.Now().Add(time.Minute)) {
if time.Now().Before(time.Unix(int64(a.Time), 0).Add(peersdb.ExpirePeerAfter)) {
k := qdb.KeyType(a.UniqID())
v := peersdb.PeerDB.Get(k)
if v != nil {
a.Banned = peersdb.NewPeer(v[:]).Banned
}
peersdb.PeerDB.Put(k, a.Bytes())
} else {
COUNTER("ADST")
}
} else {
COUNTER("ADFU")
}
}
}
// Read VLen followed by the number of locators
// parse the payload of getblocks and getheaders messages
func parseLocatorsPayload(pl []byte) (h2get []*btc.Uint256, hashstop *btc.Uint256, er error) {
var cnt uint64
var h [32]byte
var ver uint32
b := bytes.NewReader(pl)
// version
if er = binary.Read(b, binary.LittleEndian, &ver); er != nil {
return
}
// hash count
cnt, er = btc.ReadVLen(b)
if er != nil {
return
}
// block locator hashes
if cnt > 0 {
h2get = make([]*btc.Uint256, cnt)
for i := 0; i < int(cnt); i++ {
if _, er = b.Read(h[:]); er != nil {
return
}
h2get[i] = btc.NewUint256(h[:])
}
}
// hash_stop
if _, er = b.Read(h[:]); er != nil {
return
}
hashstop = btc.NewUint256(h[:])
return
}
func (c *OneConnection) ProcessGetData(pl []byte) {
var notfound []byte
//println(c.PeerAddr.Ip(), "getdata")
b := bytes.NewReader(pl)
cnt, e := btc.ReadVLen(b)
if e != nil {
println("ProcessGetData:", e.Error(), c.PeerAddr.Ip())
return
}
for i := 0; i < int(cnt); i++ {
var typ uint32
var h [36]byte
n, _ := b.Read(h[:])
if n != 36 {
println("ProcessGetData: pl too short", c.PeerAddr.Ip())
return
}
typ = binary.LittleEndian.Uint32(h[:4])
common.CountSafe(fmt.Sprint("GetdataType", typ))
if typ == 2 {
uh := btc.NewUint256(h[4:])
bl, _, er := common.BlockChain.Blocks.BlockGet(uh)
if er == nil {
c.SendRawMsg("block", bl)
} else {
notfound = append(notfound, h[:]...)
}
} else if typ == 1 {
// transaction
uh := btc.NewUint256(h[4:])
TxMutex.Lock()
if tx, ok := TransactionsToSend[uh.BIdx()]; ok && tx.Blocked == 0 {
tx.SentCnt++
tx.Lastsent = time.Now()
TxMutex.Unlock()
c.SendRawMsg("tx", tx.Data)
} else {
TxMutex.Unlock()
notfound = append(notfound, h[:]...)
}
} else {
if common.DebugLevel > 0 {
println("getdata for type", typ, "not supported yet")
}
if typ > 0 && typ <= 3 /*3 is a filtered block(we dont support it)*/ {
notfound = append(notfound, h[:]...)
}
}
}
if len(notfound) > 0 {
buf := new(bytes.Buffer)
btc.WriteVlen(buf, uint64(len(notfound)/36))
buf.Write(notfound)
c.SendRawMsg("notfound", buf.Bytes())
}
}