// XXX return errors too
func readVarIntList(r io.Reader) []uint64 {
length, _, err := encVarint.ReadVarInt(r)
if err != nil {
log.Println(err)
return nil
}
x := make([]uint64, length)
for i := range x {
if x[i], _, err = encVarint.ReadVarInt(r); err != nil {
log.Println(err)
return nil
}
}
return x
}
func parseMsg(r io.Reader) (m msg, err error) {
m.PowNonce = readBytes8(r)
// TODO:
buf := new(bytes.Buffer)
if _, err := io.Copy(buf, r); err != nil {
return m, err
}
r = buf
if err := checkProofOfWork(buf.Bytes(), m.PowNonce); err != nil {
return m, err
}
// TODO: Soon moving to uint32 in the wire.
m.Time = uint64(readUint32(r))
m.StreamNumber, _, err = encVarint.ReadVarInt(r)
if err != nil {
return m, fmt.Errorf("parseMsg reading Stream Number: %v\n", err)
}
buf = new(bytes.Buffer)
if n, err := io.Copy(buf, r); err != nil {
return m, err
} else if n == 0 {
return m, fmt.Errorf("parseMsg Encrypted content empty")
}
m.Encrypted = buf.Bytes()
return m, nil
}
func parseInv(r io.Reader) ([]inventoryVector, error) {
count, _, err := encVarint.ReadVarInt(r)
if err != nil {
return nil, err
}
ivs := make([]inventoryVector, count)
err = binary.Read(r, binary.BigEndian, ivs)
return ivs, err
}
func TestVarIntDecode(t *testing.T) {
// This was obtained by debugging a PyBitMessage message. Only the first 4
// bytes are relevant. The problem I had was with endianess if the varint
// decoding library (bitcoin and bitmessage use different endianess.)
count, x, err := encVarint.ReadVarInt(bytes.NewBuffer([]byte("\xfd\x10y\xc2\xeb\xbf\x12\xe0k:")))
if err != nil {
t.Errorf("got err: %v", err.Error())
}
if count != 4217 {
t.Errorf("wanted 4217, got %d (%d)", count, x)
}
}
func readNetworkAddressList(r io.Reader) ([]extendedNetworkAddress, error) {
length, _, err := encVarint.ReadVarInt(r)
if err != nil {
return nil, err
}
log.Println("entries", length)
addrs := make([]extendedNetworkAddress, length)
for i := range addrs {
addr := extendedNetworkAddress{}
if err := binary.Read(r, binary.BigEndian, &addr); err != nil {
return nil, err
}
addrs[i] = addr
}
return addrs, nil
}
func parseBroadcast(r io.Reader) (b broadcast, err error) {
b.PowNonce = readBytes8(r)
buf := new(bytes.Buffer)
if _, err := io.Copy(buf, r); err != nil {
return b, err
}
r = buf
if err := checkProofOfWork(buf.Bytes(), b.PowNonce); err != nil {
return b, err
}
// TODO: Soon moving to uint32 in the wire.
b.Time = uint64(readUint32(r))
b.BroadcastVersion, _, err = encVarint.ReadVarInt(r)
if err != nil {
return b, fmt.Errorf("parseBroadcast reading broadcast version: %v\n", err)
}
if b.BroadcastVersion != 1 {
return b, fmt.Errorf("I do not yet support Broadcasts of version %d", b.BroadcastVersion)
}
b.AddressVersion, _, err = encVarint.ReadVarInt(r)
if err != nil {
return b, fmt.Errorf("parseBroadcast reading address version: %v\n", err)
}
b.StreamNumber, _, err = encVarint.ReadVarInt(r)
if err != nil {
return b, fmt.Errorf("parseBroadcast reading Stream Number: %v\n", err)
}
b.Behavior = readUint32(r)
if b.Behavior != 1 {
log.Printf("warning: parseBroadcast unknown behavior mask: %x\n", b.Behavior)
}
if err = binary.Read(r, binary.BigEndian, &b.PublicSigningKey); err != nil {
return b, fmt.Errorf("parseBroadcast PublicSigningKey err: %v\n", err)
}
if err = binary.Read(r, binary.BigEndian, &b.PublicEncryptionKey); err != nil {
return b, fmt.Errorf("parseBroadcast PublicEncryptionKey err: %v\n", err)
}
if err = binary.Read(r, binary.BigEndian, &b.AddressHash); err != nil {
return b, fmt.Errorf("parseBroadcast AddressHash err: %v\n", err)
}
// PyBitMessage just writes '\x02'.
b.Encoding, _, err = encVarint.ReadVarInt(r)
if err != nil {
return b, fmt.Errorf("parseBroadcast reading encoding: %v\n", err)
}
if b.MessageLength, _, err = encVarint.ReadVarInt(r); err != nil {
return b, fmt.Errorf("parseBroadcast reading message length: %v\n", err)
}
b.Message = make([]byte, b.MessageLength)
if _, err = r.Read(b.Message); err != nil {
return b, fmt.Errorf("parseBroadcast reading message: %v\n", err)
}
if b.SigLength, _, err = encVarint.ReadVarInt(r); err != nil {
return b, fmt.Errorf("parseBroadcast reading siglength: %v\n", err)
}
b.Signature = make([]byte, b.SigLength)
if _, err = r.Read(b.Message); err != nil {
return b, fmt.Errorf("parseBroadcast reading signature: %v\n", err)
}
return b, nil
}
