Merge pull request #1 from marten-seemann/no-name-reference

implement parsing of literal header fields without name reference

Author: marten-seemann

decoder.go

@@ -73,10 +73,12 @@ func (d *Decoder) decode() error {
 		b := d.buf[0]
 		var err error
 		switch {
-		case b&0x80 > 0:
+		case b&0x80 > 0: // 1xxxxxxx
 			err = d.parseIndexedHeaderField()
-		case b&0xc0 == 0x40:
+		case b&0xc0 == 0x40: // 01xxxxxx
 			err = d.parseLiteralHeaderField()
+		case b&0xe0 == 0x20: // 001xxxxx
+			err = d.parseLiteralHeaderFieldWithoutNameReference()
 		default:
 			err = fmt.Errorf("unexpected type byte: %#x", d.buf[0])
 		}
@@ -105,8 +107,7 @@ func (d *Decoder) parseIndexedHeaderField() error {
 }
 
 func (d *Decoder) parseLiteralHeaderField() error {
-	b := d.buf
-	if b[0]&0x20 > 0 || b[0]&0x10 == 0 {
+	if d.buf[0]&0x20 > 0 || d.buf[0]&0x10 == 0 {
 		return errNoDynamicTable
 	}
 	index, rest, err := readVarInt(4, d.buf)
@@ -124,23 +125,56 @@ func (d *Decoder) parseLiteralHeaderField() error {
 		return err
 	}
 	d.buf = rest
+	val, err := d.parseString(l, usesHuffman)
+	if err != nil {
+		return err
+	}
+	hf.Value = val
+	d.emitFunc(hf)
+	return nil
+}
+
+func (d *Decoder) parseLiteralHeaderFieldWithoutNameReference() error {
+	usesHuffmanForName := d.buf[0]&0x8 > 0
+	nameLen, rest, err := readVarInt(3, d.buf)
+	if err != nil {
+		return err
+	}
+	d.buf = rest
+	name, err := d.parseString(nameLen, usesHuffmanForName)
+	if err != nil {
+		return err
+	}
+	usesHuffmanForVal := d.buf[0]&0x80 > 0
+	valLen, rest, err := readVarInt(7, d.buf)
+	if err != nil {
+		return err
+	}
+	d.buf = rest
+	val, err := d.parseString(valLen, usesHuffmanForVal)
+	if err != nil {
+		return err
+	}
+	d.emitFunc(HeaderField{Name: name, Value: val})
+	return nil
+}
+
+func (d *Decoder) parseString(l uint64, usesHuffman bool) (string, error) {
 	if uint64(len(d.buf)) < l {
-		return errors.New("too little data")
+		return "", errors.New("too little data")
 	}
 	var val string
 	if usesHuffman {
 		var err error
 		val, err = hpack.HuffmanDecodeToString(d.buf[:l])
 		if err != nil {
-			return err
+			return "", err
 		}
 	} else {
 		val = string(d.buf[:l])
 	}
 	d.buf = d.buf[l:]
-	hf.Value = val
-	d.emitFunc(hf)
-	return nil
+	return val, nil
 }
 
 func (d *Decoder) at(i uint64) (hf HeaderField, ok bool) {

decoder_test.go

@@ -97,6 +97,20 @@ var _ = Describe("Decoder", func() {
 		Expect(err).To(MatchError(errNoDynamicTable))
 	})
 
+	It("parses a literal header field without name reference", func() {
+		data := appendVarInt(nil, 3, 3)
+		data[0] ^= 0x20
+		data = append(data, []byte("foo")...)
+		data2 := appendVarInt(nil, 7, 3)
+		data2 = append(data2, []byte("bar")...)
+		data = append(data, data2...)
+		_, err := decoder.Write(insertPrefix(data))
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(HaveLen(1))
+		Expect(headerFields[0].Name).To(Equal("foo"))
+		Expect(headerFields[0].Value).To(Equal("bar"))
+	})
+
 	It("rejects unknown type bytes", func() {
 		_, err := decoder.Write(insertPrefix([]byte{0x10}))
 		Expect(err).To(MatchError("unexpected type byte: 0x10"))

integrationtests/integrationtests_suite_test.go

@@ -31,15 +31,10 @@ var qifs map[string]qif
 func readQIFs() {
 	qifDir := currentDir() + "/qifs/qifs"
 	Expect(qifDir).To(BeADirectory())
-	var processedFirst bool
 	filepath.Walk(qifDir, func(path string, info os.FileInfo, err error) error {
-		if processedFirst {
-			return nil
-		}
 		if info.IsDir() {
 			return nil
 		}
-		processedFirst = true
 		_, filename := filepath.Split(path)
 		ext := filepath.Ext(filename)
 		name := filename[:len(filename)-len(ext)]

integrationtests/interop_test.go

@@ -62,27 +62,31 @@ var _ = Describe("Interop", func() {
 	filenames := findFiles()
 	for i := range filenames {
 		path := filenames[i]
-		_, filename := filepath.Split(path)
+		fpath, filename := filepath.Split(path)
+		prettyPath := path[len(filepath.Dir(filepath.Dir(filepath.Dir(fpath))))+1:]
 
-		It(fmt.Sprintf("using %s", filename), func() {
+		It(fmt.Sprintf("using %s", prettyPath), func() {
 			qif, ok := qifs[strings.Split(filename, ".")[0]]
-			if !ok {
-				Skip("Skipping. No QIF file.")
-			}
+			Expect(ok).To(BeTrue())
 
 			file, err := os.Open(path)
 			var headers []qpack.HeaderField
 			decoder := qpack.NewDecoder(func(hf qpack.HeaderField) {
 				headers = append(headers, hf)
 			})
+			var numRequests, numHeaderFields int
+			Expect(qif.requests).ToNot(BeEmpty())
 			for _, req := range qif.requests {
 				Expect(err).ToNot(HaveOccurred())
 				_, data := parseInput(file)
 				_, err = decoder.Write(data)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(headers).To(Equal(req.headers))
+				numRequests++
+				numHeaderFields += len(headers)
 				headers = nil
 			}
+			fmt.Fprintf(GinkgoWriter, "Decoded %d requests containing %d header fields.\n", len(qif.requests), numHeaderFields)
 		})
 	}
 })