package p2p import ( "context" "errors" "fmt" "net" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/internal/p2p/conn" "github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/version" ) //go:generate ../../scripts/mockery_generate.sh Transport|Connection const ( // defaultProtocol is the default protocol used for NodeAddress when // a protocol isn't explicitly given as a URL scheme. defaultProtocol Protocol = MConnProtocol ) // defaultProtocolVersion populates the Block and P2P versions using // the global values, but not the App. var defaultProtocolVersion = types.ProtocolVersion{ P2P: version.P2PProtocol, Block: version.BlockProtocol, App: 0, } // Protocol identifies a transport protocol. type Protocol string // Transport is a connection-oriented mechanism for exchanging data with a peer. type Transport interface { // Protocols returns the protocols supported by the transport. The Router // uses this to pick a transport for an Endpoint. Protocols() []Protocol // Endpoints returns the local endpoints the transport is listening on, if any. // // How to listen is transport-dependent, e.g. MConnTransport uses Listen() while // MemoryTransport starts listening via MemoryNetwork.CreateTransport(). Endpoints() []Endpoint // Accept waits for the next inbound connection on a listening endpoint, blocking // until either a connection is available or the transport is closed. On closure, // io.EOF is returned and further Accept calls are futile. Accept() (Connection, error) // Dial creates an outbound connection to an endpoint. Dial(context.Context, Endpoint) (Connection, error) // Close stops accepting new connections, but does not close active connections. Close() error // Stringer is used to display the transport, e.g. in logs. // // Without this, the logger may use reflection to access and display // internal fields. These can be written to concurrently, which can trigger // the race detector or even cause a panic. fmt.Stringer } // Connection represents an established connection between two endpoints. // // FIXME: This is a temporary interface for backwards-compatibility with the // current MConnection-protocol, which is message-oriented. It should be // migrated to a byte-oriented multi-stream interface instead, which would allow // e.g. adopting QUIC and making message framing, traffic scheduling, and node // handshakes a Router concern shared across all transports. However, this // requires MConnection protocol changes or a shim. For details, see: // https://github.com/tendermint/spec/pull/227 // // FIXME: The interface is currently very broad in order to accommodate // MConnection behavior that the legacy P2P stack relies on. It should be // cleaned up when the legacy stack is removed. type Connection interface { // Handshake executes a node handshake with the remote peer. It must be // called immediately after the connection is established, and returns the // remote peer's node info and public key. The caller is responsible for // validation. // // FIXME: The handshake should really be the Router's responsibility, but // that requires the connection interface to be byte-oriented rather than // message-oriented (see comment above). Handshake(context.Context, types.NodeInfo, crypto.PrivKey) (types.NodeInfo, crypto.PubKey, error) // ReceiveMessage returns the next message received on the connection, // blocking until one is available. Returns io.EOF if closed. ReceiveMessage() (ChannelID, []byte, error) // SendMessage sends a message on the connection. Returns io.EOF if closed. // // FIXME: For compatibility with the legacy P2P stack, it returns an // additional boolean false if the message timed out waiting to be accepted // into the send buffer. This should be removed. SendMessage(ChannelID, []byte) (bool, error) // TrySendMessage is a non-blocking version of SendMessage that returns // immediately if the message buffer is full. It returns true if the message // was accepted. // // FIXME: This method is here for backwards-compatibility with the legacy // P2P stack and should be removed. TrySendMessage(ChannelID, []byte) (bool, error) // LocalEndpoint returns the local endpoint for the connection. LocalEndpoint() Endpoint // RemoteEndpoint returns the remote endpoint for the connection. RemoteEndpoint() Endpoint // Close closes the connection. Close() error // FlushClose flushes all pending sends and then closes the connection. // // FIXME: This only exists for backwards-compatibility with the current // MConnection implementation. There should really be a separate Flush() // method, but there is no easy way to synchronously flush pending data with // the current MConnection code. FlushClose() error // Status returns the current connection status. // FIXME: Only here for compatibility with the current Peer code. Status() conn.ConnectionStatus // Stringer is used to display the connection, e.g. in logs. // // Without this, the logger may use reflection to access and display // internal fields. These can be written to concurrently, which can trigger // the race detector or even cause a panic. fmt.Stringer } // Endpoint represents a transport connection endpoint, either local or remote. // // Endpoints are not necessarily networked (see e.g. MemoryTransport) but all // networked endpoints must use IP as the underlying transport protocol to allow // e.g. IP address filtering. Either IP or Path (or both) must be set. type Endpoint struct { // Protocol specifies the transport protocol. Protocol Protocol // IP is an IP address (v4 or v6) to connect to. If set, this defines the // endpoint as a networked endpoint. IP net.IP // Port is a network port (either TCP or UDP). If 0, a default port may be // used depending on the protocol. Port uint16 // Path is an optional transport-specific path or identifier. Path string } // NewEndpoint constructs an Endpoint from a types.NetAddress structure. func NewEndpoint(na *types.NetAddress) Endpoint { return Endpoint{ Protocol: MConnProtocol, IP: na.IP, Port: na.Port, } } // NodeAddress converts the endpoint into a NodeAddress for the given node ID. func (e Endpoint) NodeAddress(nodeID types.NodeID) NodeAddress { address := NodeAddress{ NodeID: nodeID, Protocol: e.Protocol, Path: e.Path, } if len(e.IP) > 0 { address.Hostname = e.IP.String() address.Port = e.Port } return address } // String formats the endpoint as a URL string. func (e Endpoint) String() string { // If this is a non-networked endpoint with a valid node ID as a path, // assume that path is a node ID (to handle opaque URLs of the form // scheme:id). if e.IP == nil { if nodeID, err := types.NewNodeID(e.Path); err == nil { return e.NodeAddress(nodeID).String() } } return e.NodeAddress("").String() } // Validate validates the endpoint. func (e Endpoint) Validate() error { switch { case e.Protocol == "": return errors.New("endpoint has no protocol") case len(e.IP) > 0 && e.IP.To16() == nil: return fmt.Errorf("invalid IP address %v", e.IP) case e.Port > 0 && len(e.IP) == 0: return fmt.Errorf("endpoint has port %v but no IP", e.Port) case len(e.IP) == 0 && e.Path == "": return errors.New("endpoint has neither path nor IP") default: return nil } }