netcat: convert to pan

Add path policy options to command line.

Use quicutils.SingleStream, making this incompatible with previous
versions.
Removed the long list of supported protocols in netcat again -- that was
a bit of a brain fart. The delicate handling of the quic streams is
enough of a protocol to warrant having a dedicated identifier.

Updated netcat QUIC integration tests (dont need the -b now, as both
peers can now start transmitting first).

Only tangentially related, fix concurrent Read/Close in the
udpListenConn.

Author: matzf

netcat/main.go

@@ -22,8 +22,11 @@ import (
 	"os"
 	"os/exec"
 	"strconv"
+	"strings"
 	"sync"
 	"time"
+
+	"github.com/netsec-ethz/scion-apps/pkg/pan"
 )
 
 var (
@@ -40,6 +43,10 @@ var (
 	commandString string
 
 	verboseMode bool
+
+	interactive bool
+	sequence    string
+	preference  string
 )
 
 func printUsage() {
@@ -73,6 +80,11 @@ func main() {
 	flag.BoolVar(&shutdownAfterEOF, "N", false, "Shutdown the network socket after EOF on the input.")
 	flag.DurationVar(&shutdownAfterEOFTimeout, "q", 0, "After EOF on stdin, wait the specified number of seconds and then quit. Implies -N.")
 	flag.StringVar(&commandString, "c", "", "Command")
+	flag.BoolVar(&interactive, "interactive", false, "Prompt user for interactive path selection")
+	flag.StringVar(&sequence, "sequence", "", "Sequence of space separated hop predicates to specify path")
+	flag.StringVar(&preference, "preference", "", "Preference sorting order for paths. "+
+		"Comma-separated list of available sorting options: "+
+		strings.Join(pan.AvailablePreferencePolicies, "|"))
 	flag.BoolVar(&verboseMode, "v", false, "Verbose mode")
 	flag.Parse()
 
@@ -115,7 +127,11 @@ func main() {
 		}
 	} else {
 		remoteAddr := tail[0]
-		conn, err := doDial(remoteAddr)
+		policy, err := pan.PolicyFromCommandline(sequence, preference, interactive)
+		if err != nil {
+			log.Fatal(err)
+		}
+		conn, err := doDial(remoteAddr, policy)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -235,13 +251,13 @@ func pipeConn(conn io.ReadWriteCloser) {
 	logDebug("Connection closed", "conn", conn)
 }
 
-func doDial(remoteAddr string) (io.ReadWriteCloser, error) {
+func doDial(remoteAddr string, policy pan.Policy) (io.ReadWriteCloser, error) {
 	var conn io.ReadWriteCloser
 	var err error
 	if udpMode {
-		conn, err = DoDialUDP(remoteAddr)
+		conn, err = DoDialUDP(remoteAddr, policy)
 	} else {
-		conn, err = DoDialQUIC(remoteAddr)
+		conn, err = DoDialQUIC(remoteAddr, policy)
 	}
 	if err != nil {
 		return nil, err

netcat/netcat_integration_test.go

@@ -54,22 +54,22 @@ func TestIntegrationScionNetcatCmd(t *testing.T) {
 		{
 			name:    "UDP",
 			message: "Hello UDP World!",
-			flags:   []string{"-u"},
+			flags:   []string{"-b", "-u", "-q", "50ms"},
+			// NOTE: we need -b as the client does not otherwise send any data to make the "query"
 		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			serverPort := "1234"
 			serverArgs := concat(
 				tc.flags,
-				[]string{"-b", "-K", "-c", "echo " + tc.message, "-l", serverPort},
+				[]string{"-N", "-K", "-c", "echo " + tc.message, "-l", serverPort},
 			)
-			// NOTE: we need -b as the client does not otherwise send any data to make the "query"
 			// BUG: should also work with -k, but doesn't (!?)
 
 			clientScriptArgs := concat(
 				tc.flags,
-				[]string{"-b", "-q", "10ms", integration.DstAddrPattern + ":" + serverPort},
+				[]string{integration.DstAddrPattern + ":" + serverPort},
 			)
 			in := integration.NewAppsIntegration(netcatCmd, netcatCmd, clientScriptArgs, serverArgs)
 			in.ClientDelay = 250 * time.Millisecond

netcat/quic.go

@@ -20,120 +20,62 @@ import (
 	"io"
 
 	"github.com/lucas-clemente/quic-go"
-	"github.com/netsec-ethz/scion-apps/pkg/appnet/appquic"
+	"inet.af/netaddr"
+
+	"github.com/netsec-ethz/scion-apps/pkg/pan"
+	"github.com/netsec-ethz/scion-apps/pkg/quicutil"
 )
 
 var (
-	nextProtos = []string{
-		// generic "proto" that we use e.g. for HTTP-over-QUIC
-		"raw",
-		// we accept anything -- use full list of protocol IDs from
-		// https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
-		"http/0.9",
-		"http/1.0",
-		"http/1.1",
-		"spdy/1",
-		"spdy/2",
-		"spdy/3",
-		"stun.turn",
-		"stun.nat-discovery",
-		"h2",
-		"h2c",
-		"webrtc",
-		"c-webrtc",
-		"ftp",
-		"imap",
-		"pop3",
-		"managesieve",
-		"coap",
-		"xmpp-client",
-		"xmpp-server",
-		"acme-tls/1",
-		"mqtt",
-		"dot",
-		"ntske/1",
-		"sunrpc",
-		"h3",
-		"smb",
-		"irc",
-		"nntp",
-		"nnsp",
-	}
+	nextProtos = []string{quicutil.SingleStreamProto}
 )
 
-type sessConn struct {
-	sess   quic.Session
-	stream quic.Stream
-}
-
-func (conn *sessConn) Read(b []byte) (n int, err error) {
-	return conn.stream.Read(b)
-}
-
-func (conn *sessConn) Write(b []byte) (n int, err error) {
-	return conn.stream.Write(b)
-}
-
-func (conn *sessConn) CloseWrite() error {
-	return conn.stream.Close()
-}
-
-func (conn *sessConn) Close() error {
-	err := conn.stream.Close()
-	if err != nil {
-		return err
-	}
-
-	err = conn.sess.CloseWithError(quic.ApplicationErrorCode(0), "")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 // DoListenQUIC listens on a QUIC socket
 func DoListenQUIC(port uint16) (chan io.ReadWriteCloser, error) {
-	listener, err := appquic.ListenPort(
-		port,
+	quicListener, err := pan.ListenQUIC(
+		context.Background(),
+		netaddr.IPPortFrom(netaddr.IP{}, port),
+		nil,
 		&tls.Config{
-			Certificates: appquic.GetDummyTLSCerts(),
+			Certificates: quicutil.MustGenerateSelfSignedCert(),
 			NextProtos:   nextProtos,
 		},
 		&quic.Config{KeepAlive: true},
 	)
 	if err != nil {
 		return nil, err
 	}
+	listener := quicutil.SingleStreamListener{Listener: quicListener}
 
 	conns := make(chan io.ReadWriteCloser)
 	go func() {
-		for {
-			sess, err := listener.Accept(context.Background())
-			if err != nil {
-				logError("Can't accept listener", "err", err)
-				continue
-			}
 
-			stream, err := sess.AcceptStream(context.Background())
+		for {
+			conn, err := listener.Accept()
 			if err != nil {
-				logError("Can't accept stream", "err", err)
+				logError("Can't accept", "err", err)
 				continue
 			}
-
-			conns <- &sessConn{
-				sess:   sess,
-				stream: stream,
-			}
+			conns <- conn
 		}
 	}()
 
 	return conns, nil
 }
 
 // DoDialQUIC dials with a QUIC socket
-func DoDialQUIC(remoteAddr string) (io.ReadWriteCloser, error) {
-	sess, err := appquic.Dial(
+func DoDialQUIC(remote string, policy pan.Policy) (io.ReadWriteCloser, error) {
+	remoteAddr, err := pan.ResolveUDPAddr(remote)
+	if err != nil {
+		return nil, err
+	}
+	sess, err := pan.DialQUIC(
+		context.Background(),
+		netaddr.IPPort{},
 		remoteAddr,
+		policy,
+		nil,
+		pan.MangleSCIONAddr(remote),
 		&tls.Config{
 			InsecureSkipVerify: true,
 			NextProtos:         nextProtos,
@@ -144,13 +86,5 @@ func DoDialQUIC(remoteAddr string) (io.ReadWriteCloser, error) {
 		return nil, err
 	}
 
-	stream, err := sess.OpenStreamSync(context.Background())
-	if err != nil {
-		return nil, err
-	}
-
-	return &sessConn{
-		sess:   sess,
-		stream: stream,
-	}, nil
+	return quicutil.NewSingleStream(sess)
 }

netcat/udp.go

@@ -15,21 +15,30 @@
 package main
 
 import (
+	"context"
 	"io"
+	"sync"
 
-	"github.com/netsec-ethz/scion-apps/pkg/appnet"
+	"inet.af/netaddr"
+
+	"github.com/netsec-ethz/scion-apps/pkg/pan"
 )
 
-// May not be accessed from multiple threads concurrently, especially Read(...) and Close(...)
 type udpListenConn struct {
 	requests  chan<- []byte
 	responses <-chan int
-	isClosed  bool
+	mutex     sync.Mutex // protects Read's requests/responses channel from concurrent Close
 	write     func(b []byte) (int, error)
 	close     func() error
 }
 
 func (conn *udpListenConn) Read(b []byte) (int, error) {
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
+
+	if conn.requests == nil {
+		return 0, io.EOF
+	}
 	conn.requests <- b
 	return <-conn.responses, nil
 }
@@ -39,17 +48,32 @@ func (conn *udpListenConn) Write(b []byte) (int, error) {
 }
 
 func (conn *udpListenConn) Close() error {
+	conn.mutex.Lock()
+	defer conn.mutex.Unlock()
 	return conn.close()
 }
 
 // DoDialUDP dials with a UDP socket
-func DoDialUDP(remote string) (io.ReadWriteCloser, error) {
-	return appnet.Dial(remote)
+func DoDialUDP(remote string, policy pan.Policy) (io.ReadWriteCloser, error) {
+	remoteAddr, err := pan.ResolveUDPAddr(remote)
+	if err != nil {
+		return nil, err
+	}
+	conn, err := pan.DialUDP(context.Background(), netaddr.IPPort{}, remoteAddr, policy, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return conn, nil
 }
 
 // DoListenUDP listens on a UDP socket
 func DoListenUDP(port uint16) (chan io.ReadWriteCloser, error) {
-	conn, err := appnet.ListenPort(port)
+	conn, err := pan.ListenUDP(
+		context.Background(),
+		netaddr.IPPortFrom(netaddr.IP{}, port),
+		nil,
+	)
 	if err != nil {
 		return nil, err
 	}
@@ -84,7 +108,6 @@ func DoListenUDP(port uint16) (chan io.ReadWriteCloser, error) {
 				conns <- &udpListenConn{
 					requests:  nbufChan,
 					responses: nrespChan,
-					isClosed:  false,
 					write: func(b []byte) (n int, err error) {
 						return conn.WriteTo(b, addr)
 					},