This section is empty.


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


func NetPipe

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

func RegisterPacket

func RegisterPacket(cdc *amino.Codec)


type Channel

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

    TODO: lowercase. NOTE: not goroutine-safe.

    func (*Channel) SetLogger

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

    type ChannelDescriptor

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

    func (ChannelDescriptor) FillDefaults

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

    type ChannelStatus

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

    type ConnectionStatus

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

    type MConnConfig

    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

      func DefaultMConnConfig() MConnConfig

        DefaultMConnConfig returns the default config.

        type MConnection

        type MConnection struct {
        	// 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

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

            NewMConnection wraps net.Conn and creates multiplex connection

            func NewMConnectionWithConfig

            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

              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

                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

                  func (c *MConnection) OnStart() error

                    OnStart implements BaseService

                    func (*MConnection) OnStop

                    func (c *MConnection) OnStop()

                      OnStop implements BaseService

                      func (*MConnection) Send

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

                        Queues a message to be sent to channel.

                        func (*MConnection) SetLogger

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

                        func (*MConnection) Status

                        func (c *MConnection) Status() ConnectionStatus

                        func (*MConnection) String

                        func (c *MConnection) String() string

                        func (*MConnection) TrySend

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

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

                          type Packet

                          type Packet interface {

                          type PacketMsg

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

                          func (PacketMsg) AssertIsPacket

                          func (_ PacketMsg) AssertIsPacket()

                          func (PacketMsg) String

                          func (mp PacketMsg) String() string

                          type PacketPing

                          type PacketPing struct {

                          func (PacketPing) AssertIsPacket

                          func (_ PacketPing) AssertIsPacket()

                          type PacketPong

                          type PacketPong struct {

                          func (PacketPong) AssertIsPacket

                          func (_ PacketPong) AssertIsPacket()

                          type SecretConnection

                          type SecretConnection struct {
                          	// contains filtered or unexported fields

                            SecretConnection implements net.Conn. It is an implementation of the STS protocol. See 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

                            func MakeSecretConnection

                            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

                              func (sc *SecretConnection) Close() error

                                Implements net.Conn nolint

                                func (*SecretConnection) LocalAddr

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

                                func (*SecretConnection) Read

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

                                  CONTRACT: data smaller than dataMaxSize is read atomically.

                                  func (*SecretConnection) RemoteAddr

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

                                  func (*SecretConnection) RemotePubKey

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

                                    RemotePubKey returns authenticated remote pubkey

                                    func (*SecretConnection) SetDeadline

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

                                    func (*SecretConnection) SetReadDeadline

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

                                    func (*SecretConnection) SetWriteDeadline

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

                                    func (*SecretConnection) Write

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

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