conn

package
Version: v0.0.0-...-ff5f600 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 30, 2016 License: BSD-3-Clause Imports: 26 Imported by: 0

Documentation

Index

Constants

View Source
const (
	DefaultBytesBufferedPerFlow = 1 << 20
)

Variables

View Source
var (
	ErrMissingSetupOption       = verror.Register("v.io/x/ref/runtime/internal/flow/conn.MissingSetupOption", verror.NoRetry, "{1:}{2:} missing required setup option{:3}.")
	ErrUnexpectedMsg            = verror.Register("v.io/x/ref/runtime/internal/flow/conn.UnexpectedMsg", verror.NoRetry, "{1:}{2:} unexpected message type{:3}.")
	ErrConnectionClosed         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ConnectionClosed", verror.NoRetry, "{1:}{2:} connection closed.")
	ErrRemoteError              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.RemoteError", verror.NoRetry, "{1:}{2:} remote end received err{:3}.")
	ErrSend                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Send", verror.NoRetry, "{1:}{2:} failure sending {3} message to {4}{:5}.")
	ErrRecv                     = verror.Register("v.io/x/ref/runtime/internal/flow/conn.Recv", verror.NoRetry, "{1:}{2:} error reading from {3}{:4}")
	ErrCounterOverflow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CounterOverflow", verror.NoRetry, "{1:}{2:} A remote process has sent more data than allowed.")
	ErrBlessingsFlowClosed      = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsFlowClosed", verror.NoRetry, "{1:}{2:} The blessings flow was closed with error{:3}.")
	ErrInvalidChannelBinding    = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidChannelBinding", verror.NoRetry, "{1:}{2:} The channel binding was invalid.")
	ErrNoPublicKey              = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPublicKey", verror.NoRetry, "{1:}{2:} No public key was received by the remote end.")
	ErrDialingNonServer         = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialingNonServer", verror.NoRetry, "{1:}{2:} You are attempting to dial on a connection with no remote server.")
	ErrAcceptorBlessingsMissing = verror.Register("v.io/x/ref/runtime/internal/flow/conn.AcceptorBlessingsMissing", verror.NoRetry, "{1:}{2:} The acceptor did not send blessings.")
	ErrDialerBlessingsMissing   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.DialerBlessingsMissing", verror.NoRetry, "{1:}{2:} The dialer did not send blessings.")
	ErrBlessingsNotBound        = verror.Register("v.io/x/ref/runtime/internal/flow/conn.BlessingsNotBound", verror.NoRetry, "{1:}{2:} blessings not bound to connection remote public key")
	ErrInvalidPeerFlow          = verror.Register("v.io/x/ref/runtime/internal/flow/conn.InvalidPeerFlow", verror.NoRetry, "{1:}{2:} peer has chosen flow id from local domain.")
	ErrChannelTimeout           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.ChannelTimeout", verror.NoRetry, "{1:}{2:} the channel has become unresponsive.")
	ErrCannotDecryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptBlessings", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted blessings sent by peer{:3}")
	ErrCannotDecryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotDecryptDischarges", verror.NoRetry, "{1:}{2:} cannot decrypt the encrypted discharges sent by peer{:3}")
	ErrCannotEncryptBlessings   = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptBlessings", verror.NoRetry, "{1:}{2:} cannot encyrpt blessings for peer {3}{:4}")
	ErrCannotEncryptDischarges  = verror.Register("v.io/x/ref/runtime/internal/flow/conn.CannotEncryptDischarges", verror.NoRetry, "{1:}{2:} cannot encrypt discharges for peers {3}{:4}")
	ErrNoCrypter                = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoCrypter", verror.NoRetry, "{1:}{2:} no blessings-based crypter available")
	ErrNoPrivateKey             = verror.Register("v.io/x/ref/runtime/internal/flow/conn.NoPrivateKey", verror.NoRetry, "{1:}{2:} no blessings private key available for decryption")
	ErrIdleConnKilled           = verror.Register("v.io/x/ref/runtime/internal/flow/conn.IdleConnKilled", verror.NoRetry, "{1:}{2:} Connection killed because idle expiry was reached.")
)

Functions

func NewErrAcceptorBlessingsMissing

func NewErrAcceptorBlessingsMissing(ctx *context.T) error

NewErrAcceptorBlessingsMissing returns an error with the ErrAcceptorBlessingsMissing ID.

func NewErrBlessingsFlowClosed

func NewErrBlessingsFlowClosed(ctx *context.T, err error) error

NewErrBlessingsFlowClosed returns an error with the ErrBlessingsFlowClosed ID.

func NewErrBlessingsNotBound

func NewErrBlessingsNotBound(ctx *context.T) error

NewErrBlessingsNotBound returns an error with the ErrBlessingsNotBound ID.

func NewErrCannotDecryptBlessings

func NewErrCannotDecryptBlessings(ctx *context.T, err error) error

NewErrCannotDecryptBlessings returns an error with the ErrCannotDecryptBlessings ID.

func NewErrCannotDecryptDischarges

func NewErrCannotDecryptDischarges(ctx *context.T, err error) error

NewErrCannotDecryptDischarges returns an error with the ErrCannotDecryptDischarges ID.

func NewErrCannotEncryptBlessings

func NewErrCannotEncryptBlessings(ctx *context.T, peers []security.BlessingPattern, err error) error

NewErrCannotEncryptBlessings returns an error with the ErrCannotEncryptBlessings ID.

func NewErrCannotEncryptDischarges

func NewErrCannotEncryptDischarges(ctx *context.T, peers []security.BlessingPattern, err error) error

NewErrCannotEncryptDischarges returns an error with the ErrCannotEncryptDischarges ID.

func NewErrChannelTimeout

func NewErrChannelTimeout(ctx *context.T) error

NewErrChannelTimeout returns an error with the ErrChannelTimeout ID.

func NewErrConnectionClosed

func NewErrConnectionClosed(ctx *context.T) error

NewErrConnectionClosed returns an error with the ErrConnectionClosed ID.

func NewErrCounterOverflow

func NewErrCounterOverflow(ctx *context.T) error

NewErrCounterOverflow returns an error with the ErrCounterOverflow ID.

func NewErrDialerBlessingsMissing

func NewErrDialerBlessingsMissing(ctx *context.T) error

NewErrDialerBlessingsMissing returns an error with the ErrDialerBlessingsMissing ID.

func NewErrDialingNonServer

func NewErrDialingNonServer(ctx *context.T) error

NewErrDialingNonServer returns an error with the ErrDialingNonServer ID.

func NewErrIdleConnKilled

func NewErrIdleConnKilled(ctx *context.T) error

NewErrIdleConnKilled returns an error with the ErrIdleConnKilled ID.

func NewErrInvalidChannelBinding

func NewErrInvalidChannelBinding(ctx *context.T) error

NewErrInvalidChannelBinding returns an error with the ErrInvalidChannelBinding ID.

func NewErrInvalidPeerFlow

func NewErrInvalidPeerFlow(ctx *context.T) error

NewErrInvalidPeerFlow returns an error with the ErrInvalidPeerFlow ID.

func NewErrMissingSetupOption

func NewErrMissingSetupOption(ctx *context.T, option string) error

NewErrMissingSetupOption returns an error with the ErrMissingSetupOption ID.

func NewErrNoCrypter

func NewErrNoCrypter(ctx *context.T) error

NewErrNoCrypter returns an error with the ErrNoCrypter ID.

func NewErrNoPrivateKey

func NewErrNoPrivateKey(ctx *context.T) error

NewErrNoPrivateKey returns an error with the ErrNoPrivateKey ID.

func NewErrNoPublicKey

func NewErrNoPublicKey(ctx *context.T) error

NewErrNoPublicKey returns an error with the ErrNoPublicKey ID.

func NewErrRecv

func NewErrRecv(ctx *context.T, src string, err error) error

NewErrRecv returns an error with the ErrRecv ID.

func NewErrRemoteError

func NewErrRemoteError(ctx *context.T, msg string) error

NewErrRemoteError returns an error with the ErrRemoteError ID.

func NewErrSend

func NewErrSend(ctx *context.T, typ string, dest string, err error) error

NewErrSend returns an error with the ErrSend ID.

func NewErrUnexpectedMsg

func NewErrUnexpectedMsg(ctx *context.T, typ string) error

NewErrUnexpectedMsg returns an error with the ErrUnexpectedMsg ID.

func VDLReadBlessingsFlowMessage

func VDLReadBlessingsFlowMessage(dec vdl.Decoder, x *BlessingsFlowMessage) error

Types

type Blessings

type Blessings struct {
	Blessings security.Blessings
	BKey      uint64
}

Blessings is used to transport blessings between the two ends of a Conn. Since blessings can be large, we try not to send them more than once by associating them with an integer key (BKey). Thereafter we refer to them by their key.

func (*Blessings) FillVDLTarget

func (m *Blessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (*Blessings) MakeVDLTarget

func (m *Blessings) MakeVDLTarget() vdl.Target

func (Blessings) VDLIsZero

func (x Blessings) VDLIsZero() bool

func (*Blessings) VDLRead

func (x *Blessings) VDLRead(dec vdl.Decoder) error

func (Blessings) VDLWrite

func (x Blessings) VDLWrite(enc vdl.Encoder) error

type BlessingsFlowMessage

type BlessingsFlowMessage interface {
	// Index returns the field index.
	Index() int
	// Interface returns the field value as an interface.
	Interface() interface{}
	// Name returns the field name.
	Name() string

	FillVDLTarget(vdl.Target, *vdl.Type) error
	VDLIsZero() bool
	VDLWrite(vdl.Encoder) error
	// contains filtered or unexported methods
}

BlessingsFlowMessage represents any single field of the BlessingsFlowMessage union type.

BlessingsFlowMessage is used to send either a Blessings, Discharges, EncryptedBlessings or EncryptedDischarges object over the wire.

type BlessingsFlowMessageBlessings

type BlessingsFlowMessageBlessings struct{ Value Blessings }

BlessingsFlowMessageBlessings represents field Blessings of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageBlessings) FillVDLTarget

func (m BlessingsFlowMessageBlessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (BlessingsFlowMessageBlessings) Index

func (BlessingsFlowMessageBlessings) Interface

func (x BlessingsFlowMessageBlessings) Interface() interface{}

func (BlessingsFlowMessageBlessings) MakeVDLTarget

func (m BlessingsFlowMessageBlessings) MakeVDLTarget() vdl.Target

func (BlessingsFlowMessageBlessings) Name

func (BlessingsFlowMessageBlessings) VDLIsZero

func (x BlessingsFlowMessageBlessings) VDLIsZero() bool

func (BlessingsFlowMessageBlessings) VDLWrite

type BlessingsFlowMessageDischarges

type BlessingsFlowMessageDischarges struct{ Value Discharges }

BlessingsFlowMessageDischarges represents field Discharges of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageDischarges) FillVDLTarget

func (m BlessingsFlowMessageDischarges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (BlessingsFlowMessageDischarges) Index

func (BlessingsFlowMessageDischarges) Interface

func (x BlessingsFlowMessageDischarges) Interface() interface{}

func (BlessingsFlowMessageDischarges) MakeVDLTarget

func (m BlessingsFlowMessageDischarges) MakeVDLTarget() vdl.Target

func (BlessingsFlowMessageDischarges) Name

func (BlessingsFlowMessageDischarges) VDLIsZero

func (x BlessingsFlowMessageDischarges) VDLIsZero() bool

func (BlessingsFlowMessageDischarges) VDLWrite

type BlessingsFlowMessageEncryptedBlessings

type BlessingsFlowMessageEncryptedBlessings struct{ Value EncryptedBlessings }

BlessingsFlowMessageEncryptedBlessings represents field EncryptedBlessings of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageEncryptedBlessings) FillVDLTarget

func (BlessingsFlowMessageEncryptedBlessings) Index

func (BlessingsFlowMessageEncryptedBlessings) Interface

func (x BlessingsFlowMessageEncryptedBlessings) Interface() interface{}

func (BlessingsFlowMessageEncryptedBlessings) MakeVDLTarget

func (BlessingsFlowMessageEncryptedBlessings) Name

func (BlessingsFlowMessageEncryptedBlessings) VDLIsZero

func (BlessingsFlowMessageEncryptedBlessings) VDLWrite

type BlessingsFlowMessageEncryptedDischarges

type BlessingsFlowMessageEncryptedDischarges struct{ Value EncryptedDischarges }

BlessingsFlowMessageEncryptedDischarges represents field EncryptedDischarges of the BlessingsFlowMessage union type.

func (BlessingsFlowMessageEncryptedDischarges) FillVDLTarget

func (BlessingsFlowMessageEncryptedDischarges) Index

func (BlessingsFlowMessageEncryptedDischarges) Interface

func (x BlessingsFlowMessageEncryptedDischarges) Interface() interface{}

func (BlessingsFlowMessageEncryptedDischarges) MakeVDLTarget

func (BlessingsFlowMessageEncryptedDischarges) Name

func (BlessingsFlowMessageEncryptedDischarges) VDLIsZero

func (BlessingsFlowMessageEncryptedDischarges) VDLWrite

type BlessingsFlowMessageTarget

type BlessingsFlowMessageTarget struct {
	Value *BlessingsFlowMessage

	vdl.TargetBase
	vdl.FieldsTargetBase
	// contains filtered or unexported fields
}

func (*BlessingsFlowMessageTarget) FinishField

func (t *BlessingsFlowMessageTarget) FinishField(_, fieldTarget vdl.Target) error

func (*BlessingsFlowMessageTarget) FinishFields

func (t *BlessingsFlowMessageTarget) FinishFields(_ vdl.FieldsTarget) error

func (*BlessingsFlowMessageTarget) StartField

func (t *BlessingsFlowMessageTarget) StartField(name string) (key, field vdl.Target, _ error)

func (*BlessingsFlowMessageTarget) StartFields

func (t *BlessingsFlowMessageTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error)

type BlessingsTarget

type BlessingsTarget struct {
	Value *Blessings

	vdl.TargetBase
	vdl.FieldsTargetBase
	// contains filtered or unexported fields
}

func (*BlessingsTarget) FinishField

func (t *BlessingsTarget) FinishField(_, _ vdl.Target) error

func (*BlessingsTarget) FinishFields

func (t *BlessingsTarget) FinishFields(_ vdl.FieldsTarget) error

func (*BlessingsTarget) StartField

func (t *BlessingsTarget) StartField(name string) (key, field vdl.Target, _ error)

func (*BlessingsTarget) StartFields

func (t *BlessingsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error)

func (*BlessingsTarget) ZeroField

func (t *BlessingsTarget) ZeroField(name string) error

type BufferingFlow

type BufferingFlow struct {
	flow.Flow
	// contains filtered or unexported fields
}

BufferingFlow wraps a Flow and buffers all its writes. It only truly writes to the underlying flow when the buffered data exceeds the MTU of the underlying channel, or Flush, Close, or WriteMsgAndClose is called.

func NewBufferingFlow

func NewBufferingFlow(ctx *context.T, flw flow.Flow) *BufferingFlow

func (*BufferingFlow) Close

func (b *BufferingFlow) Close() error

Close flushes the already written data and then closes the underlying Flow.

func (*BufferingFlow) Flush

func (b *BufferingFlow) Flush() (err error)

Flush writes all buffered data to the underlying Flow.

func (*BufferingFlow) Write

func (b *BufferingFlow) Write(data []byte) (int, error)

Write buffers data until the underlying channels MTU is reached at which point it calls Write on the wrapped Flow.

func (*BufferingFlow) WriteMsg

func (b *BufferingFlow) WriteMsg(data ...[]byte) (int, error)

WriteMsg buffers data until the underlying channels MTU is reached at which point it calls WriteMsg on the wrapped Flow.

func (*BufferingFlow) WriteMsgAndClose

func (b *BufferingFlow) WriteMsgAndClose(data ...[]byte) (int, error)

WriteMsgAndClose writes all buffered data and closes the underlying Flow.

type Conn

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

A Conn acts as a multiplexing encrypted channel that can host Flows.

func NewAccepted

func NewAccepted(
	ctx *context.T,
	lAuthorizedPeers []security.BlessingPattern,
	conn flow.MsgReadWriteCloser,
	local naming.Endpoint,
	versions version.RPCVersionRange,
	handshakeTimeout time.Duration,
	channelTimeout time.Duration,
	handler FlowHandler) (*Conn, error)

NewAccepted accepts a new Conn on the given conn.

func NewDialed

func NewDialed(
	ctx *context.T,
	conn flow.MsgReadWriteCloser,
	local, remote naming.Endpoint,
	versions version.RPCVersionRange,
	auth flow.PeerAuthorizer,
	handshakeTimeout time.Duration,
	channelTimeout time.Duration,
	handler FlowHandler) (c *Conn, names []string, rejected []security.RejectedBlessing, err error)

NewDialed dials a new Conn on the given conn.

func (*Conn) Close

func (c *Conn) Close(ctx *context.T, err error)

Close shuts down a conn.

func (*Conn) CloseIfIdle

func (c *Conn) CloseIfIdle(ctx *context.T, idleExpiry time.Duration) bool

CloseIfIdle closes the connection if the conn has been idle for idleExpiry, returning true if it closed it.

func (*Conn) Closed

func (c *Conn) Closed() <-chan struct{}

Closed returns a channel that will be closed after the Conn is shutdown. After this channel is closed it is guaranteed that all Dial calls will fail with an error and no more flows will be sent to the FlowHandler.

func (*Conn) CommonVersion

func (c *Conn) CommonVersion() version.RPCVersion

CommonVersion returns the RPCVersion negotiated between the local and remote endpoints.

func (*Conn) Dial

func (c *Conn) Dial(ctx *context.T, blessings security.Blessings, discharges map[string]security.Discharge,
	remote naming.Endpoint, channelTimeout time.Duration, sideChannel bool) (flow.Flow, error)

Dial dials a new flow on the Conn.

func (*Conn) EnterLameDuck

func (c *Conn) EnterLameDuck(ctx *context.T) chan struct{}

EnterLameDuck enters lame duck mode, the returned channel will be closed when the remote end has ack'd or the Conn is closed.

func (*Conn) HasActiveFlows

func (c *Conn) HasActiveFlows() bool

func (*Conn) IsEncapsulated

func (c *Conn) IsEncapsulated() bool

func (*Conn) IsIdle

func (c *Conn) IsIdle(ctx *context.T, idleExpiry time.Duration) bool

func (*Conn) LastUsed

func (c *Conn) LastUsed() time.Time

LastUsed returns the time at which the Conn had bytes read or written on it.

func (*Conn) LocalBlessings

func (c *Conn) LocalBlessings() security.Blessings

LocalBlessings returns the local blessings.

func (*Conn) LocalDischarges

func (c *Conn) LocalDischarges() map[string]security.Discharge

LocalDischarges fetches the most recently sent discharges for the local ends blessings.

func (*Conn) LocalEndpoint

func (c *Conn) LocalEndpoint() naming.Endpoint

LocalEndpoint returns the local vanadium Endpoint

func (*Conn) MTU

func (c *Conn) MTU() uint64

MTU Returns the maximum transimission unit for the connection in bytes.

func (*Conn) MatchesRID

func (c *Conn) MatchesRID(ep naming.Endpoint) bool

MatchesRID returns true if the given endpoint matches the routing ID of the remote server. Also returns true if the given ep has the null routing id (in which case it is assumed that any connected server must be the target since nothing has been specified).

func (*Conn) RTT

func (c *Conn) RTT() time.Duration

RTT returns the round trip time of a message to the remote end. Note the initial estimate of the RTT from the accepted side of a connection my be long because we don't fully factor out certificate verification time. The RTT will be updated with the receipt of every healthCheckResponse, so this overestimate doesn't remain for long when the channel timeout is low.

func (*Conn) RemoteBlessings

func (c *Conn) RemoteBlessings() security.Blessings

RemoteBlessings returns the remote blessings.

func (*Conn) RemoteDischarges

func (c *Conn) RemoteDischarges() map[string]security.Discharge

RemoteDischarges fetches the most recently received discharges for the remote ends blessings.

func (*Conn) RemoteEndpoint

func (c *Conn) RemoteEndpoint() naming.Endpoint

RemoteEndpoint returns the remote vanadium Endpoint

func (*Conn) RemoteLameDuck

func (c *Conn) RemoteLameDuck() bool

RemoteLameDuck returns true if the other end of the connection has announced that it is in lame duck mode indicating that new flows should not be dialed on this conn.

func (*Conn) Status

func (c *Conn) Status() Status

type Discharges

type Discharges struct {
	Discharges []security.Discharge
	DKey       uint64
	BKey       uint64
}

Discharges is used to transport discharges between the two ends of a Conn. Since discharges can be large, we try not to send them more than once by associating them with an integer key (DKey). Thereafter we refer to them by their key. Discharges also contains the BKey of the blessings with which the discharges are associated with.

func (*Discharges) FillVDLTarget

func (m *Discharges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (*Discharges) MakeVDLTarget

func (m *Discharges) MakeVDLTarget() vdl.Target

func (Discharges) VDLIsZero

func (x Discharges) VDLIsZero() bool

func (*Discharges) VDLRead

func (x *Discharges) VDLRead(dec vdl.Decoder) error

func (Discharges) VDLWrite

func (x Discharges) VDLWrite(enc vdl.Encoder) error

type DischargesTarget

type DischargesTarget struct {
	Value *Discharges

	vdl.TargetBase
	vdl.FieldsTargetBase
	// contains filtered or unexported fields
}

func (*DischargesTarget) FinishField

func (t *DischargesTarget) FinishField(_, _ vdl.Target) error

func (*DischargesTarget) FinishFields

func (t *DischargesTarget) FinishFields(_ vdl.FieldsTarget) error

func (*DischargesTarget) StartField

func (t *DischargesTarget) StartField(name string) (key, field vdl.Target, _ error)

func (*DischargesTarget) StartFields

func (t *DischargesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error)

func (*DischargesTarget) ZeroField

func (t *DischargesTarget) ZeroField(name string) error

type EncryptedBlessings

type EncryptedBlessings struct {
	Ciphertexts []bcrypter.WireCiphertext
	BKey        uint64
}

EncryptedBlessings is used to transport encrypted blessings between the two ends of a Conn. The encryption is with respect to a set of blessing patterns that define the set of peers that are allowed to see the blessings. Since encrypted blessings can be large, we try not to send them more than once by associating them with an integer key (BKey). Thereafter we refer to them by their key.

func (*EncryptedBlessings) FillVDLTarget

func (m *EncryptedBlessings) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (*EncryptedBlessings) MakeVDLTarget

func (m *EncryptedBlessings) MakeVDLTarget() vdl.Target

func (EncryptedBlessings) VDLIsZero

func (x EncryptedBlessings) VDLIsZero() bool

func (*EncryptedBlessings) VDLRead

func (x *EncryptedBlessings) VDLRead(dec vdl.Decoder) error

func (EncryptedBlessings) VDLWrite

func (x EncryptedBlessings) VDLWrite(enc vdl.Encoder) error

type EncryptedBlessingsTarget

type EncryptedBlessingsTarget struct {
	Value *EncryptedBlessings

	vdl.TargetBase
	vdl.FieldsTargetBase
	// contains filtered or unexported fields
}

func (*EncryptedBlessingsTarget) FinishField

func (t *EncryptedBlessingsTarget) FinishField(_, _ vdl.Target) error

func (*EncryptedBlessingsTarget) FinishFields

func (t *EncryptedBlessingsTarget) FinishFields(_ vdl.FieldsTarget) error

func (*EncryptedBlessingsTarget) StartField

func (t *EncryptedBlessingsTarget) StartField(name string) (key, field vdl.Target, _ error)

func (*EncryptedBlessingsTarget) StartFields

func (t *EncryptedBlessingsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error)

func (*EncryptedBlessingsTarget) ZeroField

func (t *EncryptedBlessingsTarget) ZeroField(name string) error

type EncryptedDischarges

type EncryptedDischarges struct {
	Ciphertexts []bcrypter.WireCiphertext
	DKey        uint64
	BKey        uint64
}

EncryptedDischarges is used to transport encrypted discharges between the two ends of a Conn. The encryption is with respect to a set of blessing patterns that define the set of peers that are allowed to see the discharges. Since discharges can be large, we try not to send them more than once by associating them with an integer key (DKey). Thereafter we refer to them by their key. EncryptedDischarges also contains the BKey of the blessings with which the plaintext discharges are associated with.

func (*EncryptedDischarges) FillVDLTarget

func (m *EncryptedDischarges) FillVDLTarget(t vdl.Target, tt *vdl.Type) error

func (*EncryptedDischarges) MakeVDLTarget

func (m *EncryptedDischarges) MakeVDLTarget() vdl.Target

func (EncryptedDischarges) VDLIsZero

func (x EncryptedDischarges) VDLIsZero() bool

func (*EncryptedDischarges) VDLRead

func (x *EncryptedDischarges) VDLRead(dec vdl.Decoder) error

func (EncryptedDischarges) VDLWrite

func (x EncryptedDischarges) VDLWrite(enc vdl.Encoder) error

type EncryptedDischargesTarget

type EncryptedDischargesTarget struct {
	Value *EncryptedDischarges

	vdl.TargetBase
	vdl.FieldsTargetBase
	// contains filtered or unexported fields
}

func (*EncryptedDischargesTarget) FinishField

func (t *EncryptedDischargesTarget) FinishField(_, _ vdl.Target) error

func (*EncryptedDischargesTarget) FinishFields

func (t *EncryptedDischargesTarget) FinishFields(_ vdl.FieldsTarget) error

func (*EncryptedDischargesTarget) StartField

func (t *EncryptedDischargesTarget) StartField(name string) (key, field vdl.Target, _ error)

func (*EncryptedDischargesTarget) StartFields

func (t *EncryptedDischargesTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error)

func (*EncryptedDischargesTarget) ZeroField

func (t *EncryptedDischargesTarget) ZeroField(name string) error

type FlowHandler

type FlowHandler interface {
	// HandleFlow processes an accepted flow.
	HandleFlow(flow.Flow) error
}

A FlowHandler processes accepted flows.

type MTUer

type MTUer interface {
	MTU() uint64
}

type Status

type Status int
const (
	Active Status = iota
	EnteringLameDuck
	LameDuckAcknowledged
	Closing
	Closed
)

Note that this is a progression of states that can only go in one direction. We use inequality operators to see how far along in the progression we are, so the order of these is important.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL