make it possible to encode multiple header fields

Author: marten-seemann

encoder.go

@@ -6,6 +6,8 @@ import (
 
 // An Encoder performs QPACK encoding.
 type Encoder struct {
+	wrotePrefix bool
+
 	w   io.Writer
 	buf []byte
 }
@@ -21,15 +23,25 @@ func NewEncoder(w io.Writer) *Encoder {
 // if necessary. If produced, it is done before encoding f.
 func (e *Encoder) WriteField(f HeaderField) error {
 	// write the Header Block Prefix
-	e.buf = appendVarInt(e.buf, 8, 0)
-	e.buf = appendVarInt(e.buf, 7, 0)
+	if !e.wrotePrefix {
+		e.buf = appendVarInt(e.buf, 8, 0)
+		e.buf = appendVarInt(e.buf, 7, 0)
+		e.wrotePrefix = true
+	}
 
 	e.writeLiteralFieldWithoutNameReference(f)
 	e.w.Write(e.buf)
 	e.buf = e.buf[:0]
 	return nil
 }
 
+// Close declares that the encoding is complete and resets the Encoder
+// to be reused again for a new header block.
+func (e *Encoder) Close() error {
+	e.wrotePrefix = false
+	return nil
+}
+
 func (e *Encoder) writeLiteralFieldWithoutNameReference(f HeaderField) {
 	offset := len(e.buf)
 	e.buf = appendVarInt(e.buf, 3, uint64(len(f.Name)))

encoder_test.go

@@ -27,24 +27,64 @@ var _ = Describe("Encoder", func() {
 		return
 	}
 
-	It("encodes", func() {
+	checkHeaderField := func(data []byte, hf HeaderField) []byte {
+		Expect(data[0] & (0x80 ^ 0x40 ^ 0x20)).To(Equal(uint8(0x20))) // 001xxxxx
+		Expect(data[0] & 0x8).To(BeZero())                            // no Huffman encoding
+		nameLen, data, err := readVarInt(3, data)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(nameLen).To(BeEquivalentTo(len(hf.Name)))
+		Expect(string(data[:len(hf.Name)])).To(Equal(hf.Name))
+		valueLen, data, err := readVarInt(7, data[len(hf.Name):])
+		Expect(err).ToNot(HaveOccurred())
+		Expect(valueLen).To(BeEquivalentTo(len(hf.Value)))
+		Expect(string(data[:len(hf.Value)])).To(Equal(hf.Value))
+		return data[len(hf.Value):]
+	}
+
+	It("encodes a single field", func() {
 		hf := HeaderField{Name: "foobar", Value: "lorem ipsum"}
 		Expect(encoder.WriteField(hf)).To(Succeed())
 
 		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
 		Expect(requiredInsertCount).To(BeZero())
 		Expect(deltaBase).To(BeZero())
 
-		Expect(data[0] & (0x80 ^ 0x40 ^ 0x20)).To(Equal(uint8(0x20))) // 001xxxxx
-		Expect(data[0] & 0x8).To(BeZero())                            // no Huffman encoding
-		nameLen, data, err := readVarInt(3, data)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(nameLen).To(BeEquivalentTo(6))
-		Expect(string(data[:6])).To(Equal("foobar"))
-		valueLen, data, err := readVarInt(7, data[6:])
-		Expect(err).ToNot(HaveOccurred())
-		Expect(valueLen).To(BeEquivalentTo(11))
-		Expect(string(data[:11])).To(Equal("lorem ipsum"))
-		Expect(data[11:]).To(BeEmpty())
+		data = checkHeaderField(data, hf)
+		Expect(data).To(BeEmpty())
+	})
+
+	It("encodes multipe fields", func() {
+		hf1 := HeaderField{Name: "foobar", Value: "lorem ipsum"}
+		hf2 := HeaderField{Name: "raboof", Value: "dolor sit amet"}
+		Expect(encoder.WriteField(hf1)).To(Succeed())
+		Expect(encoder.WriteField(hf2)).To(Succeed())
+
+		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+
+		data = checkHeaderField(data, hf1)
+		data = checkHeaderField(data, hf2)
+		Expect(data).To(BeEmpty())
+	})
+
+	It("encodes multiple requests", func() {
+		hf1 := HeaderField{Name: "foobar", Value: "lorem ipsum"}
+		Expect(encoder.WriteField(hf1)).To(Succeed())
+		data, requiredInsertCount, deltaBase := readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+		data = checkHeaderField(data, hf1)
+		Expect(data).To(BeEmpty())
+
+		output.Reset()
+		Expect(encoder.Close())
+		hf2 := HeaderField{Name: "raboof", Value: "dolor sit amet"}
+		Expect(encoder.WriteField(hf2)).To(Succeed())
+		data, requiredInsertCount, deltaBase = readPrefix(output.Bytes())
+		Expect(requiredInsertCount).To(BeZero())
+		Expect(deltaBase).To(BeZero())
+		data = checkHeaderField(data, hf2)
+		Expect(data).To(BeEmpty())
 	})
 })

integrationtests/self/integration_test.go

@@ -28,11 +28,50 @@ var _ = Describe("Self Tests", func() {
 		})
 	})
 
-	It("encodes and decodes a single header", func() {
+	It("encodes and decodes a single header field", func() {
 		hf := qpack.HeaderField{Name: "foo", Value: "bar"}
 		Expect(encoder.WriteField(hf)).To(Succeed())
 		_, err := decoder.Write(output.Bytes())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(headerFields).To(Equal([]qpack.HeaderField{hf}))
 	})
+
+	It("encodes and decodes multiple header fields", func() {
+		hfs := []qpack.HeaderField{
+			{Name: "foo", Value: "bar"},
+			{Name: "lorem", Value: "ipsum"},
+			{Name: "name", Value: "value"},
+		}
+		for _, hf := range hfs {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		_, err := decoder.Write(output.Bytes())
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs))
+	})
+
+	It("encodes and decodes multiple requests", func() {
+		hfs1 := []qpack.HeaderField{{Name: "foo", Value: "bar"}}
+		hfs2 := []qpack.HeaderField{
+			{Name: "lorem", Value: "ipsum"},
+			{Name: "name", Value: "value"},
+		}
+		for _, hf := range hfs1 {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		req1 := append([]byte{}, output.Bytes()...)
+		output.Reset()
+		for _, hf := range hfs2 {
+			Expect(encoder.WriteField(hf)).To(Succeed())
+		}
+		req2 := append([]byte{}, output.Bytes()...)
+
+		_, err := decoder.Write(req1)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs1))
+		headerFields = nil
+		_, err = decoder.Write(req2)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(headerFields).To(Equal(hfs2))
+	})
 })