tendermint: github.com/tendermint/tendermint/p2p/conn Index | Files

package conn

import "github.com/tendermint/tendermint/p2p/conn"

Index

Package Files

codec.go conn_go110.go connection.go secret_connection.go

Variables

var (
    ErrSmallOrderRemotePubKey = errors.New("detected low order point from remote peer")
    ErrSharedSecretIsZero     = errors.New("shared secret is all zeroes")
)

func NetPipe Uses

func NetPipe() (net.Conn, net.Conn)

func RegisterPacket Uses

func RegisterPacket(cdc *amino.Codec)

type Channel Uses

type Channel struct {
    Logger log.Logger
    // contains filtered or unexported fields
}

TODO: lowercase. NOTE: not goroutine-safe.

func (*Channel) SetLogger Uses

func (ch *Channel) SetLogger(l log.Logger)

type ChannelDescriptor Uses

type ChannelDescriptor struct {
    ID                  byte
    Priority            int
    SendQueueCapacity   int
    RecvBufferCapacity  int
    RecvMessageCapacity int
}

func (ChannelDescriptor) FillDefaults Uses

func (chDesc ChannelDescriptor) FillDefaults() (filled ChannelDescriptor)

type ChannelStatus Uses

type ChannelStatus struct {
    ID                byte
    SendQueueCapacity int
    SendQueueSize     int
    Priority          int
    RecentlySent      int64
}

type ConnectionStatus Uses

type ConnectionStatus struct {
    Duration    time.Duration
    SendMonitor flow.Status
    RecvMonitor flow.Status
    Channels    []ChannelStatus
}

type MConnConfig Uses

type MConnConfig struct {
    SendRate int64 `mapstructure:"send_rate"`
    RecvRate int64 `mapstructure:"recv_rate"`

    // Maximum payload size
    MaxPacketMsgPayloadSize int `mapstructure:"max_packet_msg_payload_size"`

    // Interval to flush writes (throttled)
    FlushThrottle time.Duration `mapstructure:"flush_throttle"`

    // Interval to send pings
    PingInterval time.Duration `mapstructure:"ping_interval"`

    // Maximum wait time for pongs
    PongTimeout time.Duration `mapstructure:"pong_timeout"`
}

MConnConfig is a MConnection configuration.

func DefaultMConnConfig Uses

func DefaultMConnConfig() MConnConfig

DefaultMConnConfig returns the default config.

type MConnection Uses

type MConnection struct {
    cmn.BaseService
    // contains filtered or unexported fields
}

Each peer has one `MConnection` (multiplex connection) instance.

__multiplex__ *noun* a system or signal involving simultaneous transmission of several messages along a single channel of communication.

Each `MConnection` handles message transmission on multiple abstract communication `Channel`s. Each channel has a globally unique byte id. The byte id and the relative priorities of each `Channel` are configured upon initialization of the connection.

There are two methods for sending messages:

func (m MConnection) Send(chID byte, msgBytes []byte) bool {}
func (m MConnection) TrySend(chID byte, msgBytes []byte}) bool {}

`Send(chID, msgBytes)` is a blocking call that waits until `msg` is successfully queued for the channel with the given id byte `chID`, or until the request times out. The message `msg` is serialized using Go-Amino.

`TrySend(chID, msgBytes)` is a nonblocking call that returns false if the channel's queue is full.

Inbound message bytes are handled with an onReceive callback function.

func NewMConnection Uses

func NewMConnection(conn net.Conn, chDescs []*ChannelDescriptor, onReceive receiveCbFunc, onError errorCbFunc) *MConnection

NewMConnection wraps net.Conn and creates multiplex connection

func NewMConnectionWithConfig Uses

func NewMConnectionWithConfig(conn net.Conn, chDescs []*ChannelDescriptor, onReceive receiveCbFunc, onError errorCbFunc, config MConnConfig) *MConnection

NewMConnectionWithConfig wraps net.Conn and creates multiplex connection with a config

func (*MConnection) CanSend Uses

func (c *MConnection) CanSend(chID byte) bool

CanSend returns true if you can send more data onto the chID, false otherwise. Use only as a heuristic.

func (*MConnection) FlushStop Uses

func (c *MConnection) FlushStop()

FlushStop replicates the logic of OnStop. It additionally ensures that all successful .Send() calls will get flushed before closing the connection.

func (*MConnection) OnStart Uses

func (c *MConnection) OnStart() error

OnStart implements BaseService

func (*MConnection) OnStop Uses

func (c *MConnection) OnStop()

OnStop implements BaseService

func (*MConnection) Send Uses

func (c *MConnection) Send(chID byte, msgBytes []byte) bool

Queues a message to be sent to channel.

func (*MConnection) SetLogger Uses

func (c *MConnection) SetLogger(l log.Logger)

func (*MConnection) Status Uses

func (c *MConnection) Status() ConnectionStatus

func (*MConnection) String Uses

func (c *MConnection) String() string

func (*MConnection) TrySend Uses

func (c *MConnection) TrySend(chID byte, msgBytes []byte) bool

Queues a message to be sent to channel. Nonblocking, returns true if successful.

type Packet Uses

type Packet interface {
    AssertIsPacket()
}

type PacketMsg Uses

type PacketMsg struct {
    ChannelID byte
    EOF       byte // 1 means message ends here.
    Bytes     []byte
}

func (PacketMsg) AssertIsPacket Uses

func (_ PacketMsg) AssertIsPacket()

func (PacketMsg) String Uses

func (mp PacketMsg) String() string

type PacketPing Uses

type PacketPing struct {
}

func (PacketPing) AssertIsPacket Uses

func (_ PacketPing) AssertIsPacket()

type PacketPong Uses

type PacketPong struct {
}

func (PacketPong) AssertIsPacket Uses

func (_ PacketPong) AssertIsPacket()

type SecretConnection Uses

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

SecretConnection implements net.Conn. It is an implementation of the STS protocol. See https://github.com/tendermint/tendermint/blob/0.1/docs/sts-final.pdf for details on the protocol.

Consumers of the SecretConnection are responsible for authenticating the remote peer's pubkey against known information, like a nodeID. Otherwise they are vulnerable to MITM. (TODO(ismail): see also https://github.com/tendermint/tendermint/issues/3010)

func MakeSecretConnection Uses

func MakeSecretConnection(conn io.ReadWriteCloser, locPrivKey crypto.PrivKey) (*SecretConnection, error)

MakeSecretConnection performs handshake and returns a new authenticated SecretConnection. Returns nil if there is an error in handshake. Caller should call conn.Close() See docs/sts-final.pdf for more information.

func (*SecretConnection) Close Uses

func (sc *SecretConnection) Close() error

Implements net.Conn nolint

func (*SecretConnection) LocalAddr Uses

func (sc *SecretConnection) LocalAddr() net.Addr

func (*SecretConnection) Read Uses

func (sc *SecretConnection) Read(data []byte) (n int, err error)

CONTRACT: data smaller than dataMaxSize is read atomically.

func (*SecretConnection) RemoteAddr Uses

func (sc *SecretConnection) RemoteAddr() net.Addr

func (*SecretConnection) RemotePubKey Uses

func (sc *SecretConnection) RemotePubKey() crypto.PubKey

RemotePubKey returns authenticated remote pubkey

func (*SecretConnection) SetDeadline Uses

func (sc *SecretConnection) SetDeadline(t time.Time) error

func (*SecretConnection) SetReadDeadline Uses

func (sc *SecretConnection) SetReadDeadline(t time.Time) error

func (*SecretConnection) SetWriteDeadline Uses

func (sc *SecretConnection) SetWriteDeadline(t time.Time) error

func (*SecretConnection) Write Uses

func (sc *SecretConnection) Write(data []byte) (n int, err error)

Writes encrypted frames of `totalFrameSize + aeadSizeOverhead`. CONTRACT: data smaller than dataMaxSize is written atomically.

Package conn imports 29 packages (graph) and is imported by 18 packages. Updated 2019-09-12. Refresh now. Tools for package owners.