David Wragg
c2ad4c5633
For fast datapath, the router core will only be invoked upon datapath misses. And it needs to yield routing decisions in a form that can be used to configure the in-kernel datapath. So here we make the router core yield FlowOps, which represent operations which actually do something with a packet. The router core obtains these in turn from the Bridge or the Overlay, depending on what it wants to do with a packet. For fast datapath, it's critical that the router makes decisions based only on the required packet header information (as the same header information will be used when configuring the ODP flow rules). So we pass only that information into the router core, in the form of PacketKeys. The overall effect is to curry the router core: Rather than taking a packet and doing something with it, it takes packet header information and returns a function that does something with a packet.
96 lines
2.2 KiB
Go
96 lines
2.2 KiB
Go
package router
|
|
|
|
import (
|
|
"net"
|
|
)
|
|
|
|
// Interface to overlay network packet handling
|
|
type Overlay interface {
|
|
// Start consuming forwarded packets.
|
|
StartConsumingPackets(*Peer, *Peers, OverlayConsumer) error
|
|
|
|
// Form a packet-forwarding connection.
|
|
MakeForwarder(ForwarderParams) (OverlayForwarder, error)
|
|
}
|
|
|
|
type ForwarderParams struct {
|
|
RemotePeer *Peer
|
|
|
|
// The local IP address to use for sending. Derived from the
|
|
// local address of the corresponding TCP socket, so may
|
|
// differ for different forwarders.
|
|
LocalIP net.IP
|
|
|
|
// The remote address to send to. nil if unknown, i.e. an
|
|
// incoming connection, in which case the Overlay needs to
|
|
// discover it (e.g. from incoming datagrams).
|
|
RemoteAddr *net.UDPAddr
|
|
|
|
// Unique identifier for this connection
|
|
ConnUID uint64
|
|
|
|
// Crypto bits. Nil if not encrypting
|
|
Crypto *OverlayCrypto
|
|
|
|
// Function to send a control message to the counterpart
|
|
// forwarder.
|
|
SendControlMessage func([]byte) error
|
|
}
|
|
|
|
// When a consumer is called, the decoder will already have been used
|
|
// to decode the frame.
|
|
type OverlayConsumer func(ForwardPacketKey) FlowOp
|
|
|
|
// Crypto settings for a forwarder.
|
|
type OverlayCrypto struct {
|
|
Dec Decryptor
|
|
Enc Encryptor
|
|
EncDF Encryptor
|
|
}
|
|
|
|
// All of the machinery to forward packets to a particular peer
|
|
type OverlayForwarder interface {
|
|
// Register a callback for forwarder state changes.
|
|
// side-effect, calling this confirms that the connection is
|
|
// really wanted, and so the provider should activate it.
|
|
// However, Forward might be called before this is called
|
|
// (e.g. on another thread).
|
|
SetListener(OverlayForwarderListener)
|
|
|
|
// Forward a packet across the connection.
|
|
Forward(ForwardPacketKey) FlowOp
|
|
|
|
Stop()
|
|
|
|
// Handle a message from the peer
|
|
ControlMessage([]byte)
|
|
}
|
|
|
|
type OverlayForwarderListener interface {
|
|
Established()
|
|
Error(error)
|
|
}
|
|
|
|
type NullOverlay struct{}
|
|
|
|
func (NullOverlay) StartConsumingPackets(*Peer, *Peers, OverlayConsumer) error {
|
|
return nil
|
|
}
|
|
|
|
func (NullOverlay) MakeForwarder(ForwarderParams) (OverlayForwarder, error) {
|
|
return NullOverlay{}, nil
|
|
}
|
|
|
|
func (NullOverlay) SetListener(OverlayForwarderListener) {
|
|
}
|
|
|
|
func (NullOverlay) Forward(ForwardPacketKey) FlowOp {
|
|
return nil
|
|
}
|
|
|
|
func (NullOverlay) Stop() {
|
|
}
|
|
|
|
func (NullOverlay) ControlMessage([]byte) {
|
|
}
|