router

package

Go to main page

Versions in this module

v1

v1.6.0

Jun 20, 2016

Changes in this version

+ type AWSVPC struct

+ func NewAWSVPC() AWSVPC

+ func (vpc AWSVPC) AddFeaturesTo(features map[string]string)

+ func (vpc AWSVPC) Diagnostics() interface{}

+ func (vpc AWSVPC) InvalidateRoutes()

+ func (vpc AWSVPC) InvalidateShortIDs()

+ func (vpc AWSVPC) PrepareConnection(params mesh.OverlayConnectionParams) (mesh.OverlayConnection, error)

+ func (vpc AWSVPC) StartConsumingPackets(localPeer *mesh.Peer, peers *mesh.Peers, consumer OverlayConsumer) error

+ type AWSVPCConnection struct

+ func (conn *AWSVPCConnection) Confirm()

+ func (conn *AWSVPCConnection) ControlMessage(tag byte, msg []byte)

+ func (conn *AWSVPCConnection) DisplayName() string

+ func (conn *AWSVPCConnection) ErrorChannel() <-chan error

+ func (conn *AWSVPCConnection) EstablishedChannel() <-chan struct{}

+ func (conn *AWSVPCConnection) Forward(key ForwardPacketKey) FlowOp

+ func (conn *AWSVPCConnection) Stop()

v1.5.2

May 26, 2016

v1.5.1

May 9, 2016

v1.5.0

Apr 19, 2016

Changes in this version

type Bridge

+ Interface func() *net.Interface

type NetworkRouter

+ func (router *NetworkRouter) ForgetConnections(peers []string)

+ func (router *NetworkRouter) InitialPeers(peers []string) ([]string, error)

+ func (router *NetworkRouter) InitiateConnections(peers []string, replace bool) []error

type NullBridge

+ func (NullBridge) Interface() *net.Interface

type Pcap

+ func (p *Pcap) Interface() *net.Interface

v1.4.6

Mar 23, 2016

v1.4.5

Feb 29, 2016

v1.4.4

Feb 9, 2016

v1.4.3

Feb 2, 2016

v1.4.2

Jan 14, 2016

v1.4.1

Dec 22, 2015

v1.4.0

Dec 17, 2015

v1.3.1

Nov 23, 2015

v1.3.0

Nov 12, 2015

Changes in this version

+ type NetworkConfig struct

+ Bridge Bridge

+ BufSz int

+ PacketLogging PacketLogging

+ type NetworkOverlay interface

+ InvalidateRoutes func()

+ InvalidateShortIDs func()

+ StartConsumingPackets func(*mesh.Peer, *mesh.Peers, OverlayConsumer) error

+ type NetworkRouter struct

+ Macs *MacCache

+ func NewNetworkRouter(config mesh.Config, networkConfig NetworkConfig, name mesh.PeerName, ...) *NetworkRouter

+ func (router *NetworkRouter) HandleHTTP(muxRouter *mux.Router)

+ func (router *NetworkRouter) Start()

+ type NetworkRouterStatus struct

+ CaptureStats map[string]int

+ Interface string

+ MACs []MACStatus

+ func NewNetworkRouterStatus(router *NetworkRouter) *NetworkRouterStatus

+ type NullNetworkOverlay struct

+ func (NullNetworkOverlay) Forward(ForwardPacketKey) FlowOp

+ func (NullNetworkOverlay) InvalidateRoutes()

+ func (NullNetworkOverlay) InvalidateShortIDs()

+ func (NullNetworkOverlay) StartConsumingPackets(*mesh.Peer, *mesh.Peers, OverlayConsumer) error

type OverlaySwitch

+ func (osw *OverlaySwitch) PrepareConnection(params mesh.OverlayConnectionParams) (mesh.OverlayConnection, error)

type SleeveOverlay

+ func (sleeve *SleeveOverlay) PrepareConnection(params mesh.OverlayConnectionParams) (mesh.OverlayConnection, error)

v1.2.1

Nov 5, 2015

v1.2.0

Oct 22, 2015

Changes in this version

+ const DefaultMTU

+ const FastDatapathHeartbeatAck

+ const MTUVerifyAttempts

+ const MTUVerifyTimeout

+ const PeerShortIDBits

+ const ProtocolOverlayControlMsg

+ const ResetAfter

+ func AddDatapathInterface(dpname string, ifname string) error

+ func CreateDatapath(dpname string) error

+ func DeleteDatapath(dpname string) error

+ type Bridge interface

+ InjectPacket func(PacketKey) FlowOp

+ StartConsumingPackets func(BridgeConsumer) error

+ Stats func() map[string]int

+ String func() string

+ func NewPcap(iface *net.Interface, bufSz int) (Bridge, error)

+ type BridgeConsumer func(PacketKey) FlowOp

type Config

+ Bridge Bridge

+ Overlay Overlay

+ PacketLogging PacketLogging

type ConnectionMaker

+ func (cm *ConnectionMaker) ConnectionAborted(address string, err error)

+ func (cm *ConnectionMaker) ConnectionCreated(conn Connection)

+ type DiscardingFlowOp struct

+ func (DiscardingFlowOp) Discards() bool

+ func (DiscardingFlowOp) Process([]byte, *EthernetDecoder, bool)

type EthernetDecoder

+ func (dec *EthernetDecoder) PacketKey() (key PacketKey)

+ type FastDatapath struct

+ func NewFastDatapath(config FastDatapathConfig) (*FastDatapath, error)

+ func (fastdp *FastDatapath) Bridge() Bridge

+ func (fastdp *FastDatapath) Close() error

+ func (fastdp *FastDatapath) Error(err error, stopped bool)

+ func (fastdp *FastDatapath) Miss(packet []byte, fks odp.FlowKeys) error

+ func (fastdp *FastDatapath) Overlay() Overlay

+ func (fastdp *FastDatapath) VportCreated(dpid odp.DatapathID, vport odp.Vport) error

+ func (fastdp *FastDatapath) VportDeleted(dpid odp.DatapathID, vport odp.Vport) error

+ type FastDatapathConfig struct

+ DatapathName string

+ ExpireFlowsInterval time.Duration

+ ExpireMACsInterval time.Duration

+ Port int

+ type FlowOp interface

+ Discards func() bool

+ Process func(frame []byte, dec *EthernetDecoder, broadcast bool)

+ func FlattenFlowOp(fop FlowOp) []FlowOp

+ type FlowStatus odp.FlowInfo

+ func (flowStatus *FlowStatus) MarshalJSON() ([]byte, error)

+ type ForwardPacketKey struct

+ DstPeer *Peer

+ SrcPeer *Peer

+ type ForwarderParams struct

+ ConnUID uint64

+ Crypto *OverlayCrypto

+ Features map[string]string

+ LocalIP net.IP

+ RemoteAddr *net.UDPAddr

+ RemotePeer *Peer

+ SendControlMessage func(tag byte, msg []byte) error

+ type MAC [6]byte

+ func (mac MAC) String() string

type MacCache

+ func (cache *MacCache) Add(mac net.HardwareAddr, peer *Peer) (bool, *Peer)

+ func (cache *MacCache) AddForced(mac net.HardwareAddr, peer *Peer) (bool, *Peer)

+ type MultiFlowOp struct

+ func NewMultiFlowOp(broadcast bool, ops ...FlowOp) *MultiFlowOp

+ func (mfop *MultiFlowOp) Add(op FlowOp)

+ func (mfop *MultiFlowOp) Discards() bool

+ func (mfop *MultiFlowOp) Process(frame []byte, dec *EthernetDecoder, broadcast bool)

+ type NonDiscardingFlowOp struct

+ func (NonDiscardingFlowOp) Discards() bool

+ type NullBridge struct

+ func (NullBridge) InjectPacket(PacketKey) FlowOp

+ func (NullBridge) StartConsumingPackets(BridgeConsumer) error

+ func (NullBridge) Stats() map[string]int

+ func (NullBridge) String() string

+ type NullOverlay struct

+ func (NullOverlay) AddFeaturesTo(map[string]string)

+ func (NullOverlay) Confirm()

+ func (NullOverlay) ControlMessage(byte, []byte)

+ func (NullOverlay) Diagnostics() interface{}

+ func (NullOverlay) DisplayName() string

+ func (NullOverlay) ErrorChannel() <-chan error

+ func (NullOverlay) EstablishedChannel() <-chan struct{}

+ func (NullOverlay) Forward(ForwardPacketKey) FlowOp

+ func (NullOverlay) InvalidateRoutes()

+ func (NullOverlay) InvalidateShortIDs()

+ func (NullOverlay) MakeForwarder(ForwarderParams) (OverlayForwarder, error)

+ func (NullOverlay) StartConsumingPackets(*Peer, *Peers, OverlayConsumer) error

+ func (NullOverlay) Stop()

+ type Overlay interface

+ AddFeaturesTo func(map[string]string)

+ Diagnostics func() interface{}

+ InvalidateRoutes func()

+ InvalidateShortIDs func()

+ MakeForwarder func(ForwarderParams) (OverlayForwarder, error)

+ StartConsumingPackets func(*Peer, *Peers, OverlayConsumer) error

+ func NewSleeveOverlay(localPort int) Overlay

+ type OverlayConsumer func(ForwardPacketKey) FlowOp

+ type OverlayCrypto struct

+ Dec Decryptor

+ Enc Encryptor

+ EncDF Encryptor

+ type OverlayForwarder interface

+ Confirm func()

+ ControlMessage func(tag byte, msg []byte)

+ DisplayName func() string

+ ErrorChannel func() <-chan error

+ EstablishedChannel func() <-chan struct{}

+ Forward func(ForwardPacketKey) FlowOp

+ Stop func()

+ type OverlaySwitch struct

+ func NewOverlaySwitch() *OverlaySwitch

+ func (osw *OverlaySwitch) Add(name string, overlay Overlay)

+ func (osw *OverlaySwitch) AddFeaturesTo(features map[string]string)

+ func (osw *OverlaySwitch) Diagnostics() interface{}

+ func (osw *OverlaySwitch) InvalidateRoutes()

+ func (osw *OverlaySwitch) InvalidateShortIDs()

+ func (osw *OverlaySwitch) MakeForwarder(params ForwarderParams) (OverlayForwarder, error)

+ func (osw *OverlaySwitch) SetCompatOverlay(overlay Overlay)

+ func (osw *OverlaySwitch) StartConsumingPackets(localPeer *Peer, peers *Peers, consumer OverlayConsumer) error

+ type PacketKey struct

+ DstMAC MAC

+ SrcMAC MAC

+ type PacketLogging interface

+ LogForwardPacket func(string, ForwardPacketKey)

+ LogPacket func(string, PacketKey)

+ type Pcap struct

+ func (p *Pcap) InjectPacket(PacketKey) FlowOp

+ func (p *Pcap) Process(frame []byte, dec *EthernetDecoder, broadcast bool)

+ func (p *Pcap) StartConsumingPackets(consumer BridgeConsumer) error

+ func (p *Pcap) Stats() map[string]int

+ func (p *Pcap) String() string

type Peer

+ func NewPeerFrom(peer *Peer) *Peer

+ func NewPeerFromSummary(summary PeerSummary) *Peer

+ type PeerShortID uint16

type PeerStatus

+ ShortID PeerShortID

type PeerSummary

+ HasShortID bool

+ ShortID PeerShortID

type Peers

+ func (peers *Peers) FetchByShortID(shortID PeerShortID) *Peer

+ func (peers *Peers) OnInvalidateShortIDs(callback func())

+ type PeersPendingNotifications struct

type Router

+ func (router *Router) BroadcastTopologyUpdate(update []*Peer)

+ type ShortIDPeers struct

+ type SleeveOverlay struct

+ func (*SleeveOverlay) AddFeaturesTo(map[string]string)

+ func (*SleeveOverlay) Diagnostics() interface{}

+ func (*SleeveOverlay) InvalidateRoutes()

+ func (*SleeveOverlay) InvalidateShortIDs()

+ func (sleeve *SleeveOverlay) MakeForwarder(params ForwarderParams) (OverlayForwarder, error)

+ func (sleeve *SleeveOverlay) StartConsumingPackets(localPeer *Peer, peers *Peers, consumer OverlayConsumer) error

type Status

+ OverlayDiagnostics interface{}

+ type TargetState int

+ const TargetAttempting

+ const TargetConnected

+ const TargetWaiting

+ type VportStatus odp.Vport

+ func (vport *VportStatus) MarshalJSON() ([]byte, error)

v1.1.2

Oct 20, 2015

v1.1.1

Oct 5, 2015

v1.1.0

Sep 7, 2015

Changes in this version

+ const MaxTCPMsgSize

+ const ProtocolMaxVersion

+ var ErrConnectToSelf = errors.New("Cannot connect to ourself")

+ var ErrExpectedCrypto = fmt.Errorf("Password specified, but peer requested an unencrypted connection")

+ var ErrExpectedNoCrypto = fmt.Errorf("No password specificed, but peer requested an encrypted connection")

+ var ProtocolV1Features = []string

+ func NewTargetSlice(cm *ConnectionMaker) []string

+ func StartLocalConnection(connRemote *RemoteConnection, tcpConn *net.TCPConn, udpAddr *net.UDPAddr, ...)

+ type BroadcastRouteStatus struct

+ Source string

+ Via []string

+ func NewBroadcastRouteStatusSlice(routes *Routes) []BroadcastRouteStatus

type Config

+ ProtocolMinVersion byte

+ type ConnectionStatus struct

+ Address string

+ Established bool

+ Name string

+ NickName string

+ Outbound bool

type EncryptedTCPReceiver

+ func (receiver *EncryptedTCPReceiver) Receive() ([]byte, error)

type EthernetDecoder

+ Eth layers.Ethernet

+ IP layers.IPv4

+ func (dec *EthernetDecoder) DF() bool

+ type GobTCPReceiver struct

+ func NewGobTCPReceiver(decoder *gob.Decoder) *GobTCPReceiver

+ func (receiver *GobTCPReceiver) Receive() ([]byte, error)

+ type GobTCPSender struct

+ func NewGobTCPSender(encoder *gob.Encoder) *GobTCPSender

+ func (sender *GobTCPSender) Send(msg []byte) error

+ type LengthPrefixTCPReceiver struct

+ func NewLengthPrefixTCPReceiver(reader io.Reader) *LengthPrefixTCPReceiver

+ func (receiver *LengthPrefixTCPReceiver) Receive() ([]byte, error)

+ type LengthPrefixTCPSender struct

+ func NewLengthPrefixTCPSender(writer io.Writer) *LengthPrefixTCPSender

+ func (sender *LengthPrefixTCPSender) Send(msg []byte) error

type LocalConnection

+ func (conn *LocalConnection) Send(df bool, frameBytes []byte) error

+ type LocalConnectionStatus struct

+ Address string

+ Info string

+ Outbound bool

+ State string

+ func NewLocalConnectionStatusSlice(cm *ConnectionMaker) []LocalConnectionStatus

+ type MACStatus struct

+ LastSeen time.Time

+ Mac string

+ Name string

+ NickName string

+ func NewMACStatusSlice(cache *MacCache) []MACStatus

type PacketSource

+ Stats func() map[string]int

type PcapIO

+ func (pio *PcapIO) Stats() map[string]int

+ type PeerStatus struct

+ Connections []ConnectionStatus

+ Name string

+ NickName string

+ UID PeerUID

+ Version uint64

+ func NewPeerStatusSlice(peers *Peers) []PeerStatus

type Peers

+ func (peers *Peers) FetchAndAddRef(name PeerName) *Peer

+ func (peers *Peers) OnGC(callback func(*Peer))

+ type ProtocolIntroConn interface

+ Read func(b []byte) (n int, err error)

+ SetDeadline func(t time.Time) error

+ SetReadDeadline func(t time.Time) error

+ SetWriteDeadline func(t time.Time) error

+ Write func(b []byte) (n int, err error)

+ type ProtocolIntroParams struct

+ Conn ProtocolIntroConn

+ Features map[string]string

+ MaxVersion byte

+ MinVersion byte

+ Outbound bool

+ Password []byte

+ func (params ProtocolIntroParams) DoIntro() (res ProtocolIntroResults, err error)

+ type ProtocolIntroResults struct

+ Features map[string]string

+ Receiver TCPReceiver

+ Sender TCPSender

+ SessionKey *[32]byte

+ Version byte

type RemoteConnection

+ func (conn *RemoteConnection) ErrorLog(args ...interface{})

type Router

+ PacketSource PacketSource

+ func (router *Router) HandleHTTP(muxRouter *mux.Router)

+ type Status struct

+ BroadcastRoutes []BroadcastRouteStatus

+ CaptureStats map[string]int

+ Connections []LocalConnectionStatus

+ Encryption bool

+ Interface string

+ MACs []MACStatus

+ Name string

+ NickName string

+ PeerDiscovery bool

+ Peers []PeerStatus

+ Port int

+ Protocol string

+ ProtocolMaxVersion int

+ ProtocolMinVersion int

+ Targets []string

+ UnicastRoutes []UnicastRouteStatus

+ func NewStatus(router *Router) *Status

type TCPReceiver

+ Receive func() ([]byte, error)

+ type UnicastRouteStatus struct

+ Dest string

+ Via string

+ func NewUnicastRouteStatusSlice(routes *Routes) []UnicastRouteStatus

v1.0.3

Sep 3, 2015

v1.0.2

Aug 18, 2015

Changes in this version

+ type TokenBucket struct

+ func NewTokenBucket(capacity int64, tokenInterval time.Duration) *TokenBucket

+ func (tb *TokenBucket) Wait()

v1.0.1

Jun 21, 2015

v1.0.0

Jun 18, 2015

Changes in this version

+ const HeaderTimeout

+ const ProtocolMinVersion

+ var ProtocolBytes = []byte(Protocol)

+ var ProtocolHeader = append(ProtocolBytes, ProtocolMinVersion, ProtocolVersion)

+ var ProtocolHeaderLen = len(ProtocolHeader)

+ var ProtocolLen = len(ProtocolBytes)

+ type Config struct

+ BufSz int

+ ConnLimit int

+ Iface *net.Interface

+ LogFrame LogFrameFunc

+ Password []byte

+ PeerDiscovery bool

+ Port int

type ConnectionMaker

+ func (cm *ConnectionMaker) ForgetConnections(peers []string)

+ func (cm *ConnectionMaker) InitiateConnections(peers []string, replace bool) []error

+ func (cm *ConnectionMaker) Status() ConnectionMakerStatus

+ type ConnectionMakerStatus struct

+ DirectPeers []string

+ Reconnects map[string]Target

+ func (status ConnectionMakerStatus) String() string

type GossipChannel

+ func NewGossipChannel(channelName string, ourself *LocalPeer, routes *Routes, g Gossiper) *GossipChannel

+ type GossipChannels map[string]*GossipChannel

+ type SurrogateGossipData struct

+ func NewSurrogateGossipData(msg []byte) *SurrogateGossipData

+ func (d *SurrogateGossipData) Encode() [][]byte

+ func (d *SurrogateGossipData) Merge(other GossipData)

+ type SurrogateGossiper struct

+ func (*SurrogateGossiper) Gossip() GossipData

+ func (*SurrogateGossiper) OnGossip(update []byte) (GossipData, error)

+ func (*SurrogateGossiper) OnGossipBroadcast(update []byte) (GossipData, error)

+ func (*SurrogateGossiper) OnGossipUnicast(sender PeerName, msg []byte) error

type Target

+ func (target Target) MarshalJSON() ([]byte, error)

v0

v0.11.2

Jun 8, 2015

v0.11.1

Jun 1, 2015

v0.11.0

May 26, 2015

Changes in this version

+ const WindowSize

+ type ConnectionSummary struct

+ Established bool

+ NameByte []byte

+ Outbound bool

+ RemoteTCPAddr string

type LocalPeer

+ func (peer *LocalPeer) ConnectionTo(name PeerName) (Connection, bool)

+ func (peer *LocalPeer) Connections() ConnectionSet

+ func (peer *LocalPeer) Encode(enc *gob.Encoder)

+ func (peer *LocalPeer) Info() string

type NaClDecryptorInstance

+ func NewNaClDecryptorInstance(outbound bool) *NaClDecryptorInstance

type Peer

+ func (peer *Peer) Encode(enc *gob.Encoder)

+ func (peer *Peer) ForEachConnectedPeer(establishedAndSymmetric bool, exclude map[PeerName]PeerName, f func(*Peer))

+ func (peer *Peer) Info() string

+ type PeerSummary struct

+ NameByte []byte

+ NickName string

+ UID PeerUID

+ Version uint64

+ type PeerUID uint64

+ func ParsePeerUID(s string) (PeerUID, error)

type Peers

+ func (peers *Peers) Dereference(peer *Peer)

type Router

+ func (router *Router) StatusJSON(version, encryption string) ([]byte, error)

+ func (router *Router) Stop() error

+ type TCPCryptoState struct

+ func NewTCPCryptoState(sessionKey *[32]byte, outbound bool) *TCPCryptoState

v0.10.0

Apr 21, 2015

Changes in this version

+ const HTTPPort

+ const HeartbeatTimeout

+ const MaxMissedHeartbeats

+ const TCPHeartbeat

type Connection

+ Log func(args ...interface{})

+ Outbound func() bool

+ type ConnectionAction func() error

type ConnectionMaker

+ func (cm *ConnectionMaker) ForgetConnection(peer string)

+ type ConnectionMakerAction func() bool

+ type ConnectionSet map[Connection]struct

+ type FieldValidator struct

+ func NewFieldValidator(fields map[string]string) *FieldValidator

+ func (fv *FieldValidator) CheckEqual(fieldName, expectedValue string) error

+ func (fv *FieldValidator) Err() error

+ func (fv *FieldValidator) Value(fieldName string) (string, error)

type Forwarder

+ func (fwd *Forwarder) Forward(frame *ForwardedFrame)

+ func (fwd *Forwarder) Shutdown()

+ type ForwarderDF struct

+ func NewForwarderDF(conn *LocalConnection, enc Encryptor, udpSender UDPSender, pmtu int) *ForwarderDF

+ func (fwd *ForwarderDF) PMTUVerified(pmtu int)

+ func (fwd *ForwarderDF) Start()

type GossipChannel

+ func (c *GossipChannel) Send(srcName PeerName, data GossipData)

+ func (c *GossipChannel) SendDown(conn Connection, data GossipData)

+ type GossipData interface

+ Encode func() []byte

+ Merge func(GossipData)

+ type GossipSender struct

+ func NewGossipSender(send func(GossipData)) *GossipSender

+ func (sender *GossipSender) Send(data GossipData)

+ func (sender *GossipSender) Start()

+ func (sender *GossipSender) Stop()

type LocalPeer

+ func (peer *LocalPeer) ConnectionsTo(names []PeerName) []Connection

+ type LocalPeerAction func()

+ type LogFrameFunc func(string, []byte, *layers.Ethernet)

type MacCache

+ func (cache *MacCache) MarshalJSON() ([]byte, error)

type Peer

+ NickName string

+ func (peer *Peer) Connections() ConnectionSet

+ func (peer *Peer) FullName() string

+ func (peer *Peer) MarshalJSON() ([]byte, error)

type PeerName

+ func (name PeerName) MarshalJSON() ([]byte, error)

+ type PeerNameSet map[PeerName]struct

type Peers

+ func (peers *Peers) EncodePeers(names PeerNameSet) []byte

+ func (peers *Peers) MarshalJSON() ([]byte, error)

+ func (peers *Peers) Names() PeerNameSet

type ProtocolTag

+ const ProtocolHeartbeat

type RemoteConnection

+ func (conn *RemoteConnection) Log(args ...interface{})

+ func (conn *RemoteConnection) MarshalJSON() ([]byte, error)

+ func (conn *RemoteConnection) Outbound() bool

type Router

+ func (router *Router) GenerateStatusJSON(version, encryption string) ([]byte, error)

+ type RouterConfig struct

+ BufSz int

+ ConnLimit int

+ Iface *net.Interface

+ LogFrame LogFrameFunc

+ Password []byte

+ Port int

type Routes

+ func (routes *Routes) BroadcastAll(name PeerName) []PeerName

+ func (routes *Routes) EnsureRecalculated()

+ func (routes *Routes) MarshalJSON() ([]byte, error)

+ func (routes *Routes) PeerNames() PeerNameSet

+ func (routes *Routes) RandomNeighbours(except PeerName) PeerNameSet

+ func (routes *Routes) UnicastAll(name PeerName) (PeerName, bool)

+ type TopologyGossipData struct

+ func NewTopologyGossipData(peers *Peers, update ...*Peer) *TopologyGossipData

+ func (d *TopologyGossipData) Encode() []byte

+ func (d *TopologyGossipData) Merge(other GossipData)

v0.9.0

Feb 3, 2015

Changes in this version

+ const CReceivedHeartbeat

+ const CSendProtocolMsg

+ const EstablishedTimeout

+ const GossipInterval

+ const PSendProtocolMsg

+ func GobEncode(items ...interface{}) []byte

type Connection

+ BreakTie func(Connection) ConnectionTieBreak

type ConnectionMaker

+ func NewConnectionMaker(ourself *LocalPeer, peers *Peers) *ConnectionMaker

+ func (cm *ConnectionMaker) Start()

+ type ConnectionTieBreak int

+ const TieBreakLost

+ const TieBreakTied

+ const TieBreakWon

type EthernetDecoder

+ func (dec *EthernetDecoder) IsSpecial() bool

type Forwarder

+ func (fwd *Forwarder) Start()

+ type Gossip interface

+ GossipBroadcast func(buf []byte) error

+ GossipUnicast func(dstPeerName PeerName, buf []byte) error

+ type GossipChannel struct

+ func (c *GossipChannel) GossipBroadcast(buf []byte) error

+ func (c *GossipChannel) GossipUnicast(dstPeerName PeerName, buf []byte) error

+ func (c *GossipChannel) SendGossipMsg(buf []byte)

+ type Gossiper interface

+ Gossip func() []byte

+ OnGossip func(buf []byte) ([]byte, error)

+ OnGossipBroadcast func(msg []byte) error

+ OnGossipUnicast func(sender PeerName, msg []byte) error

type LocalConnection

+ func (conn *LocalConnection) BreakTie(dupConn Connection) ConnectionTieBreak

+ func (conn *LocalConnection) ReceivedHeartbeat(remoteUDPAddr *net.UDPAddr, connUID uint64)

+ func (conn *LocalConnection) SendProtocolMsg(m ProtocolMsg)

+ func (conn *LocalConnection) Start(acceptNewPeer bool)

type LocalPeer

+ func NewLocalPeer(name PeerName, router *Router) *LocalPeer

+ func (peer *LocalPeer) NextBroadcastHops(srcPeer *Peer) []*LocalConnection

+ func (peer *LocalPeer) SendProtocolMsg(m ProtocolMsg)

+ func (peer *LocalPeer) Start()

type MacCache

+ func (cache *MacCache) Start()

+ type ProtocolMsg struct

+ type ProtocolSender interface

+ SendProtocolMsg func(m ProtocolMsg)

+ type ProtocolTag byte

+ const ProtocolGossip

+ const ProtocolGossipBroadcast

+ const ProtocolGossipUnicast

type RemoteConnection

+ func (conn *RemoteConnection) BreakTie(Connection) ConnectionTieBreak

type Router

+ GossipChannels map[uint32]*GossipChannel

+ TopologyGossip Gossip

+ func (router *Router) Gossip() []byte

+ func (router *Router) NewGossip(channelName string, g Gossiper) Gossip

+ func (router *Router) OnGossip(buf []byte) ([]byte, error)

+ func (router *Router) OnGossipBroadcast(msg []byte) error

+ func (router *Router) OnGossipUnicast(sender PeerName, msg []byte) error

+ func (router *Router) SendAllGossip()

+ func (router *Router) SendAllGossipDown(conn Connection)

type Routes

+ func NewRoutes(ourself *Peer, peers *Peers) *Routes

+ func (routes *Routes) Start()

+ type UnknownPeerError struct

+ Name PeerName

+ func (upe UnknownPeerError) Error() string

v0.8.0

Jan 4, 2015

v0.7.0

Dec 30, 2014

Changes in this version

+ const CMInitiate

+ const CMRefresh

+ const CMStatus

+ const CMTerminated

+ const CSendTCP

+ const CSetEstablished

+ const CSetRemoteUDPAddr

+ const CShutdown

+ const ChannelSize

+ const DefaultPMTU

+ const EthernetOverhead

+ const FastHeartbeat

+ const FetchAllInterval

+ const FragTestInterval

+ const FragTestSize

+ const HttpPort

+ const InitialInterval

+ const MaxDuration

+ const MaxInterval

+ const MaxUDPPacketSize

+ const NameSize

+ const PAddConnection

+ const PBroadcastTCP

+ const PConnectionEstablished

+ const PDeleteConnection

+ const PMTUDiscoverySize

+ const PMTUVerifyAttempts

+ const PMTUVerifyTimeout

+ const PeerNameFlavour

+ const Port

+ const Protocol

+ const ProtocolConnectionEstablished

+ const ProtocolFetchAll

+ const ProtocolFragmentationReceived

+ const ProtocolNonce

+ const ProtocolPMTUVerified

+ const ProtocolStartFragmentationTest

+ const ProtocolUpdate

+ const ProtocolVersion

+ const RRecalculate

+ const ReadTimeout

+ const SlowHeartbeat

+ const UDPNonceSendAt

+ const UDPOverhead

+ const UnknownPeerName

+ var FragTest = make([]byte, FragTestSize)

+ var PMTUDiscovery = make([]byte, PMTUDiscoverySize)

+ var ProtocolConnectionEstablishedByte = []byte

+ var ProtocolFetchAllByte = []byte

+ var ProtocolFragmentationReceivedByte = []byte

+ var ProtocolNonceByte = []byte

+ var ProtocolPMTUVerifiedByte = []byte

+ var ProtocolStartFragmentationTestByte = []byte

+ var ProtocolUpdateByte = []byte

+ func Concat(elems ...[]byte) []byte

+ func DecodeNonce(msg []byte) (bool, *[24]byte)

+ func DecryptPrefixNonce(ciphertxt []byte, secret *[32]byte) ([]byte, bool)

+ func EncodeNonce(df bool) (*[24]byte, []byte, error)

+ func EncodePeers(peers ...*Peer) []byte

+ func EncryptPrefixNonce(plaintxt []byte, nonce *[24]byte, secret *[32]byte) []byte

+ func FormSessionKey(remotePublicKey, localPrivateKey *[32]byte, secretKey *[]byte) *[32]byte

+ func GenerateKeyPair() (publicKey, privateKey *[32]byte, err error)

+ func GenerateRandomNonce() ([24]byte, error)

+ func NewLocalConnection(connRemote *RemoteConnection, acceptNewPeer bool, tcpConn *net.TCPConn, ...)

+ func NormalisePeerAddr(peerAddr string) string

+ func PosixError(err error) error

+ func SetNonceLow15Bits(nonce *[24]byte, offset uint16)

+ type Connection interface

+ Established func() bool

+ Local func() *Peer

+ Remote func() *Peer

+ RemoteTCPAddr func() string

+ Shutdown func()

+ type ConnectionInteraction struct

+ type ConnectionMaker struct

+ func StartConnectionMaker(ourself *LocalPeer, peers *Peers) *ConnectionMaker

+ func (cm *ConnectionMaker) ConnectionTerminated(address string)

+ func (cm *ConnectionMaker) InitiateConnection(address string)

+ func (cm *ConnectionMaker) Refresh()

+ func (cm *ConnectionMaker) String() string

+ type ConnectionMakerInteraction struct

+ type Decryptor interface

+ IterateFrames func(FrameConsumer, *UDPPacket) error

+ ReceiveNonce func([]byte)

+ Shutdown func()

+ type EncryptedTCPMessage struct

+ Body []byte

+ Number int

+ type EncryptedTCPReceiver struct

+ func NewEncryptedTCPReceiver(conn *LocalConnection) *EncryptedTCPReceiver

+ func (receiver *EncryptedTCPReceiver) Decode(msg []byte) ([]byte, error)

+ type EncryptedTCPSender struct

+ func NewEncryptedTCPSender(encoder *gob.Encoder, conn *LocalConnection) *EncryptedTCPSender

+ func (sender *EncryptedTCPSender) Send(msg []byte) error

+ type Encryptor interface

+ AppendFrame func(*ForwardedFrame)

+ Bytes func() []byte

+ FrameOverhead func() int

+ IsEmpty func() bool

+ PacketOverhead func() int

+ TotalLen func() int

+ type EthernetDecoder struct

+ func NewEthernetDecoder() *EthernetDecoder

+ func (dec *EthernetDecoder) CheckFrameTooBig(err error, sendFrame func([]byte) error) error

+ func (dec *EthernetDecoder) DecodeLayers(data []byte) error

+ func (dec *EthernetDecoder) DropFrame() bool

+ func (dec *EthernetDecoder) IsPMTUVerify() bool

+ type ForwardedFrame struct

+ type Forwarder struct

+ func NewForwarder(conn *LocalConnection, ch <-chan *ForwardedFrame, stop <-chan interface{}, ...) *Forwarder

+ func (fwd *Forwarder) Run()

+ type FrameConsumer func(*LocalConnection, *net.UDPAddr, []byte, []byte, uint16, []byte) error

+ type FrameTooBigError struct

+ EPMTU int

+ func (ftbe FrameTooBigError) Error() string

+ type Interaction struct

+ type ListOfPeers []*Peer

+ func (lop ListOfPeers) Len() int

+ func (lop ListOfPeers) Less(i, j int) bool

+ func (lop ListOfPeers) Swap(i, j int)

+ type LocalAddress struct

+ type LocalConnection struct

+ Decryptor Decryptor

+ Router *Router

+ SessionKey *[32]byte

+ TCPConn *net.TCPConn

+ UID uint64

+ func (conn *LocalConnection) CheckFatal(err error) error

+ func (conn *LocalConnection) Established() bool

+ func (conn *LocalConnection) Forward(df bool, frame *ForwardedFrame, dec *EthernetDecoder) error

+ func (conn *LocalConnection) RemoteUDPAddr() *net.UDPAddr

+ func (conn *LocalConnection) SendTCP(msg []byte)

+ func (conn *LocalConnection) SetEstablished()

+ func (conn *LocalConnection) SetRemoteUDPAddr(remoteUDPAddr *net.UDPAddr)

+ func (conn *LocalConnection) Shutdown()

+ type LocalPeer struct

+ Router *Router

+ func StartLocalPeer(name PeerName, router *Router) *LocalPeer

+ func (peer *LocalPeer) AddConnection(conn *LocalConnection)

+ func (peer *LocalPeer) Broadcast(df bool, frame []byte, dec *EthernetDecoder) error

+ func (peer *LocalPeer) BroadcastTCP(msg []byte)

+ func (peer *LocalPeer) ConnectionEstablished(conn *LocalConnection)

+ func (peer *LocalPeer) CreateConnection(peerAddr string, acceptNewPeer bool) error

+ func (peer *LocalPeer) DeleteConnection(conn *LocalConnection)

+ func (peer *LocalPeer) Forward(dstPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error

+ func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error

+ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error

+ type MacCache struct

+ func NewMacCache(maxAge time.Duration, onExpiry func(net.HardwareAddr, *Peer)) *MacCache

+ func (cache *MacCache) Delete(peer *Peer) bool

+ func (cache *MacCache) Enter(mac net.HardwareAddr, peer *Peer) bool

+ func (cache *MacCache) Lookup(mac net.HardwareAddr) (*Peer, bool)

+ func (cache *MacCache) String() string

+ type MacCacheEntry struct

+ type MsgTooBigError struct

+ PMTU int

+ func (mtbe MsgTooBigError) Error() string

+ type NaClDecryptor struct

+ func NewNaClDecryptor(conn *LocalConnection) *NaClDecryptor

+ func (nd *NaClDecryptor) IterateFrames(fun FrameConsumer, packet *UDPPacket) error

+ func (nd *NaClDecryptor) ReceiveNonce(msg []byte)

+ func (nd *NaClDecryptor) Shutdown()

+ type NaClDecryptorInstance struct

+ type NaClEncryptor struct

+ func NewNaClEncryptor(prefix []byte, conn *LocalConnection, df bool) *NaClEncryptor

+ func (ne *NaClEncryptor) Bytes() []byte

+ func (ne *NaClEncryptor) PacketOverhead() int

+ func (ne *NaClEncryptor) TotalLen() int

+ type NameCollisionError struct

+ Name PeerName

+ func (nce NameCollisionError) Error() string

+ type NonDecryptor struct

+ func NewNonDecryptor(conn *LocalConnection) *NonDecryptor

+ func (nd *NonDecryptor) IterateFrames(fun FrameConsumer, packet *UDPPacket) error

+ func (nd *NonDecryptor) ReceiveNonce(msg []byte)

+ func (nd *NonDecryptor) Shutdown()

+ type NonEncryptor struct

+ func NewNonEncryptor(prefix []byte) *NonEncryptor

+ func (ne *NonEncryptor) AppendFrame(frame *ForwardedFrame)

+ func (ne *NonEncryptor) Bytes() []byte

+ func (ne *NonEncryptor) FrameOverhead() int

+ func (ne *NonEncryptor) IsEmpty() bool

+ func (ne *NonEncryptor) PacketOverhead() int

+ func (ne *NonEncryptor) TotalLen() int

+ type PacketDecodingError struct

+ Desc string

+ Fatal bool

+ func (pde PacketDecodingError) Error() string

+ type PacketSink interface

+ WritePacket func([]byte) error

+ func NewPcapO(ifName string) (po PacketSink, err error)

+ type PacketSource interface

+ ReadPacket func() ([]byte, error)

+ type PacketSourceSink interface

+ func NewPcapIO(ifName string, bufSz int) (PacketSourceSink, error)

+ type PcapIO struct

+ func (pi *PcapIO) ReadPacket() (data []byte, err error)

+ func (po *PcapIO) WritePacket(data []byte) error

+ type Peer struct

+ Name PeerName

+ NameByte []byte

+ UID uint64

+ func NewPeer(name PeerName, uid uint64, version uint64) *Peer

+ func (peer *Peer) ConnectionCount() int

+ func (peer *Peer) ConnectionTo(name PeerName) (Connection, bool)

+ func (peer *Peer) DecrementLocalRefCount()

+ func (peer *Peer) ForEachConnection(fun func(PeerName, Connection))

+ func (peer *Peer) IncrementLocalRefCount()

+ func (peer *Peer) IsLocallyReferenced() bool

+ func (peer *Peer) Routes(stopAt *Peer, symmetric bool) (bool, map[PeerName]PeerName)

+ func (peer *Peer) SetVersionAndConnections(version uint64, connections map[PeerName]Connection)

+ func (peer *Peer) String() string

+ func (peer *Peer) Version() uint64

+ type PeerInteraction struct

+ type PeerName uint64

+ func PeerNameFromBin(nameByte []byte) PeerName

+ func PeerNameFromString(nameStr string) (PeerName, error)

+ func PeerNameFromUserInput(userInput string) (PeerName, error)

+ func (name PeerName) Bin() []byte

+ func (name PeerName) String() string

+ type Peers struct

+ func NewPeers(ourself *Peer, macs *MacCache, onGC func(*Peer)) *Peers

+ func (peers *Peers) ApplyUpdate(update []byte) ([]byte, error)

+ func (peers *Peers) EncodeAllPeers() []byte

+ func (peers *Peers) Fetch(name PeerName) (*Peer, bool)

+ func (peers *Peers) FetchWithDefault(peer *Peer) *Peer

+ func (peers *Peers) ForEach(fun func(PeerName, *Peer))

+ func (peers *Peers) GarbageCollect() []*Peer

+ func (peers *Peers) String() string

+ type RawUDPSender struct

+ func NewRawUDPSender(conn *LocalConnection) (*RawUDPSender, error)

+ func (sender *RawUDPSender) Send(msg []byte) error

+ func (sender *RawUDPSender) Shutdown() error

+ type RemoteConnection struct

+ func NewRemoteConnection(from, to *Peer, tcpAddr string) *RemoteConnection

+ func (conn *RemoteConnection) Established() bool

+ func (conn *RemoteConnection) Local() *Peer

+ func (conn *RemoteConnection) Remote() *Peer

+ func (conn *RemoteConnection) RemoteTCPAddr() string

+ func (conn *RemoteConnection) Shutdown()

+ func (conn *RemoteConnection) String() string

+ type Router struct

+ BufSz int

+ ConnLimit int

+ ConnectionMaker *ConnectionMaker

+ Iface *net.Interface

+ LogFrame func(string, []byte, *layers.Ethernet)

+ Macs *MacCache

+ Ourself *LocalPeer

+ Password *[]byte

+ Peers *Peers

+ Routes *Routes

+ UDPListener *net.UDPConn

+ func NewRouter(iface *net.Interface, name PeerName, password []byte, connLimit int, bufSz int, ...) *Router

+ func (router *Router) Start()

+ func (router *Router) Status() string

+ func (router *Router) UsingPassword() bool

+ type Routes struct

+ func StartRoutes(ourself *Peer, peers *Peers) *Routes

+ func (routes *Routes) Broadcast(name PeerName) []PeerName

+ func (routes *Routes) Recalculate()

+ func (routes *Routes) String() string

+ func (routes *Routes) Unicast(name PeerName) (PeerName, bool)

+ type SimpleTCPReceiver struct

+ func NewSimpleTCPReceiver() *SimpleTCPReceiver

+ func (receiver *SimpleTCPReceiver) Decode(msg []byte) ([]byte, error)

+ type SimpleTCPSender struct

+ func NewSimpleTCPSender(encoder *gob.Encoder) *SimpleTCPSender

+ func (sender *SimpleTCPSender) Send(msg []byte) error

+ type SimpleUDPSender struct

+ func NewSimpleUDPSender(conn *LocalConnection) *SimpleUDPSender

+ func (sender *SimpleUDPSender) Send(msg []byte) error

+ func (sender *SimpleUDPSender) Shutdown() error

+ type TCPReceiver interface

+ Decode func([]byte) ([]byte, error)

+ type TCPSender interface

+ Send func([]byte) error

+ type Target struct

+ type UDPPacket struct

+ Name PeerName

+ Packet []byte

+ Sender *net.UDPAddr

+ func (packet UDPPacket) String() string

+ type UDPSender interface

+ Send func([]byte) error

+ Shutdown func() error

+ type UnknownPeersError struct

+ func (upe UnknownPeersError) Error() string

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