Merge branch 'master' into master

Author: N2D4

lib/shttp/transport.go

@@ -19,15 +19,19 @@ package shttp
 
 import (
 	"crypto/tls"
+	"errors"
+	"fmt"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
+	"strings"
 	"sync"
 
 	"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/addr"
 	"github.com/scionproto/scion/go/lib/snet"
 	// "github.com/scionproto/scion/go/lib/snet/squic"
 )
@@ -91,9 +95,20 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 		return nil, initErr
 	}
 
+	// If req.URL.Host is a SCION address, we need to mangle it so it passes through
+	// h2quic without tripping up.
+	raddr, err := snet.AddrFromString(req.URL.Host)
+	if err == nil {
+		tmp := *req
+		tmp.URL = new(url.URL)
+		*tmp.URL = *req.URL
+		tmp.URL.Host = mangleSCIONAddr(raddr)
+		req = &tmp
+	}
+
 	// set the dial function and QuicConfig once for each Transport
 	t.dialOnce.Do(func() {
-		dial := func(network, addr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.Session, error) {
+		dial := func(network, addrStr string, tlsCfg *tls.Config, cfg *quic.Config) (quic.Session, error) {
 
 			/* TODO(chaehni):
 			RequestConnectionIDOmission MUST not be set to 'true' when a connection is dialed using an existing net.PacketConn
@@ -105,20 +120,28 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 			*/
 			cfg.RequestConnectionIDOmission = false
 
-			host, port, err := net.SplitHostPort(addr)
+			host, port, err := net.SplitHostPort(addrStr)
 			if err != nil {
 				return nil, err
 			}
-			ia, l3, err := scionutil.GetHostByName(host)
+
+			var ia addr.IA
+			var l3 addr.HostAddr
+			if isMangledSCIONAddr(host) {
+				ia, l3, err = unmangleSCIONAddr(host)
+			} else {
+				ia, l3, err = scionutil.GetHostByName(host)
+			}
 			if err != nil {
 				return nil, err
 			}
 			p, err := strconv.ParseUint(port, 10, 16)
 			if err != nil {
 				p = 443
 			}
-			l4 := libaddr.NewL4UDPInfo(uint16(p))
-			raddr := &snet.Addr{IA: ia, Host: &libaddr.AppAddr{L3: l3, L4: l4}}
+			l4 := addr.NewL4UDPInfo(uint16(p))
+			raddr := &snet.Addr{IA: ia, Host: &addr.AppAddr{L3: l3, L4: l4}}
+
 			return t.squicDialSCION(nil, t.LAddr, raddr, cfg)
 		}
 		t.rt = &h2quic.RoundTripper{
@@ -131,6 +154,48 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 	return t.rt.RoundTripOpt(req, opt)
 }
 
+// mangleSCIONAddr encodes the given SCION address so that it can be safely
+// used in the host part of a URL.
+func mangleSCIONAddr(raddr *snet.Addr) string {
+
+	// The HostAddr will be either IPv4 or IPv6 (not a HostSVC-addr).
+	// To make this a valid host string for a URL, replace : for IPv6 addresses by ~. There will
+	// not be any other tildes, so no need to escape them.
+	l3 := raddr.Host.L3.String()
+	l3_mangled := strings.Replace(l3, ":", "~", -1)
+
+	u := fmt.Sprintf("__%s__%s__", raddr.IA.FileFmt(false), l3_mangled)
+	if raddr.Host.L4 != nil {
+		u += fmt.Sprintf(":%d", raddr.Host.L4.Port())
+	}
+	return u
+}
+
+// isMangledSCIONAddr checks if this is an address previously encoded with mangleSCIONAddr
+// without port, *after* SplitHostPort has been applied.
+func isMangledSCIONAddr(host string) bool {
+
+	parts := strings.Split(host, "__")
+	return len(parts) == 4 && len(parts[0]) == 0 && len(parts[3]) == 0
+}
+
+// unmangleSCIONAddr decodes and parses a SCION-address previously encoded with mangleSCIONAddr
+// without port, i.e. *after* SplitHostPort has been applied.
+func unmangleSCIONAddr(host string) (addr.IA, addr.HostAddr, error) {
+
+	parts := strings.Split(host, "__")
+	ia, err := addr.IAFromFileFmt(parts[1], false)
+	if err != nil {
+		return addr.IA{}, nil, err
+	}
+	l3_str := strings.Replace(parts[2], "~", ":", -1)
+	l3 := addr.HostFromIPStr(l3_str)
+	if l3 == nil {
+		return addr.IA{}, nil, errors.New("Could not parse IP in SCION-address")
+	}
+	return ia, l3, nil
+}
+
 // Close closes the QUIC connections that this RoundTripper has used
 func (t *Transport) Close() error {
 	err := t.rt.Close()

webapp/lib/bwcont.go

@@ -141,11 +141,16 @@ func GetBwByTimeHandler(w http.ResponseWriter, r *http.Request, active bool, src
 	since := r.PostFormValue("since")
 	log.Info("Requesting data since", "timestamp", since)
 	// find undisplayed test results
-	bwTestResults := model.ReadBwTestItemsSince(since)
+	bwTestResults, err := model.ReadBwTestItemsSince(since)
+	if CheckError(err) {
+		returnError(w, err)
+		return
+	}
 	log.Debug("Requested data:", "bwTestResults", bwTestResults)
 
 	bwtestsJSON, err := json.Marshal(bwTestResults)
 	if CheckError(err) {
+		returnError(w, err)
 		return
 	}
 	jsonBuf := []byte(`{ "graph": ` + string(bwtestsJSON))

webapp/lib/sciond.go

@@ -38,6 +38,22 @@ func returnError(w http.ResponseWriter, err error) {
 	fmt.Fprintf(w, `{"err":`+strconv.Quote(err.Error())+`}`)
 }
 
+func returnPathHandler(w http.ResponseWriter, pathJson []byte, segJson []byte, err error) {
+	var buffer bytes.Buffer
+	buffer.WriteString(`{"src":"sciond"`)
+	if pathJson != nil {
+		buffer.WriteString(fmt.Sprintf(`,"paths":%s`, pathJson))
+	}
+	if segJson != nil {
+		buffer.WriteString(fmt.Sprintf(`,"segments":%s`, segJson))
+	}
+	if err != nil {
+		buffer.WriteString(fmt.Sprintf(`,"err":%s`, strconv.Quote(err.Error())))
+	}
+	buffer.WriteString(`}`)
+	fmt.Fprintf(w, buffer.String())
+}
+
 // sciond data sources and calls
 
 // PathTopoHandler handles requests for paths, returning results from sciond.
@@ -78,34 +94,55 @@ func PathTopoHandler(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	paths := getPaths(*clientCCAddr, *serverCCAddr)
-	if len(paths) == 0 {
-		returnError(w, fmt.Errorf("No paths from %s to %s", clientCCAddr.IA,
-			serverCCAddr.IA))
+	paths, err := getPathsJSON(*clientCCAddr, *serverCCAddr)
+	if CheckError(err) {
+		returnError(w, err)
+		return
+	}
+	log.Debug("PathTopoHandler:", "paths", string(paths))
+
+	// Since segments data is supplimentary to paths data, if segments data
+	// fails, provide the error, but we must still allow paths data to return.
+	segments, err := getSegmentsJSON(*clientCCAddr)
+	if CheckError(err) {
+		returnPathHandler(w, paths, nil, err)
 		return
 	}
+	log.Debug("PathTopoHandler:", "segments", string(segments))
 
-	jsonPathInfo, _ := json.Marshal(paths)
-	log.Debug("PathTopoHandler:", "jsonPathInfo", string(jsonPathInfo))
+	returnPathHandler(w, paths, segments, err)
+}
 
+func getSegmentsJSON(local snet.Addr) ([]byte, error) {
 	// load segments from paths database
-	var dbSrcFile = findDBFilename(clientCCAddr.IA)
-	dbTmpFile := copyDBToTemp(dbSrcFile)
+	var dbSrcFile = findDBFilename(local.IA)
+	dbTmpFile, err := copyDBToTemp(dbSrcFile)
+	if err != nil {
+		return nil, err
+	}
 	// since http.ListenAndServe() blocks, ensure we generate a local db object
 	// which will live only during the http call
-	db := pathdb.InitDB(dbTmpFile)
+	db, err := pathdb.InitDB(dbTmpFile)
+	if err != nil {
+		return nil, err
+	}
 	defer func() {
 		pathdb.CloseDB(db)
 		removeAllDir(filepath.Dir(dbTmpFile))
 	}()
-	segTypes := pathdb.ReadSegTypesAll(db)
-	segments := pathdb.ReadSegmentsAll(db, segTypes)
-
-	jsonSegsInfo, _ := json.Marshal(segments)
-	log.Debug("PathTopoHandler:", "jsonSegsInfo", string(jsonSegsInfo))
-
-	fmt.Fprintf(w, fmt.Sprintf(`{"paths":%s,"segments":%s}`,
-		jsonPathInfo, jsonSegsInfo))
+	segTypes, err := pathdb.ReadSegTypesAll(db)
+	if err != nil {
+		return nil, err
+	}
+	segments, err := pathdb.ReadSegmentsAll(db, segTypes)
+	if err != nil {
+		return nil, err
+	}
+	jsonSegsInfo, err := json.Marshal(segments)
+	if err != nil {
+		return nil, err
+	}
+	return jsonSegsInfo, nil
 }
 
 func findDBFilename(ia addr.IA) string {
@@ -120,52 +157,60 @@ func findDBFilename(ia addr.IA) string {
 }
 
 // returns the name of the created file
-func copyDBToTemp(filename string) string {
+func copyDBToTemp(filename string) (string, error) {
 	copyOneFile := func(dstDir, srcFileName string) error {
 		src, err := os.Open(srcFileName)
-		if CheckError(err) {
-			return fmt.Errorf("Cannot open %s: %v", srcFileName, err)
+		if err != nil {
+			return err
 		}
 		defer src.Close()
 		dstFilename := filepath.Join(dstDir, filepath.Base(srcFileName))
 		dst, err := os.Create(dstFilename)
-		if CheckError(err) {
-			return fmt.Errorf("Cannot open %s: %v", dstFilename, err)
+		if err != nil {
+			return err
 		}
 		defer dst.Close()
 		_, err = io.Copy(dst, src)
-		if CheckError(err) {
-			return fmt.Errorf("Cannot copy %s to %s: %v", srcFileName, dstFilename, err.Error())
+		if err != nil {
+			return err
 		}
 		return nil
 	}
 	dirName, err := ioutil.TempDir("/tmp", "sciond_dump")
-	if CheckError(err) {
-		return err.Error()
+	if err != nil {
+		return "", err
 	}
-
 	err = copyOneFile(dirName, filename)
-	if CheckError(err) {
-		fmt.Fprintf(os.Stderr, "No panic: %v", err)
+	if err != nil {
+		return "", err
 	}
 	err = copyOneFile(dirName, filename+"-wal")
-	CheckError(err)
-	return filepath.Join(dirName, filepath.Base(filename))
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dirName, filepath.Base(filename)), nil
 }
 
 func removeAllDir(dirName string) {
 	err := os.RemoveAll(dirName)
 	CheckError(err)
 }
 
-func getPaths(local snet.Addr, remote snet.Addr) []*spathmeta.AppPath {
+func getPathsJSON(local snet.Addr, remote snet.Addr) ([]byte, error) {
 	pathMgr := snet.DefNetwork.PathResolver()
 	pathSet := pathMgr.Query(context.Background(), local.IA, remote.IA)
+	if len(pathSet) == 0 {
+		return nil, fmt.Errorf("No paths from %s to %s", local.IA, remote.IA)
+	}
 	var appPaths []*spathmeta.AppPath
 	for _, path := range pathSet {
 		appPaths = append(appPaths, path)
 	}
-	return appPaths
+	jsonPathInfo, err := json.Marshal(appPaths)
+	if err != nil {
+		return nil, err
+	}
+	return jsonPathInfo, nil
 }
 
 // AsTopoHandler handles requests for AS data, returning results from sciond.