lbcd/msgheaders.go

125 lines
3.7 KiB
Go
Raw Normal View History

2013-05-08 21:31:00 +02:00
// Copyright (c) 2013 Conformal Systems LLC.
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package btcwire
import (
"fmt"
"io"
)
// MaxBlockHeadersPerMsg is the maximum number of block headers that can be in
// a single bitcoin headers message.
const MaxBlockHeadersPerMsg = 2000
// MsgHeaders implements the Message interface and represents a bitcoin headers
// message. It is used to deliver block header information in response
// to a getheaders message (MsgGetHeaders). The maximum number of block headers
// per message is currently 2000. See MsgGetHeaders for details on requesting
// the headers.
type MsgHeaders struct {
Headers []*BlockHeader
}
// AddBlockHeader adds a new block header to the message.
func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
str := fmt.Sprintf("too many block headers in message [max %v]",
MaxBlockHeadersPerMsg)
return messageError("MsgHeaders.AddBlockHeader", str)
2013-05-08 21:31:00 +02:00
}
msg.Headers = append(msg.Headers, bh)
return nil
}
// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
// This is part of the Message interface implementation.
func (msg *MsgHeaders) BtcDecode(r io.Reader, pver uint32) error {
count, err := readVarInt(r, pver)
if err != nil {
return err
}
// Limit to max block headers per message.
if count > MaxBlockHeadersPerMsg {
str := fmt.Sprintf("too many block headers for message "+
"[count %v, max %v]", count, MaxBlockHeadersPerMsg)
return messageError("MsgHeaders.BtcDecode", str)
2013-05-08 21:31:00 +02:00
}
msg.Headers = make([]*BlockHeader, 0, count)
2013-05-08 21:31:00 +02:00
for i := uint64(0); i < count; i++ {
bh := BlockHeader{}
err := readBlockHeader(r, pver, &bh)
if err != nil {
return err
}
// Ensure the transaction count is zero for headers.
if bh.TxnCount > 0 {
str := fmt.Sprintf("block headers may not contain "+
"transactions [count %v]", bh.TxnCount)
return messageError("MsgHeaders.BtcDecode", str)
2013-05-08 21:31:00 +02:00
}
msg.AddBlockHeader(&bh)
}
return nil
}
// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
// This is part of the Message interface implementation.
func (msg *MsgHeaders) BtcEncode(w io.Writer, pver uint32) error {
// Limit to max block headers per message.
count := len(msg.Headers)
if count > MaxBlockHeadersPerMsg {
str := fmt.Sprintf("too many block headers for message "+
"[count %v, max %v]", count, MaxBlockHeadersPerMsg)
return messageError("MsgHeaders.BtcEncode", str)
2013-05-08 21:31:00 +02:00
}
err := writeVarInt(w, pver, uint64(count))
if err != nil {
return err
}
for _, bh := range msg.Headers {
// Ensure block headers do not contain a transaction count.
if bh.TxnCount > 0 {
str := fmt.Sprintf("block headers may not contain "+
"transactions [count %v]", bh.TxnCount)
return messageError("MsgHeaders.BtcEncode", str)
2013-05-08 21:31:00 +02:00
}
err := writeBlockHeader(w, pver, bh)
if err != nil {
return err
}
}
return nil
}
// Command returns the protocol command string for the message. This is part
// of the Message interface implementation.
func (msg *MsgHeaders) Command() string {
return cmdHeaders
}
// MaxPayloadLength returns the maximum length the payload can be for the
// receiver. This is part of the Message interface implementation.
func (msg *MsgHeaders) MaxPayloadLength(pver uint32) uint32 {
// Num headers (varInt) + max allowed headers.
return maxVarIntPayload + (maxBlockHeaderPayload * MaxBlockHeadersPerMsg)
}
// NewMsgHeaders returns a new bitcoin headers message that conforms to the
2013-05-08 21:31:00 +02:00
// Message interface. See MsgHeaders for details.
func NewMsgHeaders() *MsgHeaders {
return &MsgHeaders{
Headers: make([]*BlockHeader, 0, MaxBlockHeadersPerMsg),
}
2013-05-08 21:31:00 +02:00
}