skip: update proxy to the last version of the extension (#242)

* Add first tries to collect path statistics in skip

* fix bug broken SingleStream:

- We cast quic.session to *pan.QUICSession on the dialing side
so that applications as the scion-skip can extract path information
from the quic stream. This is not needed or intended, at the moment,
for the listening side, which breaks down if do not pass a *pan.QUICSession
object.

* updating path usage info

* treat nil

* lint

* pass

* lint

* lint

* pass

---------

Co-authored-by: Marten Gartner <[email protected]>

Author: JordiSubira

pkg/pan/policy.go

@@ -118,6 +118,10 @@ func (s Sequence) Filter(paths []*Path) []*Path {
 	return ps
 }
 
+func (s Sequence) String() string {
+	return s.sequence.String()
+}
+
 // ACL is a policy filtering paths matching an ACL pattern. The ACL pattern is
 // an ordered list of allow/deny actions over hop predicates.
 // See https://scion.docs.anapaya.net/en/latest/PathPolicy.html#acl.

pkg/pan/udp_dial.go

@@ -33,6 +33,8 @@ type Conn interface {
 	// ReadVia reads a message and returns the (return-)path via which the
 	// message was received.
 	ReadVia(b []byte) (int, *Path, error)
+
+	GetPath() *Path
 }
 
 // DialUDP opens a SCION/UDP socket, connected to the remote address.
@@ -96,6 +98,10 @@ func (c *dialedConn) LocalAddr() net.Addr {
 	return c.local
 }
 
+func (c *dialedConn) GetPath() *Path {
+	return c.selector.Path()
+}
+
 func (c *dialedConn) RemoteAddr() net.Addr {
 	return c.remote
 }

pkg/quicutil/single.go

@@ -23,6 +23,8 @@ import (
 	"time"
 
 	"github.com/quic-go/quic-go"
+
+	"github.com/netsec-ethz/scion-apps/pkg/pan"
 )
 
 var (
@@ -54,48 +56,63 @@ type SingleStreamListener struct {
 
 func (l SingleStreamListener) Accept() (net.Conn, error) {
 	ctx := context.Background()
-	session, err := l.Listener.Accept(ctx)
+	connection, err := l.Listener.Accept(ctx)
 	if err != nil {
 		return nil, err
 	}
-	return NewSingleStream(session)
+	return NewSingleStream(connection)
 }
 
 // SingleStream implements an opaque, bi-directional data stream using QUIC,
 // intending to be a drop-in replacement for TCP.
 // A SingleStream is either created by
 //
 //   - on the client side: quic.Dial and then immediately NewSingleStream(sess)
-//     with the obtained session
+//     with the obtained connection
 //   - on the listener side: quic.Listener wrapped in SingleStreamListener, which
 //     returns SingleStream from Accept.
 type SingleStream struct {
-	Session       quic.Connection
+	Connection    quic.Connection
 	sendStream    quic.SendStream
 	receiveStream quic.ReceiveStream
 	readDeadline  time.Time
 	mutex         sync.Mutex // mutex protects receiveStream for await
 	onceOK        sync.Once
 }
 
-func NewSingleStream(session quic.Connection) (*SingleStream, error) {
-	sendStream, err := session.OpenUniStream()
+func NewSingleStream(connection quic.Connection) (*SingleStream, error) {
+	sendStream, err := connection.OpenUniStream()
 	if err != nil {
 		return nil, err
 	}
 	return &SingleStream{
-		Session:       session,
+		Connection:    connection,
 		sendStream:    sendStream,
 		receiveStream: nil,
 	}, nil
 }
 
 func (s *SingleStream) LocalAddr() net.Addr {
-	return s.Session.LocalAddr()
+	return s.Connection.LocalAddr()
+}
+
+func (s *SingleStream) GetPath() *pan.Path {
+	if s.Connection == nil {
+		// XXX(JordiSubira): To be refactored when proper support
+		// for retrieving path information.
+		return nil
+	}
+	quicSession, ok := s.Connection.(*pan.QUICSession)
+	if !ok {
+		// XXX(JordiSubira): To be refactored when proper support
+		// for retrieving path information.
+		return nil
+	}
+	return quicSession.Conn.GetPath()
 }
 
 func (s *SingleStream) RemoteAddr() net.Addr {
-	return s.Session.RemoteAddr()
+	return s.Connection.RemoteAddr()
 }
 
 func (s *SingleStream) SetDeadline(t time.Time) error {
@@ -148,7 +165,7 @@ func (s *SingleStream) awaitReceiveStream() error {
 			ctx, cancel = context.WithDeadline(ctx, s.readDeadline)
 			defer cancel()
 		}
-		stream, err := s.Session.AcceptUniStream(ctx)
+		stream, err := s.Connection.AcceptUniStream(ctx)
 		if err != nil {
 			return err
 		}
@@ -162,7 +179,7 @@ func (s *SingleStream) awaitReceiveStream() error {
 
 func (s *SingleStream) sendOKSignal() {
 	s.onceOK.Do(func() {
-		okSignal, err := s.Session.OpenUniStream()
+		okSignal, err := s.Connection.OpenUniStream()
 		if err != nil {
 			return // otherwise ignore error here, what could we do?
 		}
@@ -175,14 +192,14 @@ func (s *SingleStream) awaitOKSignal(ctx context.Context) error {
 	defer s.mutex.Unlock()
 	// ensure we've accepted the actual receive stream first.
 	if s.receiveStream == nil {
-		stream, err := s.Session.AcceptUniStream(ctx)
+		stream, err := s.Connection.AcceptUniStream(ctx)
 		if err != nil {
 			return err
 		}
 		s.receiveStream = stream
 	}
 
-	_, err := s.Session.AcceptUniStream(ctx)
+	_, err := s.Connection.AcceptUniStream(ctx)
 	// We can ignore data arriving in on this stream -- we expect
 	// a single FIN, so a readeading will immediately give EOF.
 	// If that's not what we get, guess we can ignore it.
@@ -220,9 +237,9 @@ func (s *SingleStream) CloseSync(ctx context.Context) error {
 	_ = s.CloseRead()
 	// Await the OK-signal
 	if err := s.awaitOKSignal(ctx); err != nil {
-		return s.Session.CloseWithError(0x101, "shutdown error")
+		return s.Connection.CloseWithError(0x101, "shutdown error")
 	}
-	return s.Session.CloseWithError(0x0, "ok")
+	return s.Connection.CloseWithError(0x0, "ok")
 }
 
 func (s *SingleStream) Close() error {