WIP: middleware/dnstap (#711)

middleware/dnstap add

vendor/github.com/farsightsec/golang-framestream/COPYRIGHT

@@ -0,0 +1,13 @@
+Copyright (c) 2014 by Farsight Security, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/farsightsec/golang-framestream/Control.go

@@ -0,0 +1,156 @@
+package framestream
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"io"
+)
+
+const CONTROL_ACCEPT = 0x01
+const CONTROL_START = 0x02
+const CONTROL_STOP = 0x03
+const CONTROL_READY = 0x04
+const CONTROL_FINISH = 0x05
+
+const CONTROL_FIELD_CONTENT_TYPE = 0x01
+
+type ControlFrame struct {
+	ControlType  uint32
+	ContentTypes [][]byte
+}
+
+var ControlStart = ControlFrame{ControlType: CONTROL_START}
+var ControlStop = ControlFrame{ControlType: CONTROL_STOP}
+var ControlReady = ControlFrame{ControlType: CONTROL_READY}
+var ControlAccept = ControlFrame{ControlType: CONTROL_ACCEPT}
+var ControlFinish = ControlFrame{ControlType: CONTROL_FINISH}
+
+func (c *ControlFrame) Encode(w io.Writer) (err error) {
+	var buf bytes.Buffer
+	err = binary.Write(&buf, binary.BigEndian, c.ControlType)
+	if err != nil {
+		return
+	}
+	for _, ctype := range c.ContentTypes {
+		err = binary.Write(&buf, binary.BigEndian, uint32(CONTROL_FIELD_CONTENT_TYPE))
+		if err != nil {
+			return
+		}
+
+		err = binary.Write(&buf, binary.BigEndian, uint32(len(ctype)))
+		if err != nil {
+			return
+		}
+
+		_, err = buf.Write(ctype)
+		if err != nil {
+			return
+		}
+	}
+
+	err = binary.Write(w, binary.BigEndian, uint32(0))
+	if err != nil {
+		return
+	}
+	err = binary.Write(w, binary.BigEndian, uint32(buf.Len()))
+	if err != nil {
+		return
+	}
+	_, err = buf.WriteTo(w)
+	return
+}
+
+func (c *ControlFrame) EncodeFlush(w *bufio.Writer) error {
+	if err := c.Encode(w); err != nil {
+		return err
+	}
+	return w.Flush()
+}
+
+func (c *ControlFrame) Decode(r io.Reader) (err error) {
+	var cflen uint32
+	err = binary.Read(r, binary.BigEndian, &cflen)
+	if err != nil {
+		return
+	}
+
+	err = binary.Read(r, binary.BigEndian, &c.ControlType)
+	if err != nil {
+		return
+	}
+
+	cflen -= 4
+	if cflen > 0 {
+		cfields := make([]byte, int(cflen))
+		_, err = io.ReadFull(r, cfields)
+		if err != nil {
+			return
+		}
+
+		for len(cfields) > 8 {
+			cftype := binary.BigEndian.Uint32(cfields[:4])
+			cfields = cfields[4:]
+			if cftype != CONTROL_FIELD_CONTENT_TYPE {
+				return ErrDecode
+			}
+
+			cflen := int(binary.BigEndian.Uint32(cfields[:4]))
+			cfields = cfields[4:]
+			if cflen > len(cfields) {
+				return ErrDecode
+			}
+
+			c.ContentTypes = append(c.ContentTypes, cfields[:cflen])
+			cfields = cfields[cflen:]
+		}
+
+		if len(cfields) > 0 {
+			return ErrDecode
+		}
+	}
+	return
+}
+
+func (c *ControlFrame) DecodeEscape(r io.Reader) error {
+	var zero uint32
+	err := binary.Read(r, binary.BigEndian, &zero)
+	if err != nil {
+		return err
+	}
+	if zero != 0 {
+		return ErrDecode
+	}
+	return c.Decode(r)
+}
+
+func (c *ControlFrame) DecodeTypeEscape(r io.Reader, ctype uint32) error {
+	err := c.DecodeEscape(r)
+	if err != nil {
+		return err
+	}
+
+	if ctype != c.ControlType {
+		return ErrDecode
+	}
+
+	return nil
+}
+
+func (c *ControlFrame) MatchContentType(ctype []byte) bool {
+	if ctype == nil {
+		return true
+	}
+	for _, cfctype := range c.ContentTypes {
+		if bytes.Compare(ctype, cfctype) == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *ControlFrame) SetContentType(ctype []byte) {
+	if ctype != nil {
+		c.ContentTypes = [][]byte{ctype}
+	}
+}

vendor/github.com/farsightsec/golang-framestream/Decoder.go

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2014 by Farsight Security, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package framestream
+
+import (
+	"bufio"
+	"encoding/binary"
+	"io"
+)
+
+type DecoderOptions struct {
+	MaxPayloadSize uint32
+	ContentType    []byte
+	Bidirectional  bool
+}
+
+type Decoder struct {
+	buf     []byte
+	opt     DecoderOptions
+	reader  *bufio.Reader
+	writer  *bufio.Writer
+	stopped bool
+}
+
+func NewDecoder(r io.Reader, opt *DecoderOptions) (dec *Decoder, err error) {
+	if opt == nil {
+		opt = &DecoderOptions{}
+	}
+	if opt.MaxPayloadSize == 0 {
+		opt.MaxPayloadSize = DEFAULT_MAX_PAYLOAD_SIZE
+	}
+	dec = &Decoder{
+		buf:    make([]byte, opt.MaxPayloadSize),
+		opt:    *opt,
+		reader: bufio.NewReader(r),
+		writer: nil,
+	}
+
+	var cf ControlFrame
+	if opt.Bidirectional {
+		w, ok := r.(io.Writer)
+		if !ok {
+			return dec, ErrType
+		}
+		dec.writer = bufio.NewWriter(w)
+
+		// Read the ready control frame.
+		err = cf.DecodeTypeEscape(dec.reader, CONTROL_READY)
+		if err != nil {
+			return
+		}
+
+		// Check content type.
+		if !cf.MatchContentType(dec.opt.ContentType) {
+			return dec, ErrContentTypeMismatch
+		}
+
+		// Send the accept control frame.
+		accept := ControlAccept
+		accept.SetContentType(dec.opt.ContentType)
+		err = accept.EncodeFlush(dec.writer)
+		if err != nil {
+			return
+		}
+	}
+
+	// Read the start control frame.
+	err = cf.DecodeTypeEscape(dec.reader, CONTROL_START)
+	if err != nil {
+		return
+	}
+
+	// Check content type.
+	if !cf.MatchContentType(dec.opt.ContentType) {
+		return dec, ErrContentTypeMismatch
+	}
+
+	return
+}
+
+func (dec *Decoder) readFrame(frameLen uint32) (err error) {
+	// Enforce limits on frame size.
+	if frameLen > dec.opt.MaxPayloadSize {
+		err = ErrDataFrameTooLarge
+		return
+	}
+
+	// Read the frame.
+	n, err := io.ReadFull(dec.reader, dec.buf[0:frameLen])
+	if err != nil || uint32(n) != frameLen {
+		return
+	}
+	return
+}
+
+func (dec *Decoder) Decode() (frameData []byte, err error) {
+	if dec.stopped {
+		err = EOF
+		return
+	}
+
+	// Read the frame length.
+	var frameLen uint32
+	err = binary.Read(dec.reader, binary.BigEndian, &frameLen)
+	if err != nil {
+		return
+	}
+	if frameLen == 0 {
+		// This is a control frame.
+		var cf ControlFrame
+		err = cf.Decode(dec.reader)
+		if err != nil {
+			return
+		}
+		if cf.ControlType == CONTROL_STOP {
+			dec.stopped = true
+			if dec.opt.Bidirectional {
+				ff := &ControlFrame{ControlType: CONTROL_FINISH}
+				err = ff.EncodeFlush(dec.writer)
+				if err != nil {
+					return
+				}
+			}
+			return nil, EOF
+		}
+		if err != nil {
+			return nil, err
+		}
+
+	} else {
+		// This is a data frame.
+		err = dec.readFrame(frameLen)
+		if err != nil {
+			return
+		}
+		frameData = dec.buf[0:frameLen]
+	}
+
+	return
+}

vendor/github.com/farsightsec/golang-framestream/Encoder.go

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2014 by Farsight Security, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package framestream
+
+import (
+	"bufio"
+	"encoding/binary"
+	"io"
+)
+
+type EncoderOptions struct {
+	ContentType   []byte
+	Bidirectional bool
+}
+
+type Encoder struct {
+	writer *bufio.Writer
+	reader *bufio.Reader
+	opt    EncoderOptions
+	buf    []byte
+}
+
+func NewEncoder(w io.Writer, opt *EncoderOptions) (enc *Encoder, err error) {
+	if opt == nil {
+		opt = &EncoderOptions{}
+	}
+	enc = &Encoder{
+		writer: bufio.NewWriter(w),
+		opt:    *opt,
+	}
+
+	if opt.Bidirectional {
+		r, ok := w.(io.Reader)
+		if !ok {
+			return nil, ErrType
+		}
+		enc.reader = bufio.NewReader(r)
+		ready := ControlReady
+		ready.SetContentType(opt.ContentType)
+		if err = ready.EncodeFlush(enc.writer); err != nil {
+			return
+		}
+
+		var accept ControlFrame
+		if err = accept.DecodeTypeEscape(enc.reader, CONTROL_ACCEPT); err != nil {
+			return
+		}
+
+		if !accept.MatchContentType(opt.ContentType) {
+			return nil, ErrContentTypeMismatch
+		}
+	}
+
+	// Write the start control frame.
+	start := ControlStart
+	start.SetContentType(opt.ContentType)
+	err = start.Encode(enc.writer)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+func (enc *Encoder) Close() (err error) {
+	err = ControlStop.EncodeFlush(enc.writer)
+	if err != nil || !enc.opt.Bidirectional {
+		return
+	}
+
+	var finish ControlFrame
+	return finish.DecodeTypeEscape(enc.reader, CONTROL_FINISH)
+}
+
+func (enc *Encoder) Write(frame []byte) (n int, err error) {
+	err = binary.Write(enc.writer, binary.BigEndian, uint32(len(frame)))
+	if err != nil {
+		return
+	}
+	return enc.writer.Write(frame)
+}
+
+func (enc *Encoder) Flush() error {
+	return enc.writer.Flush()
+}

vendor/github.com/farsightsec/golang-framestream/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/github.com/farsightsec/golang-framestream/framestream.go

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2014 by Farsight Security, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package framestream
+
+import (
+	"errors"
+	"io"
+)
+
+const DEFAULT_MAX_PAYLOAD_SIZE = 1048576
+const MAX_CONTROL_FRAME_SIZE = 512
+
+var EOF = io.EOF
+var ErrContentTypeMismatch = errors.New("content type mismatch")
+var ErrDataFrameTooLarge = errors.New("data frame too large")
+var ErrShortRead = errors.New("short read")
+var ErrDecode = errors.New("decoding error")
+var ErrType = errors.New("invalid type")

vendor/github.com/farsightsec/golang-framestream/framestream_dump/main.go

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2014 by Farsight Security, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/farsightsec/golang-framestream"
+)
+
+func main() {
+	// Arguments.
+	if len(os.Args) != 2 {
+		fmt.Fprintf(os.Stderr, "Usage: %s <INPUT FILE>\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "Dumps a FrameStreams formatted input file.\n\n")
+		os.Exit(1)
+	}
+	fname := os.Args[1]
+
+	// Open the input file.
+	file, err := os.Open(fname)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Create the decoder.
+	fs, err := framestream.NewDecoder(file, nil)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Print the frames.
+	fmt.Printf("Control frame [START] (%v bytes): %x\n", len(fs.ControlStart), fs.ControlStart)
+	for {
+		frame, err := fs.Decode()
+		if err == framestream.EOF {
+			break
+		}
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Printf("Data frame (%v bytes): %x\n", len(frame), frame)
+	}
+	if fs.ControlStop != nil {
+		fmt.Printf("Control frame [STOP] (%v bytes): %x\n", len(fs.ControlStop), fs.ControlStop)
+	}
+}

vendor/github.com/farsightsec/golang-framestream/framestream_test.go

@@ -0,0 +1,134 @@
+package framestream_test
+
+import (
+	"bytes"
+	"net"
+	"testing"
+
+	framestream "github.com/farsightsec/golang-framestream"
+)
+
+func testDecoder(t *testing.T, dec *framestream.Decoder, nframes int) {
+	i := 1
+	for {
+		tf, err := dec.Decode()
+		if err != nil {
+			if i < nframes+1 {
+				t.Fatalf("testDecoder(%d): %v", i, err)
+			}
+			if err != framestream.EOF {
+				t.Fatalf("unexpected error: %v != EOF", err)
+			}
+			return
+		}
+		if i > nframes {
+			t.Errorf("extra frame received: %d", i)
+		}
+		f := make([]byte, i)
+		if bytes.Compare(tf, f) != 0 {
+			t.Errorf("testDecoder: received %v != %v", tf, f)
+		}
+		i++
+	}
+}
+
+func TestUnidirectional(t *testing.T) {
+	buf := new(bytes.Buffer)
+	enc, err := framestream.NewEncoder(buf, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i := 1; i < 10; i++ {
+		b := make([]byte, i)
+		if _, err = enc.Write(b); err != nil {
+			t.Error(err)
+		}
+	}
+	enc.Close()
+
+	dec, err := framestream.NewDecoder(buf, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	testDecoder(t, dec, 9)
+}
+
+func TestBidirectional(t *testing.T) {
+	client, server := net.Pipe()
+
+	go func() {
+		dec, err := framestream.NewDecoder(server,
+			&framestream.DecoderOptions{
+				Bidirectional: true,
+			})
+
+		if err != nil {
+			t.Fatal(err)
+		}
+		testDecoder(t, dec, 9)
+	}()
+
+	enc, err := framestream.NewEncoder(client,
+		&framestream.EncoderOptions{
+			Bidirectional: true,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i := 1; i < 10; i++ {
+		b := make([]byte, i)
+		if _, err := enc.Write(b); err != nil {
+			t.Error(err)
+		}
+	}
+	enc.Close()
+}
+
+func TestContentTypeMismatch(t *testing.T) {
+	buf := new(bytes.Buffer)
+
+	enc, err := framestream.NewEncoder(buf,
+		&framestream.EncoderOptions{
+			ContentType: []byte("test"),
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	enc.Write([]byte("hello, world"))
+	enc.Close()
+
+	_, err = framestream.NewDecoder(buf,
+		&framestream.DecoderOptions{
+			ContentType: []byte("wrong"),
+		})
+	if err != framestream.ErrContentTypeMismatch {
+		t.Error("expected %v, received %v",
+			framestream.ErrContentTypeMismatch,
+			err)
+	}
+}
+
+func TestOversizeFrame(t *testing.T) {
+	buf := new(bytes.Buffer)
+	enc, err := framestream.NewEncoder(buf, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	enc.Write(make([]byte, 15))
+	enc.Close()
+
+	dec, err := framestream.NewDecoder(buf,
+		&framestream.DecoderOptions{
+			MaxPayloadSize: 10,
+		})
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = dec.Decode()
+	if err != framestream.ErrDataFrameTooLarge {
+		t.Error("data frame too large, received %v", err)
+	}
+}