test: quic server supports dpvs-compatible cid and uoa

test/quic/client/quic-client.go

@@ -3,47 +3,61 @@ package main
 import (
 	"context"
 	"crypto/tls"
+	"flag"
 	"fmt"
 	"io"
 	"log"
 	"net"
 	"os"
+	"runtime/trace"
 
 	"github.com/quic-go/quic-go"
 )
 
-var servAddr = ":4242"
-
-var keyLogFile = "quic-go-client-sshkey.log"
-
 func main() {
-	if len(os.Args) > 1 {
-		servAddr = os.Args[1]
-	}
-	fmt.Printf("target server: %s\n", servAddr)
+	servAddr := flag.String("server", ":4242", "quic server address")
+	keyLogFile := flag.String("keylog", "", "key log file")
+	traceFile := flag.String("trace", "", "trace file name")
+	flag.Parse()
 
-	keyLog, err := os.OpenFile(keyLogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
-	if err != nil {
-		log.Fatal(err)
+	if *traceFile != "" {
+		tracef, err := os.Create(*traceFile)
+		if err != nil {
+			log.Fatalf("failed to create trace output file: %v", err)
+		}
+		defer tracef.Close()
+		err = trace.Start(tracef)
+		if err != nil {
+			log.Fatalf("failed to start trace: %v", err)
+		}
+		defer trace.Stop()
 	}
-	defer keyLog.Close()
 
-	ctx := context.Background()
+	fmt.Printf("target server: %s\n", *servAddr)
+
 	tlsConf := &tls.Config{
 		InsecureSkipVerify: true,
 		NextProtos:         []string{"quic-echo-example"},
-		KeyLogWriter:       keyLog,
+	}
+	if *keyLogFile != "" {
+		keyLog, err := os.OpenFile(*keyLogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer keyLog.Close()
+		tlsConf.KeyLogWriter = keyLog
 	}
 
+	ctx := context.Background()
 	/*
-		conn, err := quic.DialAddr(ctx, servAddr, tlsConf, nil)
+		conn, err := quic.DialAddr(ctx, *servAddr, tlsConf, nil)
 		if err != nil {
 			log.Fatal("Cannot dial QUIC server:", err)
 		}
 		defer conn.CloseWithError(0, "")
 	*/
 
-	serverAddr, err := net.ResolveUDPAddr("udp", servAddr)
+	serverAddr, err := net.ResolveUDPAddr("udp", *servAddr)
 	if err != nil {
 		log.Fatal("ServerAddr resolution fail:", err)
 	}
@@ -56,6 +70,14 @@ func main() {
 	defer listener.Close()
 
 	conn, err := quic.Dial(ctx, listener, serverAddr, tlsConf, nil)
+	/*
+		cidGenerator := cid.NewDpvsQCID(10, 4, 0, nil, 0)
+		transport := &quic.Transport{
+			Conn:                  listener,
+			ConnectionIDGenerator: cidGenerator,
+		}
+		conn, err := transport.Dial(ctx, serverAddr, tlsConf, nil)
+	*/
 	if err != nil {
 		log.Fatal("Cannot dial QUIC server:", err)
 	}

test/quic/http3/h3client/h3client.go

@@ -20,7 +20,7 @@ func main() {
 	quiet := flag.Bool("q", false, "don't print the data")
 	keyLogFile := flag.String("keylog", "", "key log file")
 	insecure := flag.Bool("insecure", false, "skip certificate verification")
-	cert := flag.String("cert", "../certs/cert.pem", "TLS certificate")
+	cert := flag.String("cert", "", "TLS certificate")
 	flag.Parse()
 	urls := flag.Args()
 

test/quic/http3/h3server/h3server.go

@@ -137,8 +137,8 @@ func main() {
 	flag.Var(&bs, "bind", "bind to")
 	www := flag.String("www", "", "www data")
 	tcp := flag.Bool("tcp", false, "also listen on TCP")
-	key := flag.String("key", "../certs/key.pem", "TLS key (requires -cert option)")
-	cert := flag.String("cert", "../certs/cert.pem", "TLS certificate (requires -key option)")
+	key := flag.String("key", "./http3/certs/key.pem", "TLS key (requires -cert option)")
+	cert := flag.String("cert", "./http3/certs/cert.pem", "TLS certificate (requires -key option)")
 	flag.Parse()
 
 	if len(bs) == 0 {

test/quic/pkg/cid/cid_generator.go

@@ -5,29 +5,83 @@ import (
 	"fmt"
 	"io"
 	"net"
+
+	quic "github.com/quic-go/quic-go"
 )
 
 const (
 	QUIC_CID_BUF_LEN         = 20
 	DPVS_QUIC_DCID_BYTES_MIN = 7
 )
 
-func QuicCIDGenerator(
+type DpvsQCID struct {
+	cidLen  uint8
+	l3len   uint8
+	l4len   uint8
+	svrIP   net.IP
+	svrPort uint16
+}
+
+var _ quic.ConnectionIDGenerator = (*DpvsQCID)(nil)
+
+func NewDpvsQCID(cidLen, l3len, l4len uint8,
+	svrIP net.IP, svrPort uint16) *DpvsQCID {
+	if cidLen < DPVS_QUIC_DCID_BYTES_MIN {
+		cidLen = DPVS_QUIC_DCID_BYTES_MIN
+	}
+	if l3len < 1 {
+		l3len = 1
+	} else if l3len > 8 {
+		l3len = 8
+	}
+	if l4len > 0 {
+		l4len = 2
+	}
+	if svrIP == nil {
+		svrIP, _ = FindLocalIP("")
+	}
+
+	return &DpvsQCID{
+		cidLen:  cidLen,
+		l3len:   l3len,
+		l4len:   l4len,
+		svrIP:   svrIP,
+		svrPort: svrPort,
+	}
+}
+
+func (dqcid *DpvsQCID) ConnectionIDLen() int {
+	return int(dqcid.cidLen)
+}
+
+func (dqcid *DpvsQCID) GenerateConnectionID() (quic.ConnectionID, error) {
+	data, err := QuicCIDGeneratorFunction(dqcid.cidLen, dqcid.l3len,
+		dqcid.l4len, dqcid.svrIP, dqcid.svrPort)
+	if err != nil {
+		data = make([]byte, dqcid.cidLen)
+		rand.Read(data[:])
+	}
+	return quic.ConnectionIDFromBytes(data), err
+}
+
+func QuicCIDGeneratorFunction(
 	cidLen uint8, // the total length of CID to be generated, 7~20 bytes
 	l3len uint8, // the length of server IP to encode into CID, 1~8 bytes
 	l4len uint8, // the length of server Port to encode into CID, 0 or 2 bytes
 	svrIP net.IP, // the server IP
 	svrPort uint16, // the server Port
-) (error, []byte) {
+) ([]byte, error) {
 	rdbuf := make([]byte, QUIC_CID_BUF_LEN)
 	var i uint8
 	var l3addr []byte
 	var l4addr uint16
 
-	if cidLen < DPVS_QUIC_DCID_BYTES_MIN || l3len > 8 || l3len < 1 ||
+	if svrIP == nil ||
+		cidLen < DPVS_QUIC_DCID_BYTES_MIN ||
+		l3len > 8 || l3len < 1 ||
 		(l4len != 0 && l4len != 2) ||
 		cidLen < l3len+l4len+5 {
-		return fmt.Errorf("invalid params"), nil
+		return nil, fmt.Errorf("invalid params")
 	}
 
 	entropy := cidLen - l3len - l4len + 1
@@ -42,14 +96,14 @@ func QuicCIDGenerator(
 	} else {
 		ipbytes = svrIP.To16()
 		if ipbytes == nil {
-			return fmt.Errorf("invalid IP %v", svrIP), nil
+			return nil, fmt.Errorf("invalid IP %v", svrIP)
 		}
 		l3addr = ipbytes[16-l3len:]
 	}
 	l4addr = svrPort
 
 	if _, err := io.ReadFull(rand.Reader, rdbuf[:entropy]); err != nil {
-		return err, nil
+		return nil, err
 	}
 
 	cid := make([]byte, cidLen, cidLen)
@@ -73,5 +127,5 @@ func QuicCIDGenerator(
 	cid[l3len+l4len+1] |= (rdbuf[1] & 0xf)
 	copy(cid[l3len+l4len+2:], rdbuf[2:entropy-1])
 
-	return nil, cid
+	return cid, nil
 }

test/quic/pkg/cid/cid_generator_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 func TestQuicCIDGenerator_IPv4(t *testing.T) {
-	err, cid := QuicCIDGenerator(10, 3, 2, net.ParseIP("192.168.111.222"), 8029)
+	cid, err := QuicCIDGeneratorFunction(10, 3, 2, net.ParseIP("192.168.111.222"), 8029)
 	if err != nil {
 		t.Errorf("QuicCIDGenerator error return: %v", err)
 	}
@@ -27,7 +27,8 @@ func TestQuicCIDGenerator_IPv4(t *testing.T) {
 }
 
 func TestQuicCIDGenerator_IPv6(t *testing.T) {
-	err, cid := QuicCIDGenerator(16, 6, 2, net.ParseIP("2001::123:4567:89ab:cdef"), 51321)
+	cid, err := QuicCIDGeneratorFunction(16, 6, 2,
+		net.ParseIP("2001::123:4567:89ab:cdef"), 51321)
 	if err != nil {
 		t.Errorf("QuicCIDGenerator error return: %v", err)
 	}

test/quic/pkg/cid/server_addr.go

@@ -0,0 +1,25 @@
+package cid
+
+import (
+	"net"
+)
+
+func FindLocalIP(targetIP string) (net.IP, error) {
+	if len(targetIP) == 0 {
+		targetIP = "8.8.8.8"
+	}
+
+	raddr, err := net.ResolveIPAddr("ip", targetIP)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.DialIP("ip:icmp", nil, raddr)
+	if err != nil {
+		return nil, err
+	}
+	defer conn.Close()
+
+	localAddr := conn.LocalAddr().(*net.IPAddr)
+	return localAddr.IP, nil
+}