redoing updates (#45)

* redoing updates

* deleted comment

Author: chaehni

bat/bat.go

@@ -57,7 +57,6 @@ var (
 	download         bool
 	insecureSSL      bool
 	local            string // TODO: remove as soon as dispatcher supports nil local address
-	remote           string // TODO: remove as soon as RAINS is deployed
 	auth             string
 	proxy            string
 	printV           string
@@ -88,7 +87,6 @@ func init() {
 	flag.BoolVar(&insecureSSL, "insecure", false, "Allow connections to SSL sites without certs")
 	flag.BoolVar(&insecureSSL, "i", false, "Allow connections to SSL sites without certs")
 	flag.StringVar(&local, "l", "", "local SCION address")
-	flag.StringVar(&remote, "r", "", "remote SCION address")
 	flag.StringVar(&auth, "auth", "", "HTTP authentication username:password, USER[:PASS]")
 	flag.StringVar(&auth, "a", "", "HTTP authentication username:password, USER[:PASS]")
 	flag.StringVar(&proxy, "proxy", "", "Proxy host and port, PROXY_URL")
@@ -123,7 +121,7 @@ func init() {
 	}
 
 	// redirect SCION log to a log file
-	slog.SetupLogFile("scion", "log", "info", 10, 10, 0)
+	slog.SetupLogFile("scion", "log", "debug", 10, 10, 0)
 }
 
 func parsePrintOption(s string) {
@@ -174,8 +172,7 @@ func main() {
 			}
 		}
 	}
-	// TODO: uncomment when RAINS is deployed and remove belows URL creation
-	/* start of URL creation: Remove when RAINS is deployed*/
+	
 	if *URL == "" {
 		usage()
 	}

lib/scionutil/hosts.go

@@ -22,22 +22,32 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/scionproto/scion/go/lib/snet"
+	libaddr "github.com/scionproto/scion/go/lib/addr"
 )
 
+type scionAddress struct {
+	ia libaddr.IA
+	l3 libaddr.HostAddr
+}
+
 var (
 	hostFilePath = "/etc/hosts"
-	addrRegexp   = regexp.MustCompile(`\d{1,4}-([0-9a-f]{1,4}:){2}[0-9a-f]{1,4},\[[^]]+\]`)
-	hosts        map[string]string   // hostname -> SCION address
-	revHosts     map[string][]string // SCION address w/o port -> hostnames
+	addrRegexp   = regexp.MustCompile(`^(?P<ia>\d+-[\d:A-Fa-f]+),\[(?P<host>[^\]]+)\]`)
+	hosts        map[string]scionAddress // hostname -> scionAddress
+	revHosts     map[string][]string     // SCION address w/o port -> hostnames
+)
+
+const (
+	iaIndex = iota + 1
+	l3Index
 )
 
 func init() {
 	hostsFile, err := readHostsFile()
 	if err != nil {
 		hostsFile = []byte{}
 	}
-	err = parseHostsFile(hostsFile)
+	parseHostsFile(hostsFile)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -50,28 +60,23 @@ func AddHost(hostname, address string) error {
 	if addrs, ok := hosts[hostname]; ok {
 		return fmt.Errorf("Host %q already exists, address(es): %v", hostname, addrs)
 	}
-	_, err := snet.AddrFromString(fmt.Sprintf("%s:%s", address, "0"))
+	addr, err := addrFromString(address)
 	if err != nil {
 		return fmt.Errorf("Cannot add host %q: %v", hostname, err)
 	}
-	hosts[hostname] = address
+	hosts[hostname] = addr
 	revHosts[address] = append(revHosts[address], hostname)
 
 	return nil
 }
 
-// GetHostByName returns the SCION address corresponding to hostname.
-// The port is set to the default zero value.
-func GetHostByName(hostname string) (*snet.Addr, error) {
+// GetHostByName returns the IA and HostAddr corresponding to hostname
+func GetHostByName(hostname string) (libaddr.IA, libaddr.HostAddr, error) {
 	addr, ok := hosts[hostname]
 	if !ok {
-		return nil, fmt.Errorf("Address for host %q not found", hostname)
+		return libaddr.IA{}, nil, fmt.Errorf("Address for host %q not found", hostname)
 	}
-	scionAddr, err := snet.AddrFromString(addr)
-	if err != nil {
-		return nil, err
-	}
-	return scionAddr, nil
+	return addr.ia, addr.l3, nil
 }
 
 // GetHostnamesByAddress returns the hostnames corresponding to address
@@ -92,24 +97,47 @@ func readHostsFile() ([]byte, error) {
 	return bs, nil
 }
 
-func parseHostsFile(hostsFile []byte) error {
-	hosts = make(map[string]string)
+func parseHostsFile(hostsFile []byte) {
+	hosts = make(map[string]scionAddress)
 	revHosts = make(map[string][]string)
 	lines := bytes.Split(hostsFile, []byte("\n"))
 	for _, line := range lines {
 		fields := strings.Fields(string(line))
 		if len(fields) == 0 {
 			continue
 		}
-		if match := addrRegexp.FindString(fields[0]); len(match) == len(fields[0]) {
+		if matched := addrRegexp.MatchString(fields[0]); matched {
+			addr, err := addrFromString(fields[0])
+			if err != nil {
+				continue
+			}
+
+			// map hostnames to scionAddress
 			for _, field := range fields[1:] {
 				if _, ok := hosts[field]; !ok {
-					hosts[field] = fields[0]
+					hosts[field] = addr
 					revHosts[fields[0]] = append(revHosts[fields[0]], field)
 				}
 			}
 		}
 
 	}
-	return nil
+}
+
+func addrFromString(addr string) (scionAddress, error) {
+	parts := addrRegexp.FindStringSubmatch(addr)
+	ia, err := libaddr.IAFromString(parts[iaIndex])
+	if err != nil {
+		return scionAddress{}, fmt.Errorf("Invalid IA string: %v", parts[iaIndex])
+	}
+	var l3 libaddr.HostAddr
+	if hostSVC := libaddr.HostSVCFromString(parts[l3Index]); hostSVC != libaddr.SvcNone {
+		l3 = hostSVC
+	} else {
+		l3 = libaddr.HostFromIPStr(parts[l3Index])
+		if l3 == nil {
+			return scionAddress{}, fmt.Errorf("Invalid IP address string: %v", parts[l3Index])
+		}
+	}
+	return scionAddress{ia, l3}, nil
 }

lib/scionutil/hosts_test.go

@@ -68,11 +68,12 @@ func TestAddingHost(t *testing.T) {
 }
 
 func TestReadHosts(t *testing.T) {
-	addr, err := GetHostByName("host1.2")
+	ia, l3, err := GetHostByName("host1.2")
 	if err != nil {
 		t.Error(err)
 	}
-	addr.Host.L4 = libaddr.NewL4UDPInfo(0)
+	addr := &snet.Addr{IA: ia, Host: &libaddr.AppAddr{L3: l3, L4: libaddr.NewL4UDPInfo(0)}}
+
 	expected, err := snet.AddrFromString("17-ffaa:0:1,[192.168.1.1]:0")
 	if err != nil {
 		panic("This should always work")
@@ -82,18 +83,19 @@ func TestReadHosts(t *testing.T) {
 	}
 
 	// works with IPv6 SCION hosts
-	addr, err = GetHostByName("host4")
+	ia, l3, err = GetHostByName("host4")
 	if err != nil {
 		t.Error(err)
 	}
-	addr.Host.L4 = libaddr.NewL4UDPInfo(0)
+	addr = &snet.Addr{IA: ia, Host: &libaddr.AppAddr{L3: l3, L4: libaddr.NewL4UDPInfo(0)}}
+
 	expected, err = snet.AddrFromString("20-ffaa:c0ff:ee12,[::ff1:ce00:dead:10cc:baad:f00d]:0")
 	if !addr.EqAddr(expected) {
 		t.Errorf("host resolved to wrong address, expected: %q, received: %q", "20-ffaa:c0ff:ee12,[::ff1:ce00:dead:10cc:baad:f00d]:0", addr)
 	}
 
 	// does not parse commented hosts
-	addr, err = GetHostByName("commented")
+	ia, l3, err = GetHostByName("commented")
 	if err == nil {
 		t.Error("read commented host")
 	}
@@ -114,7 +116,7 @@ func TestReadAddresses(t *testing.T) {
 		t.Error(err)
 	}
 	if len(addrs) != 3 || addrs[0] != "host1.1" || addrs[1] != "host1.2" || addrs[2] != "host3" {
-		t.Errorf("address resolved to wrong hostnames, expected: %v, received: %v", []string{"host1", "host3"}, addrs)
+		t.Errorf("address resolved to wrong hostnames, expected: %v, received: %v", []string{"host1.1", "host1.2", "host3"}, addrs)
 	}
 
 	// pass address with IPv6

lib/scionutil/hosts_test_file

@@ -7,7 +7,7 @@ fe80:cd00:0:cde:1257:0:211e:729c                        dummy2
 123:4567:89ab:cdef:123:4567:89ab:cdef                   dummy3
 
 # SCION hosts
-# 17-ffaa:0:0,[10.0.8.15]                               commented
+#17-ffaa:0:0,[10.0.8.15]                                commented
 17-ffaa:0:1,[192.168.1.1]                               host1.1 host1.2
 18-ffaa:1:2,[10.0.8.10]	                                host2 
 17-ffaa:0:1,[192.168.1.1]                               host3

lib/shttp/examples/image_server/client.go

@@ -41,11 +41,13 @@ func main() {
 		log.Fatal(err)
 	}
 
-	rAddr, err := scionutil.GetHostByName("image-server")
+	ia, l3, err := scionutil.GetHostByName("image-server")
 	if err != nil {
 		log.Fatal(err)
 	}
-	rAddr.Host.L4 = addr.NewL4UDPInfo(40002)
+	l4 := addr.NewL4UDPInfo(40002)
+	rAddr := &snet.Addr{IA: ia, Host: &addr.AppAddr{L3: l3, L4: l4}}
+
 	if *interactive {
 		scionutil.ChoosePathInteractive(lAddr, rAddr)
 	} else {

lib/shttp/examples/minimal/client.go

@@ -41,11 +41,13 @@ func main() {
 		log.Fatal(err)
 	}
 
-	rAddr, err := scionutil.GetHostByName("minimal-server")
+	ia, l3, err := scionutil.GetHostByName("minimal-server")
 	if err != nil {
 		log.Fatal(err)
 	}
-	rAddr.Host.L4 = addr.NewL4UDPInfo(40002)
+	l4 := addr.NewL4UDPInfo(40002)
+	rAddr := &snet.Addr{IA: ia, Host: &addr.AppAddr{L3: l3, L4: l4}}
+
 	if *interactive {
 		scionutil.ChoosePathInteractive(lAddr, rAddr)
 	} else {

lib/shttp/transport.go

@@ -32,9 +32,11 @@ import (
 	"github.com/scionproto/scion/go/lib/snet/squic"
 )
 
-// Transport wraps a h2quic.RoundTripper and makes it compatible with SCION
+// Transport wraps a h2quic.RoundTripper making it compatible with SCION
 type Transport struct {
-	LAddr *snet.Addr
+	LAddr              *snet.Addr
+	QuicConfig         *quic.Config
+	DisableCompression bool
 
 	rt *h2quic.RoundTripper
 
@@ -60,26 +62,40 @@ func (t *Transport) RoundTripOpt(req *http.Request, opt h2quic.RoundTripOpt) (*h
 		return nil, initErr
 	}
 
-	// set the dial function once for each Transport
+	// 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) {
+
+			/* TODO(chaehni):
+			RequestConnectionIDOmission MUST not be set to 'true' when a connection is dialed using an existing net.PacketConn
+			(which the squic package is doing)
+			quic-go/client.go func populateClientConfig (line 177) fails to catch this problem
+			As a result, if set to 'true' the quic-go client multiplexer fails to match incoming packets
+			This problem is solved in subsequent releases of quic-go (>v0.8.0)
+			See issue https://github.com/scionproto/scion/issues/2463
+			*/
+			cfg.RequestConnectionIDOmission = false
+
 			host, port, err := net.SplitHostPort(addr)
 			if err != nil {
 				return nil, err
 			}
-			raddr, err := scionutil.GetHostByName(host)
+			ia, l3, err := scionutil.GetHostByName(host)
 			if err != nil {
 				return nil, err
 			}
 			p, err := strconv.ParseUint(port, 10, 16)
 			if err != nil {
 				p = 443
 			}
-			raddr.Host.L4 = libaddr.NewL4UDPInfo(uint16(p))
-			return squic.DialSCION(nil, t.LAddr, raddr, nil)
+			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)
 		}
 		t.rt = &h2quic.RoundTripper{
-			Dial: dial,
+			Dial:               dial,
+			QuicConfig:         t.QuicConfig,
+			DisableCompression: t.DisableCompression,
 		}
 	})