Documentation
¶
Index ¶
Examples ¶
Constants ¶
const ( DiscRequested DiscReason = 0x00 DiscNetworkError = 0x01 DiscProtocolError = 0x02 DiscUselessPeer = 0x03 DiscTooManyPeers = 0x04 DiscAlreadyConnected = 0x05 DiscIncompatibleVersion = 0x06 DiscInvalidIdentity = 0x07 DiscQuitting = 0x08 DiscUnexpectedIdentity = 0x09 DiscSelf = 0x0a DiscReadTimeout = 0x0b DiscSubprotocolError = 0x10 )
Variables ¶
var ErrPipeClosed = errors.New("p2p: read or write on closed message pipe")
ErrPipeClosed is returned from pipe operations after the pipe has been closed.
Functions ¶
func MsgPipe ¶
MsgPipe creates a message pipe. Reads on one end are matched with writes on the other. The pipe is full-duplex, both ends implement MsgReadWriter.
Example ¶
rw1, rw2 := MsgPipe()
go func() {
rw1.EncodeMsg(8, []byte{0, 0})
rw1.EncodeMsg(5, []byte{1, 1})
rw1.Close()
}()
for {
msg, err := rw2.ReadMsg()
if err != nil {
break
}
var data [1][]byte
msg.Decode(&data)
fmt.Printf("msg: %d, %x\n", msg.Code, data[0])
}
Output: msg: 8, 0000 msg: 5, 0101
Types ¶
type BlacklistMap ¶
type BlacklistMap struct {
// contains filtered or unexported fields
}
func NewBlacklist ¶
func NewBlacklist() *BlacklistMap
func (*BlacklistMap) Delete ¶
func (self *BlacklistMap) Delete(pubkey []byte) error
func (*BlacklistMap) Exists ¶
func (self *BlacklistMap) Exists(pubkey []byte) (ok bool)
func (*BlacklistMap) Put ¶
func (self *BlacklistMap) Put(pubkey []byte) error
type ClientIdentity ¶
type ClientIdentity interface {
String() string // human readable identity
Pubkey() []byte // 512-bit public key
}
ClientIdentity represents the identity of a peer.
type DiscReason ¶
type DiscReason byte
func (DiscReason) String ¶
func (d DiscReason) String() string
type Msg ¶
Msg defines the structure of a p2p message.
Note that a Msg can only be sent once since the Payload reader is consumed during sending. It is not possible to create a Msg and send it any number of times. If you want to reuse an encoded structure, encode the payload into a byte array and create a separate Msg with a bytes.Reader as Payload for each send.
type MsgPipeRW ¶
type MsgPipeRW struct {
// contains filtered or unexported fields
}
MsgPipeRW is an endpoint of a MsgReadWriter pipe.
func (*MsgPipeRW) Close ¶
Close unblocks any pending ReadMsg and WriteMsg calls on both ends of the pipe. They will return ErrPipeClosed. Note that Close does not interrupt any reads from a message payload.
func (*MsgPipeRW) EncodeMsg ¶
EncodeMsg is a convenient shorthand for sending an RLP-encoded message.
type MsgReadWriter ¶
MsgReadWriter provides reading and writing of encoded messages.
type MsgWriter ¶
type MsgWriter interface {
// WriteMsg sends an existing message.
// The Payload reader of the message is consumed.
// Note that messages can be sent only once.
WriteMsg(Msg) error
// EncodeMsg writes an RLP-encoded message with the given
// code and data elements.
EncodeMsg(code uint64, data ...interface{}) error
}
type NAT ¶
type NAT interface {
GetExternalAddress() (net.IP, error)
AddPortMapping(protocol string, extport, intport int, name string, lifetime time.Duration) error
DeletePortMapping(protocol string, extport, intport int) error
// Should return name of the method.
String() string
}
NAT is implemented by NAT traversal methods.
type Peer ¶
type Peer struct {
// Peers have all the log methods.
// Use them to display messages related to the peer.
*logger.Logger
// contains filtered or unexported fields
}
Peer represents a remote peer.
func NewPeer ¶
func NewPeer(id ClientIdentity, caps []Cap) *Peer
NewPeer returns a peer for testing purposes.
func (*Peer) Disconnect ¶
func (p *Peer) Disconnect(reason DiscReason)
Disconnect terminates the peer connection with the given reason. It returns immediately and does not wait until the connection is closed.
func (*Peer) Identity ¶
func (p *Peer) Identity() ClientIdentity
Identity returns the client identity of the remote peer. The identity can be nil if the peer has not yet completed the handshake.
func (*Peer) RemoteAddr ¶
RemoteAddr returns the remote address of the network connection.
type Protocol ¶
type Protocol struct {
// Name should contain the official protocol name,
// often a three-letter word.
Name string
// Version should contain the version number of the protocol.
Version uint
// Length should contain the number of message codes used
// by the protocol.
Length uint64
// Run is called in a new groutine when the protocol has been
// negotiated with a peer. It should read and write messages from
// rw. The Payload for each message must be fully consumed.
//
// The peer connection is closed when Start returns. It should return
// any protocol-level error (such as an I/O error) that is
// encountered.
Run func(peer *Peer, rw MsgReadWriter) error
}
Protocol represents a P2P subprotocol implementation.
type Server ¶
type Server struct {
// This field must be set to a valid client identity.
Identity ClientIdentity
// MaxPeers is the maximum number of peers that can be
// connected. It must be greater than zero.
MaxPeers int
// Protocols should contain the protocols supported
// by the server. Matching protocols are launched for
// each peer.
Protocols []Protocol
// If Blacklist is set to a non-nil value, the given Blacklist
// is used to verify peer connections.
Blacklist Blacklist
// If ListenAddr is set to a non-nil address, the server
// will listen for incoming connections.
//
// If the port is zero, the operating system will pick a port. The
// ListenAddr field will be updated with the actual address when
// the server is started.
ListenAddr string
// If set to a non-nil value, the given NAT port mapper
// is used to make the listening port available to the
// Internet.
NAT NAT
// If Dialer is set to a non-nil value, the given Dialer
// is used to dial outbound peer connections.
Dialer *net.Dialer
// If NoDial is true, the server will not dial any peers.
NoDial bool
// contains filtered or unexported fields
}
Server manages all peer connections.
The fields of Server are used as configuration parameters. You should set them before starting the Server. Fields may not be modified while the server is running.
func (*Server) Broadcast ¶
Broadcast sends an RLP-encoded message to all connected peers. This method is deprecated and will be removed later.
func (*Server) Start ¶
Start starts running the server. Servers can be re-used and started again after stopping.
type SimpleClientIdentity ¶
type SimpleClientIdentity struct {
// contains filtered or unexported fields
}
func NewSimpleClientIdentity ¶
func NewSimpleClientIdentity(clientIdentifier string, version string, customIdentifier string, pubkey string) *SimpleClientIdentity
func (*SimpleClientIdentity) GetCustomIdentifier ¶
func (c *SimpleClientIdentity) GetCustomIdentifier() string
func (*SimpleClientIdentity) Pubkey ¶
func (c *SimpleClientIdentity) Pubkey() []byte
func (*SimpleClientIdentity) SetCustomIdentifier ¶
func (c *SimpleClientIdentity) SetCustomIdentifier(customIdentifier string)
func (*SimpleClientIdentity) String ¶
func (c *SimpleClientIdentity) String() string
Source Files