main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net"
	"net/netip"
	"os"
	"time"

	"github.com/scionproto/scion/pkg/addr"
	"github.com/scionproto/scion/pkg/daemon"
	"github.com/scionproto/scion/pkg/snet"
	"github.com/scionproto/scion/pkg/snet/addrutil"
	"github.com/scionproto/scion/pkg/snet/path"
	"github.com/scionproto/scion/private/topology/underlay"
)

var targets = []string{
	"64-2:0:9c,fd00::0034:0084:ffff:0000",
	"64-2:0:9c,fd00::0034:0085:ffff:0000",
	"64-2:0:9c,fd00::0035:0084:ffff:0000",
	"64-2:0:9c,fd00::0035:0085:ffff:0000",
}

func main() {
	var (
		scionDaemon string
		connTimeout time.Duration
	)

	flag.StringVar(&scionDaemon, "sd", "", "SCION daemon API address")
	flag.DurationVar(&connTimeout, "timeout", 5*time.Second, "timeout used for SCION daemon calls")
	flag.Parse()

	if scionDaemon == "" {
		if sd, ok := os.LookupEnv("SCION_DAEMON_ADDRESS"); ok {
			scionDaemon = sd
		} else {
			scionDaemon = daemon.DefaultAPIAddress
		}
	}

	ctx, cancel := context.WithTimeout(context.Background(), connTimeout)
	defer cancel()

	scionD, err := daemon.NewService(scionDaemon).Connect(ctx)
	if err != nil {
		log.Fatalf("unable to connect to SCIOND at %s: %v", scionDaemon, err)
	}

	localIA, err := scionD.LocalIA(ctx)
	if err != nil {
		log.Fatalf("could not determine local IA: %v", err)
	}

	firstDst, err := addr.ParseAddr(targets[0])
	if err != nil {
		log.Fatalf("invalid destination %q: %v", targets[0], err)
	}

	flags := daemon.PathReqFlags{Refresh: false, Hidden: false}
	snetPaths, err := scionD.Paths(ctx, firstDst.IA, 0, flags)
	if err != nil {
		log.Fatalf("unable to query paths for %s: %v", firstDst.IA, err)
	}
	if len(snetPaths) == 0 {
		log.Fatalf("no path available to destination IA %s", firstDst.IA)
	}

	localIP, err := addrutil.ResolveLocal(snetPaths[0].UnderlayNextHop().IP)
	if err != nil {
		log.Fatalf("failed to resolve local underlay IP: %v", err)
	}

	sn := snet.SCIONNetwork{Topology: scionD, SCMPHandler: scmpHandler{}}
	conn, err := sn.OpenRaw(context.Background(), &net.UDPAddr{IP: localIP, Port: 0})
	if err != nil {
		log.Fatalf("failed to open raw SCION socket: %v", err)
	}
	defer conn.Close()

	asNetipAddr, ok := netip.AddrFromSlice(conn.LocalAddr().(*net.UDPAddr).IP)
	if !ok {
		log.Fatalf("invalid local IP address from socket: %v", conn.LocalAddr())
	}
	local := addr.Addr{
		IA:   localIA,
		Host: addr.HostIP(asNetipAddr),
	}

	id := uint16(conn.LocalAddr().(*net.UDPAddr).Port)
	seq := uint16(0)

	for _, raw := range targets {
		dst, err := addr.ParseAddr(raw)
		if err != nil {
			log.Printf("skip invalid destination %q: %v", raw, err)
			continue
		}

		p, err := bestPath(context.Background(), scionD, dst.IA)
		if err != nil {
			log.Printf("path lookup failed for %s: %v", dst, err)
			continue
		}

		err = sendEcho(dst, p.Dataplane(), p.UnderlayNextHop(), id, seq, local, conn)
		if err != nil {
			log.Printf("send failed to %s: %v", dst, err)
			continue
		}
		log.Printf("sent echo to %s (seq=%d)", dst, seq)
		seq++
	}
}

func bestPath(ctx context.Context, scionD daemon.Connector, dstIA addr.IA) (snet.Path, error) {
	flags := daemon.PathReqFlags{Refresh: false, Hidden: false}
	paths, err := scionD.Paths(ctx, dstIA, 0, flags)
	if err != nil {
		return nil, err
	}
	if len(paths) == 0 {
		return nil, fmt.Errorf("no path to %s", dstIA)
	}
	return paths[0], nil
}

func sendEcho(
	remote addr.Addr,
	dPath snet.DataplanePath,
	nextHop *net.UDPAddr,
	id uint16,
	seq uint16,
	local addr.Addr,
	conn snet.PacketConn,
) error {
	_, isEmpty := dPath.(path.Empty)
	if isEmpty && !local.IA.Equal(remote.IA) {
		return fmt.Errorf("no path for remote ISD-AS: local %s, remote %s", local.IA, remote.IA)
	}

	pkt := &snet.Packet{
		PacketInfo: snet.PacketInfo{
			Destination: remote,
			Source:      local,
			Path:        dPath,
			Payload: snet.SCMPEchoRequest{
				Identifier: id,
				SeqNumber:  seq,
				Payload:    []byte{},
			},
		},
	}

	if nextHop == nil && local.IA.Equal(remote.IA) {
		nextHop = &net.UDPAddr{
			IP:   remote.Host.IP().AsSlice(),
			Port: underlay.EndhostPort,
			Zone: remote.Host.IP().Zone(),
		}
	}
	return conn.WriteTo(pkt, nextHop)
}

type scmpHandler struct{}

func (h scmpHandler) Handle(_ *snet.Packet) error {
	return nil
}