First cut at -13

Author: ekr

README.md

@@ -37,10 +37,12 @@ certificates.
 
 ## Quick Start (untested but should be rightish)
 
-
     cd ${GOPATH}/src
     go get github.com/ekr/minq
     cd github.com/bifurcation/mint
+    git remote add ekr https://github.com/ekr/mint
+    git fetch ekr
+    git checkout ekr/quic_record_layer
     cd ../../ekr/minq
     go test
 
@@ -101,6 +103,9 @@ Multiple log levels can be separated by commas.
 ## Mint
 
 Minq depends on Mint (https://www.github.com/bifurcation/mint) for TLS.
-Currently Mint master should work, but occasionally I will have to be on
-a branch. Will try to keep this updated.
+Right now we are on the following branch:
+
+https://github.com/ekr/mint/tree/quic_record_layer
+
+This branch is more experimental than usual.
 

bin/client/main.go

@@ -17,6 +17,9 @@ var doHttp string
 var httpCount int
 var heartbeat int
 var cpuProfile string
+var resume bool
+var httpLeft int
+var zeroRtt bool
 
 type connHandler struct {
 	bytesRead int
@@ -44,9 +47,11 @@ func (h *connHandler) StreamReadable(s minq.RecvStream) {
 			return
 		case minq.ErrorStreamIsClosed, minq.ErrorConnIsClosed:
 			log.Println("<CLOSED>")
+			httpLeft--
 			return
 		default:
 			log.Println("Error: ", err)
+			httpLeft--
 			return
 		}
 		b = b[:n]
@@ -78,6 +83,51 @@ func readUDP(s *net.UDPConn) ([]byte, error) {
 	return b, nil
 }
 
+func makeConnection(config *minq.TlsConfig, uaddr *net.UDPAddr) (*net.UDPConn, *minq.Connection) {
+	usock, err := net.ListenUDP("udp", nil)
+	if err != nil {
+		log.Println("Couldn't create connected UDP socket")
+		return nil, nil
+	}
+
+	utrans := minq.NewUdpTransport(usock, uaddr)
+
+	conn := minq.NewConnection(utrans, minq.RoleClient,
+		config, &connHandler{})
+
+	log.Printf("Client conn id=%v\n", conn.ClientId())
+
+	// Start things off.
+	_, err = conn.CheckTimer()
+
+	return usock, conn
+}
+
+func completeConnection(usock *net.UDPConn, conn *minq.Connection) error {
+	for conn.GetState() != minq.StateEstablished {
+		b, err := readUDP(usock)
+		if err != nil {
+			if err == minq.ErrorWouldBlock {
+				_, err = conn.CheckTimer()
+				if err != nil {
+					return err
+				}
+				continue
+			}
+			return err
+		}
+
+		err = conn.Input(b)
+		if err != nil {
+			log.Println("Error", err)
+			return err
+		}
+	}
+
+	log.Printf("Connection established server CID = %v\n", conn.ServerId())
+	return nil
+}
+
 func main() {
 	log.Println("PID=", os.Getpid())
 	flag.StringVar(&addr, "addr", "localhost:4433", "[host:port]")
@@ -86,8 +136,17 @@ func main() {
 	flag.IntVar(&httpCount, "httpCount", 1, "Number of parallel HTTP requests to start")
 	flag.IntVar(&heartbeat, "heartbeat", 0, "heartbeat frequency [ms]")
 	flag.StringVar(&cpuProfile, "cpuprofile", "", "write cpu profile to file")
+	flag.BoolVar(&resume, "resume", false, "Test resumption")
+	flag.BoolVar(&zeroRtt, "zerortt", false, "Test 0-RTT")
 	flag.Parse()
 
+	if zeroRtt {
+		resume = true
+		if doHttp == "" {
+			log.Printf("Need HTTP to do 0-RTT")
+			return
+		}
+	}
 	if cpuProfile != "" {
 		f, err := os.Create(cpuProfile)
 		if err != nil {
@@ -107,56 +166,46 @@ func main() {
 		}
 		serverName = host
 	}
+	config := minq.NewTlsConfig(serverName)
+
+	inner_main(&config, false)
+	if resume {
+		inner_main(&config, true)
+	}
+}
+func inner_main(config *minq.TlsConfig, resuming bool) {
 
 	uaddr, err := net.ResolveUDPAddr("udp", addr)
 	if err != nil {
 		log.Println("Invalid UDP addr", err)
 		return
 	}
-	usock, err := net.ListenUDP("udp", nil)
-	if err != nil {
-		log.Println("Couldn't create connected UDP socket")
+
+	usock, conn := makeConnection(config, uaddr)
+	if conn == nil {
 		return
 	}
 
-	utrans := minq.NewUdpTransport(usock, uaddr)
-
-	config := minq.NewTlsConfig(serverName)
-	conn := minq.NewConnection(utrans, minq.RoleClient,
-		&config, &connHandler{})
-
-	log.Printf("Client conn id=%x\n", conn.ClientId())
-
-	// Start things off.
-	_, err = conn.CheckTimer()
-
-	for conn.GetState() != minq.StateEstablished {
-		b, err := readUDP(usock)
+	if !resuming || !zeroRtt {
+		err = completeConnection(usock, conn)
 		if err != nil {
-			if err == minq.ErrorWouldBlock {
-				_, err = conn.CheckTimer()
-				if err != nil {
-					return
-				}
-				continue
-			}
-			return
-		}
-
-		err = conn.Input(b)
-		if err != nil {
-			log.Println("Error", err)
 			return
 		}
 	}
 
-	log.Println("Connection established")
+	// Hopefully reduce the risk of reordering
+	time.Sleep(100 * time.Millisecond)
 
 	// Make all the streams we need
 	streams := make([]minq.Stream, httpCount)
 	for i := 0; i < httpCount; i++ {
 		streams[i] = conn.CreateStream()
+		if streams[i] == nil {
+			log.Println("Couldn't create stream")
+			return
+		}
 	}
+	httpLeft = httpCount
 
 	udpin := make(chan []byte)
 	stdin := make(chan []byte)
@@ -185,6 +234,22 @@ func main() {
 		}()
 	}
 
+	if doHttp != "" {
+		req := "GET " + doHttp + "\r\n"
+		for _, str := range streams {
+			str.Write([]byte(req))
+			str.Close()
+		}
+	}
+
+	if resuming && zeroRtt {
+		log.Println("Completing connection after we sent 0-RTT send in 0-RTT")
+		err = completeConnection(usock, conn)
+		if err != nil {
+			return
+		}
+	}
+
 	if doHttp == "" {
 		// Read from stdin.
 		go func() {
@@ -199,14 +264,7 @@ func main() {
 				stdin <- b
 			}
 		}()
-	} else {
-		req := "GET " + doHttp + "\r\n"
-		for _, str := range streams {
-			str.Write([]byte(req))
-			str.Close()
-		}
 	}
-
 	for {
 		select {
 		case u := <-udpin:
@@ -219,6 +277,9 @@ func main() {
 				log.Println("Error", err)
 				return
 			}
+			if doHttp != "" && httpLeft == 0 {
+				return
+			}
 		case i := <-stdin:
 			if i == nil {
 				// TODO([email protected]) close the apropriate stream(s)

codec.go

@@ -195,18 +195,22 @@ func encode(i interface{}) (ret []byte, err error) {
 	return ret, nil
 }
 
+func uintDecodeIntBuf(val []byte) uint64 {
+	tmp := uint64(0)
+	for b := 0; b < len(val); b++ {
+		tmp = (tmp << 8) + uint64(val[b])
+	}
+	return tmp
+}
+
 func uintDecodeInt(r io.Reader, size uintptr) (uint64, error) {
 	val := make([]byte, size)
 	_, err := io.ReadFull(r, val)
 	if err != nil {
 		return 0, err
 	}
 
-	tmp := uint64(0)
-	for b := uintptr(0); b < size; b++ {
-		tmp = (tmp << 8) + uint64(val[b])
-	}
-	return tmp, nil
+	return uintDecodeIntBuf(val), nil
 }
 
 func uintDecode(r io.Reader, v reflect.Value, encodingSize uintptr) (uintptr, error) {