Merge pull request #54 from matzf/shttp-close-conn

shttp: Close connections, scionutil: use "sciondFromIA" logic if no default.sock

Author: matzf

lib/scionutil/initialization.go

@@ -15,14 +15,16 @@
 package scionutil
 
 import (
+	"github.com/scionproto/scion/go/lib/addr"
 	"github.com/scionproto/scion/go/lib/sciond"
 	"github.com/scionproto/scion/go/lib/snet"
+	"os"
 )
 
 // InitSCION initializes the default SCION networking context with the provided SCION address
 // and the default SCIOND/SCION dispatcher
 func InitSCION(localAddr *snet.Addr) error {
-	err := snet.Init(localAddr.IA, GetDefaultSCIOND(), GetDefaultDispatcher())
+	err := snet.Init(localAddr.IA, GetSCIONDPath(&localAddr.IA), GetDefaultDispatcher())
 	if err != nil {
 		return err
 	}
@@ -37,17 +39,23 @@ func InitSCIONString(localAddr string) (*snet.Addr, error) {
 		return nil, err
 	}
 
-	err = snet.Init(addr.IA, GetDefaultSCIOND(), GetDefaultDispatcher())
+	err = snet.Init(addr.IA, GetSCIONDPath(&addr.IA), GetDefaultDispatcher())
 	if err != nil {
 		return nil, err
 	}
 
 	return addr, nil
 }
 
-// GetDefaultSCIOND returns the path to the default SCION socket
-func GetDefaultSCIOND() string {
-	return sciond.GetDefaultSCIONDPath(nil)
+// GetSCIONDPath returns the path to the SCION socket.
+func GetSCIONDPath(ia *addr.IA) string {
+
+	// Use default.sock if exists:
+	if _, err := os.Stat(sciond.DefaultSCIONDPath); err == nil {
+		return sciond.DefaultSCIONDPath
+	}
+	// otherwise, use socket with ia name:
+	return sciond.GetDefaultSCIONDPath(ia)
 }
 
 // GetDefaultDispatcher returns the path to the default SCION dispatcher

lib/shttp/examples/minimal/README.md

@@ -2,18 +2,23 @@ This example application makes two requests from the client to the server.
 
 First, it issues a GET request and downloads an HTML file. Afterwards it sends data to the server via POST.
 
-To run the example, first start the server like this
-```Go
-go run server.go -local 17-ffaa:1:c2,[127.0.0.1]:40002 -cert tls.pem -key tls.key
+To run the example, generate a certificate for the server first, e.g
+```sh
+openssl req -x509 -newkey rsa:1024 -keyout key.pem -nodes -out cert.pem -days 365 -subj '/CN=minimal-server'
+```
+
+Start the server like this
+```sh
+go run server.go -local 17-ffaa:1:c2,[127.0.0.1]:40002 -cert cert.pem -key key.pem
 ```
 
 Then, start the client:
-```Go
+```sh
 go run client.go -local 17-ffaa:1:c2,[127.0.0.1]:0
 ```
 
 For an interactive mode that lets the user choose a path from all available paths add the `-i` flag:
-```Go
+```sh
 go run client.go -local 17-ffaa:1:c2,[127.0.0.1]:0 -i
 ```
 
@@ -22,4 +27,4 @@ Make sure to replace the addresses with your own AS addresses and to set the TLS
 Also, `minimal-server` must resolve to the SCION address on which you run the server. You can add `minimal-server` to your known hosts by adding the following line to `/etc/hosts`. (replace `ISD-AS` and `IP` with your actual address):
 ```
 ISD-AS,[IP] minimal-server
-```
+```

lib/shttp/transport.go

@@ -24,12 +24,17 @@ import (
 	"strconv"
 	"sync"
 
-	quic "github.com/lucas-clemente/quic-go"
+	"github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/h2quic"
 	"github.com/netsec-ethz/scion-apps/lib/scionutil"
 	libaddr "github.com/scionproto/scion/go/lib/addr"
 	"github.com/scionproto/scion/go/lib/snet"
-	"github.com/scionproto/scion/go/lib/snet/squic"
+	// "github.com/scionproto/scion/go/lib/snet/squic"
+)
+
+var (
+	// cliTlsCfg is a copy squic.cliTlsCfg
+	cliTlsCfg = &tls.Config{InsecureSkipVerify: true}
 )
 
 // Transport wraps a h2quic.RoundTripper making it compatible with SCION
@@ -40,7 +45,9 @@ type Transport struct {
 
 	rt *h2quic.RoundTripper
 
-	dialOnce sync.Once
+	dialOnce         sync.Once
+	connectionsMutex sync.Mutex
+	connections      []*snet.Conn
 }
 
 // RoundTrip does a single round trip; retreiving a response for a given request
@@ -49,6 +56,28 @@ func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
 	return t.RoundTripOpt(req, h2quic.RoundTripOpt{})
 }
 
+// squicDialSCION re-implements squic.DialSCION to get access to the underlying
+// snet.Conn to be able to close the connection later.
+func (t *Transport) squicDialSCION(network *snet.SCIONNetwork, laddr, raddr *snet.Addr,
+	quicConfig *quic.Config) (quic.Session, error) {
+
+	// squic.sListen (but without the Bind/SVC)
+	if network == nil {
+		network = snet.DefNetwork
+	}
+	sconn, err := network.ListenSCION("udp4", laddr, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	t.connectionsMutex.Lock()
+	defer t.connectionsMutex.Unlock()
+	t.connections = append(t.connections, &sconn)
+
+	// Use dummy hostname, as it's used for SNI, and we're not doing cert verification.
+	return quic.Dial(sconn, raddr, "host:0", cliTlsCfg, quicConfig)
+}
+
 // RoundTripOpt is the same as RoundTrip but takes additional options
 func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*http.Response, error) {
 
@@ -90,7 +119,7 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 			}
 			l4 := libaddr.NewL4UDPInfo(uint16(p))
 			raddr := &snet.Addr{IA: ia, Host: &libaddr.AppAddr{L3: l3, L4: l4}}
-			return squic.DialSCION(nil, t.LAddr, raddr, cfg)
+			return t.squicDialSCION(nil, t.LAddr, raddr, cfg)
 		}
 		t.rt = &h2quic.RoundTripper{
 			Dial:               dial,
@@ -104,5 +133,15 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 
 // Close closes the QUIC connections that this RoundTripper has used
 func (t *Transport) Close() error {
-	return t.rt.Close()
+	err := t.rt.Close()
+
+	// quic.Session.Close (which is called by RoundTripper.Close()) will NOT
+	// close the underlying connections, so we do it manually here.
+	t.connectionsMutex.Lock()
+	defer t.connectionsMutex.Unlock()
+	for _, sconn := range t.connections {
+		(*sconn).Close()
+	}
+
+	return err
 }