svc

Documentation

Overview

Package svc implements support for SVC Resolution.

Index

• Constants
• type BaseHandler
  • func (h *BaseHandler) Handle(request *Request) (Result, error)
• type Reply
  • func (r *Reply) Marshal() ([]byte, error)
  • func (r *Reply) Unmarshal(raw []byte) error
• type Request
• type RequestHandler
• type Resolver
  • func (r *Resolver) LookupSVC(ctx context.Context, p snet.Path, svc addr.SVC) (*Reply, error)
• type ResolverPacketConn
  • func (c *ResolverPacketConn) ReadFrom(pkt *snet.Packet, ov *net.UDPAddr) error
• type Result
• type RoundTripper
  • func DefaultRoundTripper() RoundTripper
• type Transport

Constants

const ErrHandler common.ErrMsg = "Unable to handle SVC request"

Types

type BaseHandler

type BaseHandler struct {
	// Message is the payload data to send in the reply. Nil and zero-length
	// payloads are supported.
	Message []byte
}

BaseHandler reverses a SCION packet, replaces the source address with the one in the struct and then sends the message on the connection.

func (*BaseHandler) Handle

func (h *BaseHandler) Handle(request *Request) (Result, error)

type Reply

type Reply struct {
	// Transports maps transport keys (e.g., "QUIC") to network address strings
	// (e.g., "192.168.1.1:80"). Applications should check if the transport keys
	// are acceptable and must parse the address strings accordingly.
	Transports map[Transport]string
	// ReturnPath contains the reversed and initialized path the SVC resolution
	// message arrived on. This can be used to communicate across paths
	// bootstrapped via One-Hop Path communication.
	ReturnPath snet.Path
}

Reply is an SVC resolution reply.

func (*Reply) Marshal

func (r *Reply) Marshal() ([]byte, error)

SerializeTo encodes a reply message into its protobuf representation. No validation of transport keys is performed.

func (*Reply) Unmarshal

func (r *Reply) Unmarshal(raw []byte) error

Unmarshal decodes a reply message from its protobuf representation. No validation of transport keys is performed.

If the returned error is non-nil, the state of Reply is unspecified.

type Request

type Request struct {
	// Source is the override value for the source address of the reply packet.
	Source snet.SCIONAddress
	// Conn is the connection to send the reply on. Conn must not be nil.
	Conn     snet.PacketConn
	Packet   *snet.Packet
	Underlay *net.UDPAddr
}

type RequestHandler

type RequestHandler interface {
	// Handle replies to SCION packets with SVC destinations coming from the
	// specified underlay address.
	//
	// Handle implementantions might panic if the destination is not an SVC
	// address, so callers should perform the check beforehand.
	Handle(*Request) (Result, error)
}

RequestHandler handles SCION packets with SVC destination addresses.

type Resolver

type Resolver struct {
	Network snet.Network
	// LocalIA is the local AS.
	LocalIA addr.IA
	// LocalIP is the default L3 address for connections originating from this process.
	LocalIP net.IP
	// RoundTripper performs the request/reply exchange for SVC resolutions. If
	// nil, the default round tripper is used.
	RoundTripper RoundTripper
}

Resolver performs SVC address resolution.

func (*Resolver) LookupSVC

func (r *Resolver) LookupSVC(ctx context.Context, p snet.Path, svc addr.SVC) (*Reply, error)

LookupSVC resolves the SVC address for the AS terminating the path.

type ResolverPacketConn

type ResolverPacketConn struct {
	// PacketConn is the conn to receive and send packets.
	snet.PacketConn
	// Source contains the address from which packets should be sent.
	Source snet.SCIONAddress
	// Handler handles packets for SVC destinations.
	Handler RequestHandler
}

ResolverPacketConn redirects SVC destination packets to SVC resolution handler logic.

func (*ResolverPacketConn) ReadFrom

func (c *ResolverPacketConn) ReadFrom(pkt *snet.Packet, ov *net.UDPAddr) error

type Result

type Result int

Result is used to inform Handler users on the outcome of handler execution.

const (
	// Error means that the handler experience an error during processing.
	Error Result = iota
	// Handled means that the handler completed successfully.
	Handled
	// Forward means that the packet should be forwarded to the application.
	Forward
)

type RoundTripper

type RoundTripper interface {
	// RoundTrip performs the round trip interaction.
	RoundTrip(ctx context.Context, c snet.PacketConn, request *snet.Packet,
		u *net.UDPAddr) (*Reply, error)
}

RoundTripper does a single SVC resolution request/reply interaction over a connection, using the specified request packet and underlay address.

func DefaultRoundTripper

func DefaultRoundTripper() RoundTripper

DefaultRoundTripper returns a basic implementation of the RoundTripper interface.

type Transport

type Transport string

Transport contains constants for common transport keys.

const (
	QUIC Transport = "QUIC"
)