Documentation

Overview

    Package p2p implements the Ethereum p2p network protocols.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    View Source
    var ErrPipeClosed = errors.New("p2p: read or write on closed message pipe")

      ErrPipeClosed is returned from pipe operations after the pipe has been closed.

      View Source
      var (
      	ErrShuttingDown = errors.New("shutting down")
      )

      Functions

      func ExpectMsg

      func ExpectMsg(r MsgReader, code uint64, content interface{}) error

        ExpectMsg reads a message from r and verifies that its code and encoded RLP content match the provided values. If content is nil, the payload is discarded and not verified.

        func MsgPipe

        func MsgPipe() (*MsgPipeRW, *MsgPipeRW)

          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
          Output:
          
          msg: 8, 0000
          msg: 5, 0101
          

          func Send

          func Send(w MsgWriter, msgcode uint64, data interface{}) error

            Send writes an RLP-encoded message with the given code. data should encode as an RLP list.

            func SendItems

            func SendItems(w MsgWriter, msgcode uint64, elems ...interface{}) error

              SendItems writes an RLP with the given code and data elements. For a call such as:

              SendItems(w, code, e1, e2, e3)
              

              the message payload will be an RLP list containing the items:

              [e1, e2, e3]
              

              Types

              type Cap

              type Cap struct {
              	Name    string
              	Version uint
              }

                Cap is the structure of a peer capability.

                func (Cap) String

                func (cap Cap) String() string

                type Config

                type Config struct {
                	// This field must be set to a valid secp256k1 private key.
                	PrivateKey *ecdsa.PrivateKey `toml:"-"`
                
                	// MaxPeers is the maximum number of peers that can be
                	// connected. It must be greater than zero.
                	MaxPeers int
                
                	// MaxPendingPeers is the maximum number of peers that can be pending in the
                	// handshake phase, counted separately for inbound and outbound connections.
                	// Zero defaults to preset values.
                	MaxPendingPeers int `toml:",omitempty"`
                
                	// DialRatio controls the ratio of inbound to dialed connections.
                	// Example: a DialRatio of 2 allows 1/2 of connections to be dialed.
                	// Setting DialRatio to zero defaults it to 3.
                	DialRatio int `toml:",omitempty"`
                
                	// NoDiscovery can be used to disable the peer discovery mechanism.
                	// Disabling is useful for protocol debugging (manual topology).
                	NoDiscovery bool
                
                	// DiscoveryV5 specifies whether the new topic-discovery based V5 discovery
                	// protocol should be started or not.
                	DiscoveryV5 bool `toml:",omitempty"`
                
                	// Name sets the node name of this server.
                	// Use common.MakeName to create a name that follows existing conventions.
                	Name string `toml:"-"`
                
                	// BootstrapNodes are used to establish connectivity
                	// with the rest of the network.
                	BootstrapNodes []*enode.Node
                
                	// BootstrapNodesV5 are used to establish connectivity
                	// with the rest of the network using the V5 discovery
                	// protocol.
                	BootstrapNodesV5 []*discv5.Node `toml:",omitempty"`
                
                	// Static nodes are used as pre-configured connections which are always
                	// maintained and re-connected on disconnects.
                	StaticNodes []*enode.Node
                
                	// Trusted nodes are used as pre-configured connections which are always
                	// allowed to connect, even above the peer limit.
                	TrustedNodes []*enode.Node
                
                	// Connectivity can be restricted to certain IP networks.
                	// If this option is set to a non-nil value, only hosts which match one of the
                	// IP networks contained in the list are considered.
                	NetRestrict *netutil.Netlist `toml:",omitempty"`
                
                	// NodeDatabase is the path to the database containing the previously seen
                	// live nodes in the network.
                	NodeDatabase string `toml:",omitempty"`
                
                	// Protocols should contain the protocols supported
                	// by the server. Matching protocols are launched for
                	// each peer.
                	Protocols []Protocol `toml:"-"`
                
                	// 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.Interface `toml:",omitempty"`
                
                	// If Dialer is set to a non-nil value, the given Dialer
                	// is used to dial outbound peer connections.
                	Dialer NodeDialer `toml:"-"`
                
                	// If NoDial is true, the server will not dial any peers.
                	NoDial bool `toml:",omitempty"`
                
                	// If EnableMsgEvents is set then the server will emit PeerEvents
                	// whenever a message is sent to or received from a peer
                	EnableMsgEvents bool
                
                	// Logger is a custom logger to use with the p2p.Server.
                	Logger log.Logger `toml:",omitempty"`
                	// contains filtered or unexported fields
                }

                  Config holds Server options.

                  type DiscReason

                  type DiscReason uint
                  const (
                  	DiscRequested DiscReason = iota
                  	DiscNetworkError
                  	DiscProtocolError
                  	DiscUselessPeer
                  	DiscTooManyPeers
                  	DiscAlreadyConnected
                  	DiscIncompatibleVersion
                  	DiscInvalidIdentity
                  	DiscQuitting
                  	DiscUnexpectedIdentity
                  	DiscSelf
                  	DiscReadTimeout
                  	DiscSubprotocolError = 0x10
                  )

                  func (DiscReason) Error

                  func (d DiscReason) Error() string

                  func (DiscReason) String

                  func (d DiscReason) String() string

                  type Msg

                  type Msg struct {
                  	Code       uint64
                  	Size       uint32 // Size of the raw payload
                  	Payload    io.Reader
                  	ReceivedAt time.Time
                  	// contains filtered or unexported fields
                  }

                    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.

                    func (Msg) Decode

                    func (msg Msg) Decode(val interface{}) error

                      Decode parses the RLP content of a message into the given value, which must be a pointer.

                      For the decoding rules, please see package rlp.

                      func (Msg) Discard

                      func (msg Msg) Discard() error

                        Discard reads any remaining payload data into a black hole.

                        func (Msg) String

                        func (msg Msg) String() string

                        type MsgPipeRW

                        type MsgPipeRW struct {
                        	// contains filtered or unexported fields
                        }

                          MsgPipeRW is an endpoint of a MsgReadWriter pipe.

                          func (*MsgPipeRW) Close

                          func (p *MsgPipeRW) Close() error

                            Close unblocks any pending ReadMsg and WriteMsg calls on both ends of the pipe. They will return ErrPipeClosed. Close also interrupts any reads from a message payload.

                            func (*MsgPipeRW) ReadMsg

                            func (p *MsgPipeRW) ReadMsg() (Msg, error)

                              ReadMsg returns a message sent on the other end of the pipe.

                              func (*MsgPipeRW) WriteMsg

                              func (p *MsgPipeRW) WriteMsg(msg Msg) error

                                WriteMsg sends a message on the pipe. It blocks until the receiver has consumed the message payload.

                                type MsgReadWriter

                                type MsgReadWriter interface {
                                	MsgReader
                                	MsgWriter
                                }

                                  MsgReadWriter provides reading and writing of encoded messages. Implementations should ensure that ReadMsg and WriteMsg can be called simultaneously from multiple goroutines.

                                  type MsgReader

                                  type MsgReader interface {
                                  	ReadMsg() (Msg, error)
                                  }

                                  type MsgWriter

                                  type MsgWriter interface {
                                  	// WriteMsg sends a message. It will block until the message's
                                  	// Payload has been consumed by the other end.
                                  	//
                                  	// Note that messages can be sent only once because their
                                  	// payload reader is drained.
                                  	WriteMsg(Msg) error
                                  }

                                  type NodeDialer

                                  type NodeDialer interface {
                                  	Dial(context.Context, *enode.Node) (net.Conn, error)
                                  }

                                    NodeDialer is used to connect to nodes in the network, typically by using an underlying net.Dialer but also using net.Pipe in tests.

                                    type NodeInfo

                                    type NodeInfo struct {
                                    	ID    string `json:"id"`    // Unique node identifier (also the encryption key)
                                    	Name  string `json:"name"`  // Name of the node, including client type, version, OS, custom data
                                    	Enode string `json:"enode"` // Enode URL for adding this peer from remote peers
                                    	ENR   string `json:"enr"`   // Ethereum Node Record
                                    	IP    string `json:"ip"`    // IP address of the node
                                    	Ports struct {
                                    		Discovery int `json:"discovery"` // UDP listening port for discovery protocol
                                    		Listener  int `json:"listener"`  // TCP listening port for RLPx
                                    	} `json:"ports"`
                                    	ListenAddr string                 `json:"listenAddr"`
                                    	Protocols  map[string]interface{} `json:"protocols"`
                                    }

                                      NodeInfo represents a short summary of the information known about the host.

                                      type Peer

                                      type Peer struct {
                                      	// contains filtered or unexported fields
                                      }

                                        Peer represents a connected remote node.

                                        func NewPeer

                                        func NewPeer(id enode.ID, name string, caps []Cap) *Peer

                                          NewPeer returns a peer for testing purposes.

                                          func (*Peer) Caps

                                          func (p *Peer) Caps() []Cap

                                            Caps returns the capabilities (supported subprotocols) of the remote peer.

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

                                              func (p *Peer) ID() enode.ID

                                                ID returns the node's public key.

                                                func (*Peer) Inbound

                                                func (p *Peer) Inbound() bool

                                                  Inbound returns true if the peer is an inbound connection

                                                  func (*Peer) Info

                                                  func (p *Peer) Info() *PeerInfo

                                                    Info gathers and returns a collection of metadata known about a peer.

                                                    func (*Peer) LocalAddr

                                                    func (p *Peer) LocalAddr() net.Addr

                                                      LocalAddr returns the local address of the network connection.

                                                      func (*Peer) Log

                                                      func (p *Peer) Log() log.Logger

                                                      func (*Peer) Name

                                                      func (p *Peer) Name() string

                                                        Name returns the node name that the remote node advertised.

                                                        func (*Peer) Node

                                                        func (p *Peer) Node() *enode.Node

                                                          Node returns the peer's node descriptor.

                                                          func (*Peer) RemoteAddr

                                                          func (p *Peer) RemoteAddr() net.Addr

                                                            RemoteAddr returns the remote address of the network connection.

                                                            func (*Peer) String

                                                            func (p *Peer) String() string

                                                              String implements fmt.Stringer.

                                                              type PeerEvent

                                                              type PeerEvent struct {
                                                              	Type          PeerEventType `json:"type"`
                                                              	Peer          enode.ID      `json:"peer"`
                                                              	Error         string        `json:"error,omitempty"`
                                                              	Protocol      string        `json:"protocol,omitempty"`
                                                              	MsgCode       *uint64       `json:"msg_code,omitempty"`
                                                              	MsgSize       *uint32       `json:"msg_size,omitempty"`
                                                              	LocalAddress  string        `json:"local,omitempty"`
                                                              	RemoteAddress string        `json:"remote,omitempty"`
                                                              }

                                                                PeerEvent is an event emitted when peers are either added or dropped from a p2p.Server or when a message is sent or received on a peer connection

                                                                type PeerEventType

                                                                type PeerEventType string

                                                                  PeerEventType is the type of peer events emitted by a p2p.Server

                                                                  const (
                                                                  	// PeerEventTypeAdd is the type of event emitted when a peer is added
                                                                  	// to a p2p.Server
                                                                  	PeerEventTypeAdd PeerEventType = "add"
                                                                  
                                                                  	// PeerEventTypeDrop is the type of event emitted when a peer is
                                                                  	// dropped from a p2p.Server
                                                                  	PeerEventTypeDrop PeerEventType = "drop"
                                                                  
                                                                  	// PeerEventTypeMsgSend is the type of event emitted when a
                                                                  	// message is successfully sent to a peer
                                                                  	PeerEventTypeMsgSend PeerEventType = "msgsend"
                                                                  
                                                                  	// PeerEventTypeMsgRecv is the type of event emitted when a
                                                                  	// message is received from a peer
                                                                  	PeerEventTypeMsgRecv PeerEventType = "msgrecv"
                                                                  )

                                                                  type PeerInfo

                                                                  type PeerInfo struct {
                                                                  	ENR     string   `json:"enr,omitempty"` // Ethereum Node Record
                                                                  	Enode   string   `json:"enode"`         // Node URL
                                                                  	ID      string   `json:"id"`            // Unique node identifier
                                                                  	Name    string   `json:"name"`          // Name of the node, including client type, version, OS, custom data
                                                                  	Caps    []string `json:"caps"`          // Protocols advertised by this peer
                                                                  	Network struct {
                                                                  		LocalAddress  string `json:"localAddress"`  // Local endpoint of the TCP data connection
                                                                  		RemoteAddress string `json:"remoteAddress"` // Remote endpoint of the TCP data connection
                                                                  		Inbound       bool   `json:"inbound"`
                                                                  		Trusted       bool   `json:"trusted"`
                                                                  		Static        bool   `json:"static"`
                                                                  	} `json:"network"`
                                                                  	Protocols map[string]interface{} `json:"protocols"` // Sub-protocol specific metadata fields
                                                                  }

                                                                    PeerInfo represents a short summary of the information known about a connected peer. Sub-protocol independent fields are contained and initialized here, with protocol specifics delegated to all connected sub-protocols.

                                                                    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 goroutine 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
                                                                    
                                                                    	// NodeInfo is an optional helper method to retrieve protocol specific metadata
                                                                    	// about the host node.
                                                                    	NodeInfo func() interface{}
                                                                    
                                                                    	// PeerInfo is an optional helper method to retrieve protocol specific metadata
                                                                    	// about a certain peer in the network. If an info retrieval function is set,
                                                                    	// but returns nil, it is assumed that the protocol handshake is still running.
                                                                    	PeerInfo func(id enode.ID) interface{}
                                                                    
                                                                    	// DialCandidates, if non-nil, is a way to tell Server about protocol-specific nodes
                                                                    	// that should be dialed. The server continuously reads nodes from the iterator and
                                                                    	// attempts to create connections to them.
                                                                    	DialCandidates enode.Iterator
                                                                    
                                                                    	// Attributes contains protocol specific information for the node record.
                                                                    	Attributes []enr.Entry
                                                                    }

                                                                      Protocol represents a P2P subprotocol implementation.

                                                                      type Server

                                                                      type Server struct {
                                                                      	// Config fields may not be modified while the server is running.
                                                                      	Config
                                                                      
                                                                      	DiscV5 *discv5.Network
                                                                      	// contains filtered or unexported fields
                                                                      }

                                                                        Server manages all peer connections.

                                                                        func (*Server) AddPeer

                                                                        func (srv *Server) AddPeer(node *enode.Node)

                                                                          AddPeer adds the given node to the static node set. When there is room in the peer set, the server will connect to the node. If the connection fails for any reason, the server will attempt to reconnect the peer.

                                                                          func (*Server) AddTrustedPeer

                                                                          func (srv *Server) AddTrustedPeer(node *enode.Node)

                                                                            AddTrustedPeer adds the given node to a reserved whitelist which allows the node to always connect, even if the slot are full.

                                                                            func (*Server) LocalNode

                                                                            func (srv *Server) LocalNode() *enode.LocalNode

                                                                              LocalNode returns the local node record.

                                                                              func (*Server) NodeInfo

                                                                              func (srv *Server) NodeInfo() *NodeInfo

                                                                                NodeInfo gathers and returns a collection of metadata known about the host.

                                                                                func (*Server) PeerCount

                                                                                func (srv *Server) PeerCount() int

                                                                                  PeerCount returns the number of connected peers.

                                                                                  func (*Server) Peers

                                                                                  func (srv *Server) Peers() []*Peer

                                                                                    Peers returns all connected peers.

                                                                                    func (*Server) PeersInfo

                                                                                    func (srv *Server) PeersInfo() []*PeerInfo

                                                                                      PeersInfo returns an array of metadata objects describing connected peers.

                                                                                      func (*Server) RemovePeer

                                                                                      func (srv *Server) RemovePeer(node *enode.Node)

                                                                                        RemovePeer removes a node from the static node set. It also disconnects from the given node if it is currently connected as a peer.

                                                                                        This method blocks until all protocols have exited and the peer is removed. Do not use RemovePeer in protocol implementations, call Disconnect on the Peer instead.

                                                                                        func (*Server) RemoveTrustedPeer

                                                                                        func (srv *Server) RemoveTrustedPeer(node *enode.Node)

                                                                                          RemoveTrustedPeer removes the given node from the trusted peer set.

                                                                                          func (*Server) Self

                                                                                          func (srv *Server) Self() *enode.Node

                                                                                            Self returns the local node's endpoint information.

                                                                                            func (*Server) SetupConn

                                                                                            func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error

                                                                                              SetupConn runs the handshakes and attempts to add the connection as a peer. It returns when the connection has been added as a peer or the handshakes have failed.

                                                                                              func (*Server) Start

                                                                                              func (srv *Server) Start() (err error)

                                                                                                Start starts running the server. Servers can not be re-used after stopping.

                                                                                                func (*Server) Stop

                                                                                                func (srv *Server) Stop()

                                                                                                  Stop terminates the server and all active peer connections. It blocks until all active connections have been closed.

                                                                                                  func (*Server) SubscribeEvents

                                                                                                  func (srv *Server) SubscribeEvents(ch chan *PeerEvent) event.Subscription

                                                                                                    SubscribePeers subscribes the given channel to peer events

                                                                                                    Directories

                                                                                                    Path Synopsis
                                                                                                    Package discover implements the Node Discovery Protocol.
                                                                                                    Package discover implements the Node Discovery Protocol.
                                                                                                    Package discv5 is a prototype implementation of Discvery v5.
                                                                                                    Package discv5 is a prototype implementation of Discvery v5.
                                                                                                    Package dnsdisc implements node discovery via DNS (EIP-1459).
                                                                                                    Package dnsdisc implements node discovery via DNS (EIP-1459).
                                                                                                    Package enr implements Ethereum Node Records as defined in EIP-778.
                                                                                                    Package enr implements Ethereum Node Records as defined in EIP-778.
                                                                                                    Package nat provides access to common network port mapping protocols.
                                                                                                    Package nat provides access to common network port mapping protocols.
                                                                                                    Package netutil contains extensions to the net package.
                                                                                                    Package netutil contains extensions to the net package.
                                                                                                    Package simulations simulates p2p networks.
                                                                                                    Package simulations simulates p2p networks.