Documentation ¶
Overview ¶
Package p2p implements the Ethereum p2p network protocols.
Index ¶
- Constants
- Variables
- func Encrypt(metadata Metadata, op P2PCommandOp, ipcID uint64, cmd interface{}) ([]byte, error)
- func ExpectMsg(r MsgReader, code uint64, content interface{}) error
- func GetPrivateKeyFromConfig(configKey string) (*ecdsa.PrivateKey, error)
- func MsgPipe() (*MsgPipeRW, *MsgPipeRW)
- func NewQKCRlp(fd net.Conn) transport
- func Send(w MsgWriter, msgcode uint64, data interface{}) error
- func SendItems(w MsgWriter, msgcode uint64, elems ...interface{}) error
- type Cap
- type Config
- type DiscReason
- type GetMinorBlockHeaderListRequest
- type GetMinorBlockHeaderListResponse
- type GetMinorBlockListRequest
- type GetMinorBlockListResponse
- type GetPeerListRequest
- type GetPeerListResponse
- type GetRootBlockHeaderListRequest
- type GetRootBlockHeaderListResponse
- type GetRootBlockListRequest
- type GetRootBlockListResponse
- type HelloCmd
- type Metadata
- type Msg
- type MsgPipeRW
- type MsgReadWriter
- type MsgReader
- type MsgWriter
- type NewBlockMinor
- type NewTransactionList
- type NodeDialer
- type NodeInfo
- type P2PCommandOp
- type P2PeerInfo
- type Peer
- func (p *Peer) Caps() []Cap
- func (p *Peer) Disconnect(reason DiscReason)
- func (p *Peer) ID() enode.ID
- func (p *Peer) Inbound() bool
- func (p *Peer) Info() *PeerInfo
- func (p *Peer) LocalAddr() net.Addr
- func (p *Peer) Log() log.Logger
- func (p *Peer) Name() string
- func (p *Peer) Node() *enode.Node
- func (p *Peer) RemoteAddr() net.Addr
- func (p *Peer) String() string
- type PeerEvent
- type PeerEventType
- type PeerInfo
- type Protocol
- type QKCMsg
- type Server
- func (srv *Server) AddPeer(node *enode.Node)
- func (srv *Server) AddTrustedPeer(node *enode.Node)
- func (srv *Server) NodeInfo() *NodeInfo
- func (srv *Server) PeerCount() int
- func (srv *Server) Peers() []*Peer
- func (srv *Server) PeersInfo() []*PeerInfo
- func (srv *Server) RemovePeer(node *enode.Node)
- func (srv *Server) RemoveTrustedPeer(node *enode.Node)
- func (srv *Server) Self() *enode.Node
- func (srv *Server) SetupConn(fd net.Conn, flags connFlag, dialDest *enode.Node) error
- func (srv *Server) Start() (err error)
- func (srv *Server) Stop()
- func (srv *Server) SubscribeEvents(ch chan *PeerEvent) event.Subscription
- type TCPDialer
- type Tip
Examples ¶
Constants ¶
const ( // OPLength Op length OPLength = 1 // RPCIDLength rpc length RPCIDLength = 8 // PreP2PLength preP2PLength PreP2PLength = OPLength + RPCIDLength )
Variables ¶
var ( //OPNonRPCMap no return rpc Op OPNonRPCMap = map[P2PCommandOp]func(P2PCommandOp, []byte){ Hello: handleError, NewTipMsg: handleNewTip, NewTransactionListMsg: handleNewTransactionList, } //OpRPCMap have return rpc Op OpRPCMap = map[P2PCommandOp]msgHandleSt{ GetPeerListRequestMsg: { // contains filtered or unexported fields }, GetRootBlockHeaderListRequestMsg: { // contains filtered or unexported fields }, GetRootBlockListRequestMsg: { // contains filtered or unexported fields }, } //PeerShardOpRPCMap used in virtual connection between local shard and remote shard PeerShardOpRPCMap = map[P2PCommandOp]msgHandleSt{ GetMinorBlockListResponseMsg: { // contains filtered or unexported fields }, GetMinorBlockHeaderListRequestMsg: { // contains filtered or unexported fields }, } )
var ErrPipeClosed = errors.New("p2p: read or write on closed message pipe")
ErrPipeClosed is returned from pipe operations after the pipe has been closed.
var (
ErrShuttingDown = errors.New("shutting down")
)
var OPSerializerMap = map[P2PCommandOp]interface{}{ Hello: HelloCmd{}, NewTipMsg: Tip{}, NewTransactionListMsg: NewTransactionList{}, GetPeerListRequestMsg: GetPeerListRequest{}, GetPeerListResponseMsg: GetPeerListResponse{}, GetRootBlockHeaderListRequestMsg: GetRootBlockHeaderListRequest{}, GetRootBlockHeaderListResponseMsg: GetRootBlockHeaderListResponse{}, GetRootBlockListRequestMsg: GetRootBlockListRequest{}, GetRootBlockListResponseMsg: GetRootBlockListResponse{}, GetMinorBlockListRequestMsg: GetMinorBlockListRequest{}, GetMinorBlockListResponseMsg: GetMinorBlockListResponse{}, GetMinorBlockHeaderListRequestMsg: GetMinorBlockHeaderListRequest{}, GetMinorBlockHeaderListResponseMsg: GetMinorBlockHeaderListResponse{}, NewBlockMinorMsg: NewBlockMinor{}, }
OPSerializerMap Op and its struct
Functions ¶
func Encrypt ¶
func Encrypt(metadata Metadata, op P2PCommandOp, ipcID uint64, cmd interface{}) ([]byte, error)
Encrypt encrypt Data to byte array
func ExpectMsg ¶
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 GetPrivateKeyFromConfig ¶
func GetPrivateKeyFromConfig(configKey string) (*ecdsa.PrivateKey, error)
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() { Send(rw1, 8, [][]byte{{0, 0}}) Send(rw1, 5, [][]byte{{1, 1}}) rw1.Close() }() for { msg, err := rw2.ReadMsg() if err != nil { break } var data [][]byte msg.Decode(&data) fmt.Printf("msg: %d, %x\n", msg.Code, data[0]) }
Output: msg: 8, 0000 msg: 5, 0101
Types ¶
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"` }
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 GetMinorBlockHeaderListRequest ¶
type GetMinorBlockHeaderListRequest struct { BlockHash common.Hash Branch account.Branch Limit uint32 Direction uint8 }
GetMinorBlockHeaderListRequest get minor block header list request
type GetMinorBlockHeaderListResponse ¶
type GetMinorBlockHeaderListResponse struct { RootTip *types.RootBlockHeader ShardTip *types.MinorBlockHeader BlockHeaderList []*types.MinorBlockHeader `bytesizeofslicelen:"4"` }
GetMinorBlockHeaderListResponse get minor block header list response
type GetMinorBlockListRequest ¶
GetMinorBlockListRequest get minor block list request
type GetMinorBlockListResponse ¶
type GetMinorBlockListResponse struct {
MinorBlockList []*types.MinorBlock `bytesizeofslicelen:"4"`
}
GetMinorBlockListResponse get minor block list response
type GetPeerListRequest ¶
type GetPeerListRequest struct {
MaxPeers uint32
}
GetPeerListRequest get peer list request
type GetPeerListResponse ¶
type GetPeerListResponse struct {
PeerInfoList []P2PeerInfo `bytesizeofslicelen:"4"`
}
GetPeerListResponse get peer list response
type GetRootBlockHeaderListRequest ¶
GetRootBlockHeaderListRequest get root block header list request
type GetRootBlockHeaderListResponse ¶
type GetRootBlockHeaderListResponse struct { RootTip *types.RootBlockHeader BlockHeaderList []*types.RootBlockHeader `bytesizeofslicelen:"4"` }
GetRootBlockHeaderListResponse get root block header list response
type GetRootBlockListRequest ¶
GetRootBlockListRequest get root block list request
type GetRootBlockListResponse ¶
GetRootBlockListResponse get root block list response
type HelloCmd ¶
type HelloCmd struct { Version uint32 NetWorkID uint32 PeerID common.Hash PeerIP *serialize.Uint128 PeerPort uint16 ChainMaskList []uint32 `bytesizeofslicelen:"4"` RootBlockHeader *types.RootBlockHeader }
HelloCmd hello cmd struct
type Msg ¶
type Msg struct { Code uint64 Size uint32 // size of the paylod Payload io.Reader ReceivedAt time.Time }
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 MakeMsg ¶
func MakeMsg(op P2PCommandOp, rpcID uint64, metadata Metadata, msg interface{}) (Msg, error)
func (Msg) Decode ¶
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.
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. Close also interrupts any reads from a message payload.
type MsgReadWriter ¶
MsgReadWriter provides reading and writing of encoded messages. Implementations should ensure that ReadMsg and WriteMsg can be called simultaneously from multiple goroutines.
type NewBlockMinor ¶
type NewBlockMinor struct {
Block *types.MinorBlock
}
NewBlockMinor new block minor
type NewTransactionList ¶
type NewTransactionList struct {
TransactionList []*types.Transaction `bytesizeofslicelen:"4"`
}
NewTransactionList new transaction list
type NodeDialer ¶
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 P2PCommandOp ¶
type P2PCommandOp byte
const ( Hello P2PCommandOp = iota NewTipMsg NewTransactionListMsg GetPeerListRequestMsg GetPeerListResponseMsg GetRootBlockHeaderListRequestMsg GetRootBlockHeaderListResponseMsg GetRootBlockListRequestMsg GetRootBlockListResponseMsg GetMinorBlockListRequestMsg GetMinorBlockListResponseMsg GetMinorBlockHeaderListRequestMsg GetMinorBlockHeaderListResponseMsg NewBlockMinorMsg MaxOPNum )
p2p command
func (P2PCommandOp) String ¶
func (p P2PCommandOp) String() string
type P2PeerInfo ¶
P2PeerInfo peerInfo use uint123
type Peer ¶
type Peer struct {
// contains filtered or unexported fields
}
Peer represents a connected remote node.
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) RemoteAddr ¶
RemoteAddr returns the remote address of the network connection.
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"` }
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 { 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{} // Attributes contains protocol specific information for the node record. Attributes []enr.Entry }
Protocol represents a P2P subprotocol implementation.
type QKCMsg ¶
type QKCMsg struct { MetaData Metadata Op P2PCommandOp RpcID uint64 Data []byte }
QKCMsg qkc msg struct
func DecodeQKCMsg ¶
DecodeQKCMsg decode byte to qkcMsg
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 ¶
AddPeer connects to the given node and maintains the connection until the server is shut down. If the connection fails for any reason, the server will attempt to reconnect the peer.
func (*Server) AddTrustedPeer ¶
AddTrustedPeer adds the given node to a reserved whitelist which allows the node to always connect, even if the slot are full.
func (*Server) NodeInfo ¶
NodeInfo gathers and returns a collection of metadata known about the host.
func (*Server) PeersInfo ¶
PeersInfo returns an array of metadata objects describing connected peers.
func (*Server) RemovePeer ¶
RemovePeer disconnects from the given node
func (*Server) RemoveTrustedPeer ¶
RemoveTrustedPeer removes the given node from the trusted peer set.
func (*Server) SetupConn ¶
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) 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
type TCPDialer ¶
TCPDialer implements the NodeDialer interface by using a net.Dialer to create TCP connections to nodes in the network
type Tip ¶
type Tip struct { RootBlockHeader *types.RootBlockHeader MinorBlockHeaderList []*types.MinorBlockHeader `bytesizeofslicelen:"4"` }
Tip new minor block header list