retriving nextHop from path and local Interface information

control/cmd/control/main.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
 	_ "net/http/pprof"
 	"path/filepath"
@@ -959,6 +960,18 @@ func (c controller) PortRange(_ context.Context) (uint16, uint16, error) {
 	return start, end, nil
 }
 
+func (c controller) Interfaces(_ context.Context) (map[uint16]*net.UDPAddr, error) {
+	ifMap := c.topo.InterfaceInfoMap()
+	ifsToUDP := make(map[uint16]*net.UDPAddr, len(ifMap))
+	for i, v := range ifMap {
+		if i > (1<<16)-1 {
+			return nil, serrors.New("Invalid interface id", "id", i)
+		}
+		ifsToUDP[uint16(i)] = v.InternalAddr
+	}
+	return ifsToUDP, nil
+}
+
 func getCAHealth(
 	ctx context.Context,
 	caClient *caapi.Client,

daemon/internal/servers/grpc.go

@@ -279,15 +279,15 @@ func (s *DaemonServer) interfaces(ctx context.Context,
 	_ *sdpb.InterfacesRequest) (*sdpb.InterfacesResponse, error) {
 
 	reply := &sdpb.InterfacesResponse{
-		Interfaces: make(map[uint64]*sdpb.Interface),
+		Interfaces: make(map[uint32]*sdpb.Interface),
 	}
 	topo := s.Topology
 	for _, ifID := range topo.InterfaceIDs() {
 		nextHop := topo.UnderlayNextHop(ifID)
 		if nextHop == nil {
 			continue
 		}
-		reply.Interfaces[uint64(ifID)] = &sdpb.Interface{
+		reply.Interfaces[uint32(ifID)] = &sdpb.Interface{
 			Address: &sdpb.Underlay{
 				Address: nextHop.String(),
 			},

pkg/daemon/daemon.go

@@ -24,7 +24,6 @@ import (
 	"github.com/scionproto/scion/pkg/daemon/internal/metrics"
 	"github.com/scionproto/scion/pkg/drkey"
 	libmetrics "github.com/scionproto/scion/pkg/metrics"
-	"github.com/scionproto/scion/pkg/private/common"
 	"github.com/scionproto/scion/pkg/private/ctrl/path_mgmt"
 	"github.com/scionproto/scion/pkg/private/serrors"
 	"github.com/scionproto/scion/pkg/snet"
@@ -67,15 +66,13 @@ type Connector interface {
 	// PortRange returns the beginning and the end of the SCION/UDP endhost port range, configured
 	// for the local IA.
 	PortRange(ctx context.Context) (uint16, uint16, error)
+	// Interfaces returns the map of interface identifiers to the underlay internal address.
+	Interfaces(ctx context.Context) (map[uint16]*net.UDPAddr, error)
 	// Paths requests from the daemon a set of end to end paths between the source and destination.
 	Paths(ctx context.Context, dst, src addr.IA, f PathReqFlags) ([]snet.Path, error)
 	// ASInfo requests from the daemon information about AS ia, the zero IA can be
 	// use to detect the local IA.
 	ASInfo(ctx context.Context, ia addr.IA) (ASInfo, error)
-	// IFInfo requests from SCION Daemon addresses and ports of interfaces. Slice
-	// ifs contains interface IDs of BRs. If empty, a fresh (i.e., uncached)
-	// answer containing all interfaces is returned.
-	IFInfo(ctx context.Context, ifs []common.IFIDType) (map[common.IFIDType]*net.UDPAddr, error)
 	// SVCInfo requests from the daemon information about addresses and ports of
 	// infrastructure services.  Slice svcTypes contains a list of desired
 	// service types. If unset, a fresh (i.e., uncached) answer containing all

pkg/daemon/grpc.go

@@ -82,6 +82,27 @@ func (c grpcConn) PortRange(ctx context.Context) (uint16, uint16, error) {
 	return asInfo.EndhostStartPort, asInfo.EndhostEndPort, nil
 }
 
+func (c grpcConn) Interfaces(ctx context.Context) (map[uint16]*net.UDPAddr, error) {
+
+	client := sdpb.NewDaemonServiceClient(c.conn)
+	response, err := client.Interfaces(ctx, &sdpb.InterfacesRequest{})
+	if err != nil {
+		c.metrics.incInterface(err)
+		return nil, err
+	}
+	result := make(map[uint16]*net.UDPAddr)
+	for ifID, intf := range response.Interfaces {
+		a, err := net.ResolveUDPAddr("udp", intf.Address.Address)
+		if err != nil {
+			c.metrics.incInterface(err)
+			return nil, serrors.WrapStr("parsing reply", err, "raw_uri", intf.Address.Address)
+		}
+		result[uint16(ifID)] = a
+	}
+	c.metrics.incInterface(nil)
+	return result, nil
+}
+
 func (c grpcConn) Paths(ctx context.Context, dst, src addr.IA,
 	f PathReqFlags) ([]snet.Path, error) {
 
@@ -117,28 +138,6 @@ func (c grpcConn) ASInfo(ctx context.Context, ia addr.IA) (ASInfo, error) {
 	}, nil
 }
 
-func (c grpcConn) IFInfo(ctx context.Context,
-	_ []common.IFIDType) (map[common.IFIDType]*net.UDPAddr, error) {
-
-	client := sdpb.NewDaemonServiceClient(c.conn)
-	response, err := client.Interfaces(ctx, &sdpb.InterfacesRequest{})
-	if err != nil {
-		c.metrics.incInterface(err)
-		return nil, err
-	}
-	result := make(map[common.IFIDType]*net.UDPAddr)
-	for ifID, intf := range response.Interfaces {
-		a, err := net.ResolveUDPAddr("udp", intf.Address.Address)
-		if err != nil {
-			c.metrics.incInterface(err)
-			return nil, serrors.WrapStr("parsing reply", err, "raw_uri", intf.Address.Address)
-		}
-		result[common.IFIDType(ifID)] = a
-	}
-	c.metrics.incInterface(nil)
-	return result, nil
-}
-
 func (c grpcConn) SVCInfo(
 	ctx context.Context,
 	_ []addr.SVC,

pkg/daemon/mock_daemon/BUILD.bazel

@@ -18,7 +18,6 @@ go_library(
         "//pkg/addr:go_default_library",
         "//pkg/daemon:go_default_library",
         "//pkg/drkey:go_default_library",
-        "//pkg/private/common:go_default_library",
         "//pkg/private/ctrl/path_mgmt:go_default_library",
         "//pkg/snet:go_default_library",
         "@com_github_golang_mock//gomock:go_default_library",

pkg/snet/BUILD.bazel

@@ -30,8 +30,12 @@ go_library(
         "//pkg/private/util:go_default_library",
         "//pkg/slayers:go_default_library",
         "//pkg/slayers/path:go_default_library",
+        "//pkg/slayers/path/empty:go_default_library",
         "//pkg/slayers/path/epic:go_default_library",
+        "//pkg/slayers/path/onehop:go_default_library",
+        "//pkg/slayers/path/scion:go_default_library",
         "//private/topology:go_default_library",
+        "//private/topology/underlay:go_default_library",
         "@com_github_google_gopacket//:go_default_library",
     ],
 )

pkg/snet/packet_conn.go

@@ -24,6 +24,11 @@ import (
 	"github.com/scionproto/scion/pkg/private/common"
 	"github.com/scionproto/scion/pkg/private/serrors"
 	"github.com/scionproto/scion/pkg/slayers"
+	"github.com/scionproto/scion/pkg/slayers/path/empty"
+	"github.com/scionproto/scion/pkg/slayers/path/epic"
+	"github.com/scionproto/scion/pkg/slayers/path/onehop"
+	"github.com/scionproto/scion/pkg/slayers/path/scion"
+	"github.com/scionproto/scion/private/topology/underlay"
 )
 
 // PacketConn gives applications easy access to writing and reading custom
@@ -114,7 +119,8 @@ type SCIONPacketConn struct {
 	// SCMP message is received.
 	SCMPHandler SCMPHandler
 	// Metrics are the metrics exported by the conn.
-	Metrics SCIONPacketConnMetrics
+	Metrics        SCIONPacketConnMetrics
+	getLastHopAddr func(id uint16) (*net.UDPAddr, error)
 }
 
 func (c *SCIONPacketConn) SetReadBuffer(bytes int) error {
@@ -185,7 +191,7 @@ func (c *SCIONPacketConn) SyscallConn() (syscall.RawConn, error) {
 
 func (c *SCIONPacketConn) readFrom(pkt *Packet, ov *net.UDPAddr) error {
 	pkt.Prepare()
-	n, lastHopNetAddr, err := c.Conn.ReadFrom(pkt.Bytes)
+	n, err := c.Conn.Read(pkt.Bytes)
 	if err != nil {
 		metrics.CounterInc(c.Metrics.UnderlayConnectionErrors)
 		return serrors.WrapStr("Reliable socket read error", err)
@@ -194,20 +200,17 @@ func (c *SCIONPacketConn) readFrom(pkt *Packet, ov *net.UDPAddr) error {
 	metrics.CounterInc(c.Metrics.ReadPackets)
 
 	pkt.Bytes = pkt.Bytes[:n]
-	var lastHop *net.UDPAddr
-
-	var ok bool
-	lastHop, ok = lastHopNetAddr.(*net.UDPAddr)
-	if !ok {
-		return serrors.New("Invalid lastHop address Type",
-			"Actual", lastHopNetAddr)
-	}
-
 	if err := pkt.Decode(); err != nil {
 		metrics.CounterInc(c.Metrics.ParseErrors)
 		return serrors.WrapStr("decoding packet", err)
 	}
 
+	// Get ingress interface internal address
+	lastHop, err := c.lastHop(pkt)
+	if err != nil {
+		return serrors.WrapStr("extracting next hop based on packet path", err)
+	}
+
 	if ov != nil {
 		*ov = *lastHop
 	}
@@ -236,3 +239,82 @@ type SerializationOptions struct {
 	// unchanged.
 	InitializePaths bool
 }
+
+func (c *SCIONPacketConn) lastHop(p *Packet) (*net.UDPAddr, error) {
+	rpath, ok := p.Path.(RawPath)
+	if !ok {
+		return nil, serrors.New("Unexpected path", "type", common.TypeOf(p.Path))
+	}
+	switch rpath.PathType {
+	case empty.PathType:
+		if p.Source.Host.Type() != addr.HostTypeIP {
+			return nil, serrors.New("Unexpected source address in packet",
+				"type", p.Source.Host.Type().String())
+		}
+		var port int
+		switch p := p.PacketInfo.Payload.(type) {
+		case UDPPayload:
+			port = int(p.SrcPort)
+		case SCMPPayload:
+			port = underlay.EndhostPort
+		default:
+			// we fallback to the endhost port also for unknown payloads
+			port = underlay.EndhostPort
+		}
+		return &net.UDPAddr{
+			IP:   p.Source.Host.IP().AsSlice(),
+			Port: port,
+		}, nil
+	case onehop.PathType:
+		var path onehop.Path
+		err := path.DecodeFromBytes(rpath.Raw)
+		if err != nil {
+			return nil, err
+		}
+		ifid := path.SecondHop.ConsIngress
+		if !path.Info.ConsDir {
+			ifid = path.SecondHop.ConsEgress
+		}
+		return c.getLastHopAddr(ifid)
+	case epic.PathType:
+		var path epic.Path
+		err := path.DecodeFromBytes(rpath.Raw)
+		if err != nil {
+			return nil, err
+		}
+		infoField, err := path.ScionPath.GetCurrentInfoField()
+		if err != nil {
+			return nil, err
+		}
+		hf, err := path.ScionPath.GetCurrentHopField()
+		if err != nil {
+			return nil, err
+		}
+		ifid := hf.ConsIngress
+		if !infoField.ConsDir {
+			ifid = hf.ConsEgress
+		}
+		return c.getLastHopAddr(ifid)
+	case scion.PathType:
+		var path scion.Raw
+		err := path.DecodeFromBytes(rpath.Raw)
+		if err != nil {
+			return nil, err
+		}
+		infoField, err := path.GetCurrentInfoField()
+		if err != nil {
+			return nil, err
+		}
+		hf, err := path.GetCurrentHopField()
+		if err != nil {
+			return nil, err
+		}
+		ifid := hf.ConsIngress
+		if !infoField.ConsDir {
+			ifid = hf.ConsEgress
+		}
+		return c.getLastHopAddr(ifid)
+	default:
+		return nil, serrors.New("Unknown type", "type", rpath.PathType.String())
+	}
+}

pkg/snet/snet.go

@@ -51,6 +51,7 @@ import (
 // Controller provides local-IA control-plane information
 type Controller interface {
 	PortRange(ctx context.Context) (uint16, uint16, error)
+	Interfaces(ctx context.Context) (map[uint16]*net.UDPAddr, error)
 }
 
 type Connector interface {
@@ -75,7 +76,10 @@ func (d *DefaultConnector) OpenUDP(ctx context.Context, addr *net.UDPAddr) (Pack
 	if err != nil {
 		return nil, err
 	}
-	log.Debug("OpenUDP", "addr", addr)
+	ifAddrs, err := d.Controller.Interfaces(ctx)
+	if err != nil {
+		return nil, err
+	}
 	if addr.Port == 0 {
 		pconn, err = listenUDPRange(addr, start, end)
 	} else {
@@ -94,6 +98,13 @@ func (d *DefaultConnector) OpenUDP(ctx context.Context, addr *net.UDPAddr) (Pack
 		Conn:        pconn,
 		SCMPHandler: d.SCMPHandler,
 		Metrics:     d.Metrics,
+		getLastHopAddr: func(id uint16) (*net.UDPAddr, error) {
+			addr, ok := ifAddrs[id]
+			if !ok {
+				return nil, serrors.New("Interface number not found", "if", id)
+			}
+			return addr, nil
+		},
 	}, nil
 }