btcd/msgheaders.go

// 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 := "MsgHeaders.AddBlockHeader: too many block headers " +
			"for message [max %v]"
		return fmt.Errorf(str, MaxBlockHeadersPerMsg)
	}

	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 := "MsgHeaders.BtcDecode: too many block headers in message [%v]"
		return fmt.Errorf(str, count)
	}

	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 := "MsgHeaders.BtcDecode: block headers may not " +
				"contain transactions [%v]"
			return fmt.Errorf(str, count)
		}
		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 := "MsgHeaders.BtcEncode: too many block headers in message [%v]"
		return fmt.Errorf(str, count)
	}

	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 := "MsgHeaders.BtcEncode: block headers " +
				"may not contain transactions [%v]"
			return fmt.Errorf(str, count)
		}

		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)
}

// NewMsgGetHeaders returns a new bitcoin headers message that conforms to the
// Message interface.  See MsgHeaders for details.
func NewMsgHeaders() *MsgHeaders {
	return &MsgHeaders{}
}