add windows support

capture/config.go

@@ -1,10 +1,11 @@
 package capture
 
 import (
-	log "github.com/sirupsen/logrus"
-	sd "github.com/zr-hebo/sniffer-agent/session-dealer"
 	"math/rand"
 	"time"
+
+	log "github.com/golang/glog"
+	sd "github.com/zr-hebo/sniffer-agent/session-dealer"
 )
 
 var (
@@ -21,7 +22,10 @@ func init() {
 	}
 
 	localIPAddr = &ipAddr
-	log.Infof("parsed local ip address:%s", *localIPAddr)
 
 	rand.Seed(time.Now().UnixNano())
 }
+
+func ShowLocalIP() {
+	log.Infof("parsed local ip address:%s", *localIPAddr)
+}

capture/model.go

@@ -0,0 +1,11 @@
+package capture
+
+import (
+	"github.com/google/gopacket/layers"
+)
+
+type TCPIPPair struct {
+	srcIP  string
+	dstIP  string
+	tcpPkt *layers.TCP
+}

capture/network.go

@@ -4,14 +4,13 @@ import (
 	"bufio"
 	"bytes"
 	"flag"
-	"fmt"
 	"math/rand"
 	"time"
 
+	log "github.com/golang/glog"
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/layers"
 	pp "github.com/pires/go-proxyproto"
-	log "github.com/sirupsen/logrus"
 	"github.com/zr-hebo/sniffer-agent/communicator"
 	"github.com/zr-hebo/sniffer-agent/model"
 	sd "github.com/zr-hebo/sniffer-agent/session-dealer"
@@ -57,14 +56,34 @@ func (nc *networkCard) Listen() (receiver chan model.QueryPiece) {
 // Listen get a connection.
 func (nc *networkCard) listenNormal() {
 	go func() {
+		dealTCPPacket := func(srcIP, dstIP string, tcpPkt *layers.TCP, capturePacketRate float64) {
+			// send FIN tcp packet to avoid not complete session cannot be released
+			// deal FIN packet
+			if tcpPkt.FIN {
+				nc.parseTCPPackage(srcIP, dstIP, tcpPkt, nil)
+				return
+			}
+
+			// deal auth packet
+			if sd.IsAuthPacket(tcpPkt.Payload) {
+				authHeader, _ := pp.Read(bufio.NewReader(bytes.NewReader(tcpPkt.Payload)))
+				nc.parseTCPPackage(srcIP, dstIP, tcpPkt, authHeader)
+				return
+			}
+
+			if 0 < capturePacketRate && capturePacketRate < 1.0 {
+				// fall into throw range
+				rn := rand.Float64()
+				if rn > capturePacketRate {
+					return
+				}
+			}
+
+			nc.parseTCPPackage(srcIP, dstIP, tcpPkt, nil)
+		}
+
 		aliveCounter := 0
-		handler := initEthernetHandlerFromPacp()
+		dealTCPIPPacket := func(tcpIPPkt *TCPIPPair) {
-
-		for {
-			var data []byte
-			var ci gopacket.CaptureInfo
-			var err error
-
 			// capture packets according to a certain probability
 			capturePacketRate := communicator.GetTCPCapturePacketRate()
 			if capturePacketRate <= 0 {
@@ -74,53 +93,19 @@ func (nc *networkCard) listenNormal() {
 					aliveCounter = 0
 					nc.receiver <- model.NewBaseQueryPiece(localIPAddr, nc.listenPort, capturePacketRate)
 				}
-				continue
+
+			} else {
+				dealTCPPacket(tcpIPPkt.srcIP, tcpIPPkt.dstIP, tcpIPPkt.tcpPkt, capturePacketRate)
 			}
-
-			data, ci, err = handler.ZeroCopyReadPacketData()
-			if err != nil {
-				log.Error(err.Error())
-				time.Sleep(time.Second * 3)
-				continue
-			}
-
-			packet := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
-			// packet := gopacket.NewPacket(data, handler.LinkType(), gopacket.NoCopy)
-			m := packet.Metadata()
-			m.CaptureInfo = ci
-
-			tcpPkt := packet.TransportLayer().(*layers.TCP)
-			// send FIN tcp packet to avoid not complete session cannot be released
-			// deal FIN packet
-			if tcpPkt.FIN {
-				nc.parseTCPPackage(packet, nil)
-				continue
-			}
-
-			// deal auth packet
-			if sd.IsAuthPacket(tcpPkt.Payload) {
-				authHeader, _ := pp.Read(bufio.NewReader(bytes.NewReader(tcpPkt.Payload)))
-				nc.parseTCPPackage(packet, authHeader)
-				continue
-			}
-
-			if 0 < capturePacketRate && capturePacketRate < 1.0 {
-				// fall into throw range
-				rn := rand.Float64()
-				if rn > capturePacketRate {
-					continue
-				}
-			}
-
-			aliveCounter = 0
-			nc.parseTCPPackage(packet, nil)
 		}
+
+		dealEachTCPIPPacket(dealTCPIPPacket)
 	}()
 
 	return
 }
 
-func (nc *networkCard) parseTCPPackage(packet gopacket.Packet, authHeader *pp.Header) {
+func (nc *networkCard) parseTCPPackage(srcIP, dstIP string, tcpPkt *layers.TCP, authHeader *pp.Header) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -128,25 +113,10 @@ func (nc *networkCard) parseTCPPackage(packet gopacket.Packet, authHeader *pp.He
 		}
 	}()
 
-	tcpPkt := packet.TransportLayer().(*layers.TCP)
 	if tcpPkt.SYN || tcpPkt.RST {
 		return
 	}
 
-	ipLayer := packet.Layer(layers.LayerTypeIPv4)
-	if ipLayer == nil {
-		err = fmt.Errorf("no ip layer found in package")
-		return
-	}
-
-	ipInfo, ok := ipLayer.(*layers.IPv4)
-	if !ok {
-		err = fmt.Errorf("parsed no ip address")
-		return
-	}
-
-	srcIP := ipInfo.SrcIP.String()
-	dstIP := ipInfo.DstIP.String()
 	srcPort := int(tcpPkt.SrcPort)
 	dstPort := int(tcpPkt.DstPort)
 
@@ -231,7 +201,7 @@ func readToServerPackage(
 			session.Close()
 			delete(sessionPool, *sessionKey)
 		}
-		log.Debugf("close connection from %s", *sessionKey)
+		log.Infof("close connection from %s", *sessionKey)
 		return
 	}
 

capture/pacp_linux.go

@@ -1,17 +1,21 @@
+//go:build linux
 // +build linux
 
 package capture
 
 import (
 	"fmt"
+	"time"
 
+	log "github.com/golang/glog"
+	"github.com/google/gopacket"
 	"github.com/google/gopacket/layers"
 	"github.com/google/gopacket/pcap"
 	"github.com/google/gopacket/pcapgo"
 	"golang.org/x/net/bpf"
 )
 
-func initEthernetHandlerFromPacp() (handler PcapHandler) {
+func initEthernetHandlerFromPacp() (pcapgoHandler *pcapgo.EthernetHandle) {
 	pcapgoHandler, err := pcapgo.NewEthernetHandle(DeviceName)
 	if err != nil {
 		panic(fmt.Sprintf("cannot open network interface %s <-- %s", DeviceName, err.Error()))
@@ -40,6 +44,58 @@ func initEthernetHandlerFromPacp() (handler PcapHandler) {
 	}
 
 	_ = pcapgoHandler.SetCaptureLength(65536)
-	handler = pcapgoHandler
 	return
 }
+
+func dealEachTCPIPPacket(dealTCPIPPacket func(tcpIPPkt *TCPIPPair)) {
+	handler := initEthernetHandlerFromPacp()
+	defer func() {
+		handler.Close()
+	}()
+
+	for {
+		var ci gopacket.CaptureInfo
+		data, ci, err := handler.ZeroCopyReadPacketData()
+		if err != nil {
+			log.Error(err.Error())
+			time.Sleep(time.Second * 3)
+			continue
+		}
+
+		packet := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
+		m := packet.Metadata()
+		m.CaptureInfo = ci
+
+		tcpPkt, ok := packet.TransportLayer().(*layers.TCP)
+		if !ok {
+			continue
+		}
+
+		ipLayer := packet.NetworkLayer()
+		if ipLayer == nil {
+			log.Error("no ip layer found in package")
+			continue
+		}
+
+		var srcIP, dstIP string
+		switch realIPLayer := ipLayer.(type) {
+		case *layers.IPv6:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		case *layers.IPv4:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		}
+
+		tcpipPair := &TCPIPPair{
+			srcIP:  srcIP,
+			dstIP:  dstIP,
+			tcpPkt: tcpPkt,
+		}
+		dealTCPIPPacket(tcpipPair)
+	}
+}

capture/pacp_macos.go

@@ -1,15 +1,20 @@
+//go:build darwin
 // +build darwin
 
 package capture
 
 import (
 	"fmt"
+	"time"
 
+	log "github.com/golang/glog"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
 	"github.com/google/gopacket/pcap"
 )
 
 // in online use, we found a strange bug: pcap cost 100% core CPU and memory increase along
-func initEthernetHandlerFromPacp() (handler PcapHandler) {
+func initEthernetHandlerFromPacp() (pcapHandler *pcap.Handle) {
 	pcapHandler, err := pcap.OpenLive(DeviceName, 65536, false, pcap.BlockForever)
 	if err != nil {
 		panic(fmt.Sprintf("cannot open network interface %s <-- %s", DeviceName, err.Error()))
@@ -20,6 +25,58 @@ func initEthernetHandlerFromPacp() (handler PcapHandler) {
 		panic(err.Error())
 	}
 
-	handler = pcapHandler
 	return
 }
+
+func dealEachTCPIPPacket(dealTCPIPPacket func(tcpIPPkt *TCPIPPair)) {
+	handler := initEthernetHandlerFromPacp()
+	defer func() {
+		handler.Close()
+	}()
+
+	for {
+		var ci gopacket.CaptureInfo
+		data, ci, err := handler.ZeroCopyReadPacketData()
+		if err != nil {
+			log.Error(err.Error())
+			time.Sleep(time.Second * 3)
+			continue
+		}
+
+		packet := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
+		m := packet.Metadata()
+		m.CaptureInfo = ci
+
+		tcpPkt, ok := packet.TransportLayer().(*layers.TCP)
+		if !ok {
+			continue
+		}
+
+		ipLayer := packet.NetworkLayer()
+		if ipLayer == nil {
+			log.Error("no ip layer found in package")
+			continue
+		}
+
+		var srcIP, dstIP string
+		switch realIPLayer := ipLayer.(type) {
+		case *layers.IPv6:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		case *layers.IPv4:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		}
+
+		tcpipPair := &TCPIPPair{
+			srcIP:  srcIP,
+			dstIP:  dstIP,
+			tcpPkt: tcpPkt,
+		}
+		dealTCPIPPacket(tcpipPair)
+	}
+}

capture/pacp_windows.go

@@ -0,0 +1,81 @@
+//go:build windows
+// +build windows
+
+package capture
+
+import (
+	"fmt"
+	"time"
+
+	log "github.com/golang/glog"
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+)
+
+var (
+	handler *pcap.Handle
+)
+
+func initEthernetHandlerFromPacp() (pcapHandler *pcap.Handle) {
+	devices, err := pcap.FindAllDevs()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, device := range devices {
+		log.Infof("found Windows device:'%s', device info:%s", device.Name, device.Description)
+	}
+
+	pcapHandler, err = pcap.OpenLive(DeviceName, 1024, false, time.Hour*24)
+	if err != nil {
+		panic(fmt.Sprintf("cannot open network interface %s <-- %s", DeviceName, err.Error()))
+	}
+
+	return
+}
+
+func dealEachTCPIPPacket(dealTCPIPPacket func(tcpIPPkt *TCPIPPair)) {
+	handler = initEthernetHandlerFromPacp()
+	defer handler.Close()
+	packetSource := gopacket.NewPacketSource(handler, handler.LinkType())
+	for packet := range packetSource.Packets() {
+		if err := packet.ErrorLayer(); err != nil {
+			log.Error(err.Error())
+			continue
+		}
+
+		// Process packet here
+		tcpLayer := packet.Layer(layers.LayerTypeTCP)
+		if tcpLayer == nil {
+			continue
+		}
+		tcpPkt := tcpLayer.(*layers.TCP)
+		if (int(tcpPkt.SrcPort) != snifferPort && int(tcpPkt.DstPort) != snifferPort) {
+			continue
+		}
+
+		var srcIP, dstIP string
+		ipLayer := packet.NetworkLayer()
+		switch realIPLayer := ipLayer.(type) {
+		case *layers.IPv6:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		case *layers.IPv4:
+			{
+				srcIP = realIPLayer.SrcIP.String()
+				dstIP = realIPLayer.DstIP.String()
+			}
+		}
+
+		tcpipPair := &TCPIPPair{
+			srcIP:  srcIP,
+			dstIP:  dstIP,
+			tcpPkt: tcpPkt,
+		}
+		dealTCPIPPacket(tcpipPair)
+	}
+	return
+}

communicator/config.go

@@ -2,9 +2,10 @@ package communicator
 
 import (
 	"flag"
-	"github.com/gorilla/mux"
 	_ "net/http/pprof"
 	"sync"
+
+	"github.com/gorilla/mux"
 )
 
 const (
@@ -30,9 +31,6 @@ func init() {
 	flag.IntVar(&communicatePort, "communicate_port", 8088, "http server port. Default is 8088")
 	flag.Float64Var(&catpurePacketRateVal, CAPTURE_PACKET_RATE, 1.0, "capture packet rate. Default is 1.0")
 
-	if err := catpurePacketRate.setVal(catpurePacketRateVal); err != nil {
-		panic(err.Error())
-	}
 	configMap = make(map[string]configItem)
 	regsiterConfig()
 }

exporter/kafka.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 
 	"github.com/Shopify/sarama"
-	log "github.com/sirupsen/logrus"
+	log "github.com/golang/glog"
 	"github.com/zr-hebo/sniffer-agent/model"
 )
 

main.go

@@ -2,43 +2,28 @@ package main
 
 import (
 	"flag"
-	"fmt"
-	sd "github.com/zr-hebo/sniffer-agent/session-dealer"
-	"github.com/zr-hebo/sniffer-agent/session-dealer/mysql"
 	"os"
 
-	log "github.com/sirupsen/logrus"
+	log "github.com/golang/glog"
 	"github.com/zr-hebo/sniffer-agent/capture"
 	"github.com/zr-hebo/sniffer-agent/communicator"
 	"github.com/zr-hebo/sniffer-agent/exporter"
+	sd "github.com/zr-hebo/sniffer-agent/session-dealer"
+	"github.com/zr-hebo/sniffer-agent/session-dealer/mysql"
 )
 
 var (
 	logLevel string
 )
 
-func init()  {
+func init() {
 	flag.StringVar(&logLevel, "log_level", "warn", "log level. Default is info")
 }
 
-func initLog()  {
+func initLog() {
-	log.SetFormatter(&log.TextFormatter{})
-	log.SetOutput(os.Stdout)
-	switch logLevel {
-	case "debug":
-		log.SetLevel(log.DebugLevel)
-	case "info":
-		log.SetLevel(log.InfoLevel)
-	case "warn":
-		log.SetLevel(log.WarnLevel)
-	case "error":
-		log.SetLevel(log.ErrorLevel)
-	default:
-		panic(fmt.Sprintf("cannot set log level:%s, there have four types can set: debug, info, warn, error", logLevel))
-	}
 }
 
-func main()  {
+func main() {
 	flag.Parse()
 	prepareEnv()
 
@@ -46,7 +31,7 @@ func main()  {
 	mainServer()
 }
 
-func mainServer()  {
+func mainServer() {
 	ept := exporter.NewExporter()
 	networkCard := capture.NewNetworkCard()
 	log.Info("begin listen")
@@ -62,8 +47,9 @@ func mainServer()  {
 	os.Exit(1)
 }
 
-func prepareEnv()  {
+func prepareEnv() {
 	initLog()
 	sd.CheckParams()
 	mysql.PrepareEnv()
-}
+	capture.ShowLocalIP()
+}

session-dealer/mysql/session.go

@@ -5,8 +5,8 @@ import (
 	"sync"
 	"time"
 
+	log "github.com/golang/glog"
 	"github.com/pingcap/tidb/util/hack"
-	log "github.com/sirupsen/logrus"
 	"github.com/zr-hebo/sniffer-agent/communicator"
 	"github.com/zr-hebo/sniffer-agent/model"
 )
@@ -171,7 +171,7 @@ func (ms *MysqlSession) readFromClient(seqID int64, bytes []byte) {
 		ms.endSeqID = seqID
 
 		if int64(ms.expectReceiveSize) < int64(len(contents)) {
-			log.Debug("receive invalid mysql packet")
+			log.Warning("receive invalid mysql packet")
 			return
 		}
 
@@ -186,13 +186,13 @@ func (ms *MysqlSession) readFromClient(seqID int64, bytes []byte) {
 		}
 
 		if ms.beginSeqID == -1 {
-			log.Debug("cover range is empty")
+			log.Info("cover range is empty")
 			return
 		}
 
 		if seqID < ms.beginSeqID {
 			// out date packet
-			log.Debugf("in session %s get outdate package with Seq:%d, beginSeq:%d",
+			log.Infof("in session %s get outdate package with Seq:%d, beginSeq:%d",
 				*ms.connectionID, seqID, ms.beginSeqID)
 			return
 		}
@@ -200,7 +200,7 @@ func (ms *MysqlSession) readFromClient(seqID int64, bytes []byte) {
 		seqOffset := seqID - ms.beginSeqID
 		if seqOffset+contentSize > int64(len(ms.cachedStmtBytes)) {
 			// not in a normal mysql packet
-			log.Debugf("receive an unexpect packet")
+			log.Info("receive an unexpect packet")
 			ms.clear()
 			return
 		}
@@ -225,12 +225,12 @@ func (ms *MysqlSession) GenerateQueryPiece() (qp model.QueryPiece) {
 	}
 
 	if !ms.checkFinish() {
-		log.Debugf("receive a not complete cover")
+		log.Warning("receive a not complete cover")
 		return
 	}
 
 	if len(ms.cachedStmtBytes) > maxSQLLen {
-		log.Warn("sql in cache is too long, ignore it")
+		log.Warning("sql in cache is too long, ignore it")
 		return
 	}
 
@@ -275,7 +275,7 @@ func (ms *MysqlSession) GenerateQueryPiece() (qp model.QueryPiece) {
 			querySQL := hack.String(querySQLInBytes)
 			mqp.QuerySQL = &querySQL
 			ms.cachedPrepareStmt[ms.prepareInfo.prepareStmtID] = querySQLInBytes
-			log.Debugf("prepare statement %s, get id:%d", querySQL, ms.prepareInfo.prepareStmtID)
+			log.Infof("prepare statement %s, get id:%d", querySQL, ms.prepareInfo.prepareStmtID)
 
 		case ComStmtExecute:
 			prepareStmtID := bytesToInt(ms.cachedStmtBytes[1:5])
@@ -293,7 +293,7 @@ func (ms *MysqlSession) GenerateQueryPiece() (qp model.QueryPiece) {
 		case ComStmtClose:
 			prepareStmtID := bytesToInt(ms.cachedStmtBytes[1:5])
 			delete(ms.cachedPrepareStmt, prepareStmtID)
-			log.Debugf("remove prepare statement:%d", prepareStmtID)
+			log.Infof("remove prepare statement:%d", prepareStmtID)
 
 		default:
 			return

vendor/github.com/golang/glog/LICENSE

@@ -0,0 +1,191 @@
+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:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+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
+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/golang/glog/README

@@ -0,0 +1,44 @@
+glog
+====
+
+Leveled execution logs for Go.
+
+This is an efficient pure Go implementation of leveled logs in the
+manner of the open source C++ package
+	https://github.com/google/glog
+
+By binding methods to booleans it is possible to use the log package
+without paying the expense of evaluating the arguments to the log.
+Through the -vmodule flag, the package also provides fine-grained
+control over logging at the file level.
+
+The comment from glog.go introduces the ideas:
+
+	Package glog implements logging analogous to the Google-internal
+	C++ INFO/ERROR/V setup.  It provides functions Info, Warning,
+	Error, Fatal, plus formatting variants such as Infof. It
+	also provides V-style logging controlled by the -v and
+	-vmodule=file=2 flags.
+	
+	Basic examples:
+	
+		glog.Info("Prepare to repel boarders")
+	
+		glog.Fatalf("Initialization failed: %s", err)
+	
+	See the documentation for the V function for an explanation
+	of these examples:
+	
+		if glog.V(2) {
+			glog.Info("Starting transaction...")
+		}
+	
+		glog.V(2).Infoln("Processed", nItems, "elements")
+
+
+The repository contains an open source version of the log package
+used inside Google. The master copy of the source lives inside
+Google, not here. The code in this repo is for export only and is not itself
+under development. Feature requests will be ignored.
+
+Send bug reports to golang-nuts@googlegroups.com.

vendor/github.com/golang/glog/glog_file.go

@@ -0,0 +1,124 @@
+// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// 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.
+
+// File I/O for logs.
+
+package glog
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// MaxSize is the maximum size of a log file in bytes.
+var MaxSize uint64 = 1024 * 1024 * 1800
+
+// logDirs lists the candidate directories for new log files.
+var logDirs []string
+
+// If non-empty, overrides the choice of directory in which to write logs.
+// See createLogDirs for the full list of possible destinations.
+var logDir = flag.String("log_dir", "", "If non-empty, write log files in this directory")
+
+func createLogDirs() {
+	if *logDir != "" {
+		logDirs = append(logDirs, *logDir)
+	}
+	logDirs = append(logDirs, os.TempDir())
+}
+
+var (
+	pid      = os.Getpid()
+	program  = filepath.Base(os.Args[0])
+	host     = "unknownhost"
+	userName = "unknownuser"
+)
+
+func init() {
+	h, err := os.Hostname()
+	if err == nil {
+		host = shortHostname(h)
+	}
+
+	current, err := user.Current()
+	if err == nil {
+		userName = current.Username
+	}
+
+	// Sanitize userName since it may contain filepath separators on Windows.
+	userName = strings.Replace(userName, `\`, "_", -1)
+}
+
+// shortHostname returns its argument, truncating at the first period.
+// For instance, given "www.google.com" it returns "www".
+func shortHostname(hostname string) string {
+	if i := strings.Index(hostname, "."); i >= 0 {
+		return hostname[:i]
+	}
+	return hostname
+}
+
+// logName returns a new log file name containing tag, with start time t, and
+// the name for the symlink for tag.
+func logName(tag string, t time.Time) (name, link string) {
+	name = fmt.Sprintf("%s.%s.%s.log.%s.%04d%02d%02d-%02d%02d%02d.%d",
+		program,
+		host,
+		userName,
+		tag,
+		t.Year(),
+		t.Month(),
+		t.Day(),
+		t.Hour(),
+		t.Minute(),
+		t.Second(),
+		pid)
+	return name, program + "." + tag
+}
+
+var onceLogDirs sync.Once
+
+// create creates a new log file and returns the file and its filename, which
+// contains tag ("INFO", "FATAL", etc.) and t.  If the file is created
+// successfully, create also attempts to update the symlink for that tag, ignoring
+// errors.
+func create(tag string, t time.Time) (f *os.File, filename string, err error) {
+	onceLogDirs.Do(createLogDirs)
+	if len(logDirs) == 0 {
+		return nil, "", errors.New("log: no log dirs")
+	}
+	name, link := logName(tag, t)
+	var lastErr error
+	for _, dir := range logDirs {
+		fname := filepath.Join(dir, name)
+		f, err := os.Create(fname)
+		if err == nil {
+			symlink := filepath.Join(dir, link)
+			os.Remove(symlink)        // ignore err
+			os.Symlink(name, symlink) // ignore err
+			return f, fname, nil
+		}
+		lastErr = err
+	}
+	return nil, "", fmt.Errorf("log: cannot create log: %v", lastErr)
+}

vendor/github.com/golang/glog/glog_test.go

@@ -0,0 +1,415 @@
+// Go support for leveled logs, analogous to https://code.google.com/p/google-glog/
+//
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// 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 glog
+
+import (
+	"bytes"
+	"fmt"
+	stdLog "log"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Test that shortHostname works as advertised.
+func TestShortHostname(t *testing.T) {
+	for hostname, expect := range map[string]string{
+		"":                "",
+		"host":            "host",
+		"host.google.com": "host",
+	} {
+		if got := shortHostname(hostname); expect != got {
+			t.Errorf("shortHostname(%q): expected %q, got %q", hostname, expect, got)
+		}
+	}
+}
+
+// flushBuffer wraps a bytes.Buffer to satisfy flushSyncWriter.
+type flushBuffer struct {
+	bytes.Buffer
+}
+
+func (f *flushBuffer) Flush() error {
+	return nil
+}
+
+func (f *flushBuffer) Sync() error {
+	return nil
+}
+
+// swap sets the log writers and returns the old array.
+func (l *loggingT) swap(writers [numSeverity]flushSyncWriter) (old [numSeverity]flushSyncWriter) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	old = l.file
+	for i, w := range writers {
+		logging.file[i] = w
+	}
+	return
+}
+
+// newBuffers sets the log writers to all new byte buffers and returns the old array.
+func (l *loggingT) newBuffers() [numSeverity]flushSyncWriter {
+	return l.swap([numSeverity]flushSyncWriter{new(flushBuffer), new(flushBuffer), new(flushBuffer), new(flushBuffer)})
+}
+
+// contents returns the specified log value as a string.
+func contents(s severity) string {
+	return logging.file[s].(*flushBuffer).String()
+}
+
+// contains reports whether the string is contained in the log.
+func contains(s severity, str string, t *testing.T) bool {
+	return strings.Contains(contents(s), str)
+}
+
+// setFlags configures the logging flags how the test expects them.
+func setFlags() {
+	logging.toStderr = false
+}
+
+// Test that Info works as advertised.
+func TestInfo(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	Info("test")
+	if !contains(infoLog, "I", t) {
+		t.Errorf("Info has wrong character: %q", contents(infoLog))
+	}
+	if !contains(infoLog, "test", t) {
+		t.Error("Info failed")
+	}
+}
+
+func TestInfoDepth(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+
+	f := func() { InfoDepth(1, "depth-test1") }
+
+	// The next three lines must stay together
+	_, _, wantLine, _ := runtime.Caller(0)
+	InfoDepth(0, "depth-test0")
+	f()
+
+	msgs := strings.Split(strings.TrimSuffix(contents(infoLog), "\n"), "\n")
+	if len(msgs) != 2 {
+		t.Fatalf("Got %d lines, expected 2", len(msgs))
+	}
+
+	for i, m := range msgs {
+		if !strings.HasPrefix(m, "I") {
+			t.Errorf("InfoDepth[%d] has wrong character: %q", i, m)
+		}
+		w := fmt.Sprintf("depth-test%d", i)
+		if !strings.Contains(m, w) {
+			t.Errorf("InfoDepth[%d] missing %q: %q", i, w, m)
+		}
+
+		// pull out the line number (between : and ])
+		msg := m[strings.LastIndex(m, ":")+1:]
+		x := strings.Index(msg, "]")
+		if x < 0 {
+			t.Errorf("InfoDepth[%d]: missing ']': %q", i, m)
+			continue
+		}
+		line, err := strconv.Atoi(msg[:x])
+		if err != nil {
+			t.Errorf("InfoDepth[%d]: bad line number: %q", i, m)
+			continue
+		}
+		wantLine++
+		if wantLine != line {
+			t.Errorf("InfoDepth[%d]: got line %d, want %d", i, line, wantLine)
+		}
+	}
+}
+
+func init() {
+	CopyStandardLogTo("INFO")
+}
+
+// Test that CopyStandardLogTo panics on bad input.
+func TestCopyStandardLogToPanic(t *testing.T) {
+	defer func() {
+		if s, ok := recover().(string); !ok || !strings.Contains(s, "LOG") {
+			t.Errorf(`CopyStandardLogTo("LOG") should have panicked: %v`, s)
+		}
+	}()
+	CopyStandardLogTo("LOG")
+}
+
+// Test that using the standard log package logs to INFO.
+func TestStandardLog(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	stdLog.Print("test")
+	if !contains(infoLog, "I", t) {
+		t.Errorf("Info has wrong character: %q", contents(infoLog))
+	}
+	if !contains(infoLog, "test", t) {
+		t.Error("Info failed")
+	}
+}
+
+// Test that the header has the correct format.
+func TestHeader(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	defer func(previous func() time.Time) { timeNow = previous }(timeNow)
+	timeNow = func() time.Time {
+		return time.Date(2006, 1, 2, 15, 4, 5, .067890e9, time.Local)
+	}
+	pid = 1234
+	Info("test")
+	var line int
+	format := "I0102 15:04:05.067890    1234 glog_test.go:%d] test\n"
+	n, err := fmt.Sscanf(contents(infoLog), format, &line)
+	if n != 1 || err != nil {
+		t.Errorf("log format error: %d elements, error %s:\n%s", n, err, contents(infoLog))
+	}
+	// Scanf treats multiple spaces as equivalent to a single space,
+	// so check for correct space-padding also.
+	want := fmt.Sprintf(format, line)
+	if contents(infoLog) != want {
+		t.Errorf("log format error: got:\n\t%q\nwant:\t%q", contents(infoLog), want)
+	}
+}
+
+// Test that an Error log goes to Warning and Info.
+// Even in the Info log, the source character will be E, so the data should
+// all be identical.
+func TestError(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	Error("test")
+	if !contains(errorLog, "E", t) {
+		t.Errorf("Error has wrong character: %q", contents(errorLog))
+	}
+	if !contains(errorLog, "test", t) {
+		t.Error("Error failed")
+	}
+	str := contents(errorLog)
+	if !contains(warningLog, str, t) {
+		t.Error("Warning failed")
+	}
+	if !contains(infoLog, str, t) {
+		t.Error("Info failed")
+	}
+}
+
+// Test that a Warning log goes to Info.
+// Even in the Info log, the source character will be W, so the data should
+// all be identical.
+func TestWarning(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	Warning("test")
+	if !contains(warningLog, "W", t) {
+		t.Errorf("Warning has wrong character: %q", contents(warningLog))
+	}
+	if !contains(warningLog, "test", t) {
+		t.Error("Warning failed")
+	}
+	str := contents(warningLog)
+	if !contains(infoLog, str, t) {
+		t.Error("Info failed")
+	}
+}
+
+// Test that a V log goes to Info.
+func TestV(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	logging.verbosity.Set("2")
+	defer logging.verbosity.Set("0")
+	V(2).Info("test")
+	if !contains(infoLog, "I", t) {
+		t.Errorf("Info has wrong character: %q", contents(infoLog))
+	}
+	if !contains(infoLog, "test", t) {
+		t.Error("Info failed")
+	}
+}
+
+// Test that a vmodule enables a log in this file.
+func TestVmoduleOn(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	logging.vmodule.Set("glog_test=2")
+	defer logging.vmodule.Set("")
+	if !V(1) {
+		t.Error("V not enabled for 1")
+	}
+	if !V(2) {
+		t.Error("V not enabled for 2")
+	}
+	if V(3) {
+		t.Error("V enabled for 3")
+	}
+	V(2).Info("test")
+	if !contains(infoLog, "I", t) {
+		t.Errorf("Info has wrong character: %q", contents(infoLog))
+	}
+	if !contains(infoLog, "test", t) {
+		t.Error("Info failed")
+	}
+}
+
+// Test that a vmodule of another file does not enable a log in this file.
+func TestVmoduleOff(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	logging.vmodule.Set("notthisfile=2")
+	defer logging.vmodule.Set("")
+	for i := 1; i <= 3; i++ {
+		if V(Level(i)) {
+			t.Errorf("V enabled for %d", i)
+		}
+	}
+	V(2).Info("test")
+	if contents(infoLog) != "" {
+		t.Error("V logged incorrectly")
+	}
+}
+
+// vGlobs are patterns that match/don't match this file at V=2.
+var vGlobs = map[string]bool{
+	// Easy to test the numeric match here.
+	"glog_test=1": false, // If -vmodule sets V to 1, V(2) will fail.
+	"glog_test=2": true,
+	"glog_test=3": true, // If -vmodule sets V to 1, V(3) will succeed.
+	// These all use 2 and check the patterns. All are true.
+	"*=2":           true,
+	"?l*=2":         true,
+	"????_*=2":      true,
+	"??[mno]?_*t=2": true,
+	// These all use 2 and check the patterns. All are false.
+	"*x=2":         false,
+	"m*=2":         false,
+	"??_*=2":       false,
+	"?[abc]?_*t=2": false,
+}
+
+// Test that vmodule globbing works as advertised.
+func testVmoduleGlob(pat string, match bool, t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	defer logging.vmodule.Set("")
+	logging.vmodule.Set(pat)
+	if V(2) != Verbose(match) {
+		t.Errorf("incorrect match for %q: got %t expected %t", pat, V(2), match)
+	}
+}
+
+// Test that a vmodule globbing works as advertised.
+func TestVmoduleGlob(t *testing.T) {
+	for glob, match := range vGlobs {
+		testVmoduleGlob(glob, match, t)
+	}
+}
+
+func TestRollover(t *testing.T) {
+	setFlags()
+	var err error
+	defer func(previous func(error)) { logExitFunc = previous }(logExitFunc)
+	logExitFunc = func(e error) {
+		err = e
+	}
+	defer func(previous uint64) { MaxSize = previous }(MaxSize)
+	MaxSize = 512
+
+	Info("x") // Be sure we have a file.
+	info, ok := logging.file[infoLog].(*syncBuffer)
+	if !ok {
+		t.Fatal("info wasn't created")
+	}
+	if err != nil {
+		t.Fatalf("info has initial error: %v", err)
+	}
+	fname0 := info.file.Name()
+	Info(strings.Repeat("x", int(MaxSize))) // force a rollover
+	if err != nil {
+		t.Fatalf("info has error after big write: %v", err)
+	}
+
+	// Make sure the next log file gets a file name with a different
+	// time stamp.
+	//
+	// TODO: determine whether we need to support subsecond log
+	// rotation.  C++ does not appear to handle this case (nor does it
+	// handle Daylight Savings Time properly).
+	time.Sleep(1 * time.Second)
+
+	Info("x") // create a new file
+	if err != nil {
+		t.Fatalf("error after rotation: %v", err)
+	}
+	fname1 := info.file.Name()
+	if fname0 == fname1 {
+		t.Errorf("info.f.Name did not change: %v", fname0)
+	}
+	if info.nbytes >= MaxSize {
+		t.Errorf("file size was not reset: %d", info.nbytes)
+	}
+}
+
+func TestLogBacktraceAt(t *testing.T) {
+	setFlags()
+	defer logging.swap(logging.newBuffers())
+	// The peculiar style of this code simplifies line counting and maintenance of the
+	// tracing block below.
+	var infoLine string
+	setTraceLocation := func(file string, line int, ok bool, delta int) {
+		if !ok {
+			t.Fatal("could not get file:line")
+		}
+		_, file = filepath.Split(file)
+		infoLine = fmt.Sprintf("%s:%d", file, line+delta)
+		err := logging.traceLocation.Set(infoLine)
+		if err != nil {
+			t.Fatal("error setting log_backtrace_at: ", err)
+		}
+	}
+	{
+		// Start of tracing block. These lines know about each other's relative position.
+		_, file, line, ok := runtime.Caller(0)
+		setTraceLocation(file, line, ok, +2) // Two lines between Caller and Info calls.
+		Info("we want a stack trace here")
+	}
+	numAppearances := strings.Count(contents(infoLog), infoLine)
+	if numAppearances < 2 {
+		// Need 2 appearances, one in the log header and one in the trace:
+		//   log_test.go:281: I0511 16:36:06.952398 02238 log_test.go:280] we want a stack trace here
+		//   ...
+		//   github.com/glog/glog_test.go:280 (0x41ba91)
+		//   ...
+		// We could be more precise but that would require knowing the details
+		// of the traceback format, which may not be dependable.
+		t.Fatal("got no trace back; log is ", contents(infoLog))
+	}
+}
+
+func BenchmarkHeader(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		buf, _, _ := logging.header(infoLog, 0)
+		logging.putBuffer(buf)
+	}
+}

vendor/github.com/google/gopacket/.gitignore

@@ -1,38 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-#*
-*~
-
-# examples binaries
-examples/synscan/synscan
-examples/pfdump/pfdump
-examples/pcapdump/pcapdump
-examples/httpassembly/httpassembly
-examples/statsassembly/statsassembly
-examples/arpscan/arpscan
-examples/bidirectional/bidirectional
-examples/bytediff/bytediff
-examples/reassemblydump/reassemblydump
-layers/gen
-macs/gen
-pcap/pcap_tester

vendor/github.com/google/gopacket/.travis.gofmt.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-cd "$(dirname $0)"
-if [ -n "$(go fmt ./...)" ]; then
-  echo "Go code is not formatted, run 'go fmt github.com/google/stenographer/...'" >&2
-  exit 1
-fi

vendor/github.com/google/gopacket/.travis.golint.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-
-cd "$(dirname $0)"
-
-go get golang.org/x/lint/golint
-DIRS=". tcpassembly tcpassembly/tcpreader ip4defrag reassembly macs pcapgo pcap afpacket pfring routing defrag/lcmdefrag"
-# Add subdirectories here as we clean up golint on each.
-for subdir in $DIRS; do
-  pushd $subdir
-  if golint |
-      grep -v CannotSetRFMon |  # pcap exported error name
-      grep -v DataLost |        # tcpassembly/tcpreader exported error name
-      grep .; then
-    exit 1
-  fi
-  popd
-done
-
-pushd layers
-for file in *.go; do
-  if cat .lint_blacklist | grep -q $file; then
-    echo "Skipping lint of $file due to .lint_blacklist"
-  elif golint $file | grep .; then
-    echo "Lint error in file $file"
-    exit 1
-  fi
-done
-popd

vendor/github.com/google/gopacket/.travis.govet.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-cd "$(dirname $0)"
-DIRS=". layers pcap pcapgo tcpassembly tcpassembly/tcpreader routing ip4defrag bytediff macs defrag/lcmdefrag"
-set -e
-for subdir in $DIRS; do
-  pushd $subdir
-  go vet
-  popd
-done

vendor/github.com/google/gopacket/.travis.install.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-set -ev
-
-go get github.com/google/gopacket
-go get github.com/google/gopacket/layers
-go get github.com/google/gopacket/tcpassembly
-go get github.com/google/gopacket/reassembly
-go get github.com/google/gopacket/pcapgo

vendor/github.com/google/gopacket/.travis.script.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-set -ev
-
-go test github.com/google/gopacket
-go test github.com/google/gopacket/layers
-go test github.com/google/gopacket/tcpassembly
-go test github.com/google/gopacket/reassembly
-go test github.com/google/gopacket/pcapgo 
-go test github.com/google/gopacket/pcap

vendor/github.com/google/gopacket/.travis.yml

@@ -1,55 +0,0 @@
-language: go
-go:
- - 1.11.x
- - 1.12.x
- - master
-
-addons:
-  apt:
-    packages:
-      libpcap-dev
-
-# use modules except for older versions (see below)
-install: true
-
-env:
-  - GO111MODULE=on
-
-script: ./.travis.script.sh
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - go: master
-
-jobs:
-  include:
-    - go: 1.5.x
-      install: ./.travis.install.sh
-    - go: 1.6.x
-      install: ./.travis.install.sh
-    - go: 1.7.x
-      install: ./.travis.install.sh
-    - go: 1.8.x
-      install: ./.travis.install.sh
-    - go: 1.9.x
-      install: ./.travis.install.sh
-    - go: 1.10.x
-      install: ./.travis.install.sh
-    - os: osx
-      go: 1.x
-    - os: windows
-      go: 1.x
-      # winpcap does not work on travis ci - so install nmap to get libpcap
-      before_install: choco install nmap
-    - stage: style
-      name: "fmt/vet/lint"
-      go: 1.x
-      script:
-        - ./.travis.gofmt.sh
-        - ./.travis.govet.sh
-        - ./.travis.golint.sh
-
-stages:
-  - style
-  - test

vendor/github.com/google/gopacket/AUTHORS

@@ -33,6 +33,7 @@ Jesse Ward <jesse@jesseward.com>
 Kane Mathers <kane@kanemathers.name>
 Jose Selvi <jselvi@pentester.es>
 Yerden Zhumabekov <yerden.zhumabekov@gmail.com>
+Jensen Hwa <jensenhwa@gmail.com>
 
 -----------------------------------------------
 FORKED FROM github.com/akrennmair/gopcap

vendor/github.com/google/gopacket/README.md

@@ -6,7 +6,7 @@ See [godoc](https://godoc.org/github.com/google/gopacket) for more details.
 [![Build Status](https://travis-ci.org/google/gopacket.svg?branch=master)](https://travis-ci.org/google/gopacket)
 [![GoDoc](https://godoc.org/github.com/google/gopacket?status.svg)](https://godoc.org/github.com/google/gopacket)
 
-Minimum Go version required is 1.5 except for pcapgo/EthernetHandle, afpacket, and bsdbpf which need at least 1.7 due to x/sys/unix dependencies.
+Minimum Go version required is 1.5 except for pcapgo/EthernetHandle, afpacket, and bsdbpf which need at least 1.9 due to x/sys/unix dependencies.
 
 Originally forked from the gopcap project written by Andreas
 Krennmair <ak@synflood.at> (http://github.com/akrennmair/gopcap).

vendor/github.com/google/gopacket/benchmark_test.go

@@ -0,0 +1,194 @@
+// Copyright 2012, Google, Inc. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree.
+
+package gopacket
+
+import (
+	"runtime"
+	"testing"
+)
+
+// A few benchmarks for figuring out exactly how fast some underlying Go
+// things are.
+
+type testError struct{}
+
+func (t *testError) Error() string { return "abc" }
+
+func BenchmarkTypeAssertion(b *testing.B) {
+	var e error = &testError{}
+	for i := 0; i < b.N; i++ {
+		_, _ = e.(*testError)
+	}
+}
+
+func BenchmarkMapLookup(b *testing.B) {
+	m := map[LayerType]bool{
+		LayerTypePayload: true,
+	}
+	for i := 0; i < b.N; i++ {
+		_ = m[LayerTypePayload]
+	}
+}
+
+func BenchmarkNilMapLookup(b *testing.B) {
+	var m map[LayerType]bool
+	for i := 0; i < b.N; i++ {
+		_ = m[LayerTypePayload]
+	}
+}
+
+func BenchmarkNilMapLookupWithNilCheck(b *testing.B) {
+	var m map[LayerType]bool
+	for i := 0; i < b.N; i++ {
+		if m != nil {
+			_ = m[LayerTypePayload]
+		}
+	}
+}
+
+func BenchmarkArrayLookup(b *testing.B) {
+	m := make([]bool, 100)
+	for i := 0; i < b.N; i++ {
+		_ = m[LayerTypePayload]
+	}
+}
+
+var testError1 = &testError{}
+var testError2 error = testError1
+
+func BenchmarkTypeToInterface1(b *testing.B) {
+	var e error
+	for i := 0; i < b.N; i++ {
+		e = testError1
+	}
+	// Have to do someting with 'e' or the compiler complains about an unused
+	// variable.
+	testError2 = e
+}
+func BenchmarkTypeToInterface2(b *testing.B) {
+	var e error
+	for i := 0; i < b.N; i++ {
+		e = testError2
+	}
+	// Have to do someting with 'e' or the compiler complains about an unused
+	// variable.
+	testError2 = e
+}
+
+var decodeOpts DecodeOptions
+
+func decodeOptsByValue(_ DecodeOptions)    {}
+func decodeOptsByPointer(_ *DecodeOptions) {}
+func BenchmarkPassDecodeOptionsByValue(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		decodeOptsByValue(decodeOpts)
+	}
+}
+func BenchmarkPassDecodeOptionsByPointer(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		decodeOptsByPointer(&decodeOpts)
+	}
+}
+
+func BenchmarkLockOSThread(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		runtime.LockOSThread()
+	}
+}
+func BenchmarkUnlockOSThread(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		runtime.UnlockOSThread()
+	}
+}
+func lockUnlock() {
+	runtime.LockOSThread()
+	runtime.UnlockOSThread()
+}
+func lockDeferUnlock() {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+}
+func BenchmarkLockUnlockOSThread(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		lockUnlock()
+	}
+}
+func BenchmarkLockDeferUnlockOSThread(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		lockDeferUnlock()
+	}
+}
+
+func BenchmarkUnbufferedChannel(b *testing.B) {
+	ca := make(chan bool)
+	cb := make(chan bool)
+	defer close(ca)
+	go func() {
+		defer close(cb)
+		for range ca {
+			cb <- true
+		}
+	}()
+	for i := 0; i < b.N; i++ {
+		ca <- true
+		<-cb
+	}
+}
+func BenchmarkSmallBufferedChannel(b *testing.B) {
+	ca := make(chan bool, 1)
+	cb := make(chan bool, 1)
+	defer close(ca)
+	go func() {
+		defer close(cb)
+		for range ca {
+			cb <- true
+		}
+	}()
+	for i := 0; i < b.N; i++ {
+		ca <- true
+		<-cb
+	}
+}
+func BenchmarkLargeBufferedChannel(b *testing.B) {
+	ca := make(chan bool, 1000)
+	cb := make(chan bool, 1000)
+	defer close(ca)
+	go func() {
+		defer close(cb)
+		for range ca {
+			cb <- true
+		}
+	}()
+	for i := 0; i < b.N; i++ {
+		ca <- true
+		<-cb
+	}
+}
+func BenchmarkEndpointFastHashShort(b *testing.B) {
+	e := Endpoint{typ: 1, len: 2}
+	for i := 0; i < b.N; i++ {
+		e.FastHash()
+	}
+}
+func BenchmarkEndpointFastHashLong(b *testing.B) {
+	e := Endpoint{typ: 1, len: 16}
+	for i := 0; i < b.N; i++ {
+		e.FastHash()
+	}
+}
+func BenchmarkFlowFastHashShort(b *testing.B) {
+	e := Flow{typ: 1, slen: 2, dlen: 2}
+	for i := 0; i < b.N; i++ {
+		e.FastHash()
+	}
+}
+func BenchmarkFlowFastHashLong(b *testing.B) {
+	e := Flow{typ: 1, slen: 16, dlen: 16}
+	for i := 0; i < b.N; i++ {
+		e.FastHash()
+	}
+}

vendor/github.com/google/gopacket/doc.go

@@ -208,7 +208,7 @@ based on endpoint criteria:
    }
  }
  // Find all packets coming from UDP port 1000 to UDP port 500
- interestingFlow := gopacket.NewFlow(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500))
+ interestingFlow := gopacket.FlowFromEndpoints(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500))
  if t := packet.NetworkLayer(); t != nil && t.TransportFlow() == interestingFlow {
    fmt.Println("Found that UDP flow I was looking for!")
  }

vendor/github.com/google/gopacket/gen.go

@@ -1,75 +0,0 @@
-// Copyright 2019 The GoPacket Authors. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the LICENSE file in the root of the source
-// tree.
-
-// +build ignore
-
-// This file generates LayersDecoder function for DecodingLayerContainer
-// go run gen.go | gofmt > layers_decoder.go
-package main
-
-import (
-	"fmt"
-	"os"
-	"time"
-)
-
-const headerFmt = `// Copyright 2019 The GoPacket Authors. All rights reserved.
-
-package gopacket
-
-// Created by gen.go, don't edit manually
-// Generated at %s
-
-// LayersDecoder returns DecodingLayerFunc for specified
-// DecodingLayerContainer, LayerType value to start decoding with and
-// some DecodeFeedback.
-func LayersDecoder(dl DecodingLayerContainer, first LayerType, df DecodeFeedback) DecodingLayerFunc {
-  firstDec, ok := dl.Decoder(first)
-  if !ok {
-    return func([]byte, *[]LayerType) (LayerType, error) {
-      return first, nil
-    }
-  }
-`
-
-var funcBody = `return func(data []byte, decoded *[]LayerType) (LayerType, error) {
-  *decoded = (*decoded)[:0] // Truncated decoded layers.
-  typ := first
-  decoder := firstDec
-  for {
-    if err := decoder.DecodeFromBytes(data, df); err != nil {
-      return LayerTypeZero, err
-    }
-    *decoded = append(*decoded, typ)
-    typ = decoder.NextLayerType()
-    if data = decoder.LayerPayload(); len(data) == 0 {
-      break
-    }
-    if decoder, ok = dlc.Decoder(typ); !ok {
-      return typ, nil
-    }
-  }
-  return LayerTypeZero, nil
-}`
-
-func main() {
-	fmt.Fprintf(os.Stderr, "Writing results to stdout\n")
-	types := []string{
-		"DecodingLayerSparse",
-		"DecodingLayerArray",
-		"DecodingLayerMap",
-	}
-
-	fmt.Printf(headerFmt, time.Now())
-	for _, t := range types {
-		fmt.Printf("if dlc, ok := dl.(%s); ok {", t)
-		fmt.Println(funcBody)
-		fmt.Println("}")
-	}
-	fmt.Println("dlc := dl")
-	fmt.Println(funcBody)
-	fmt.Println("}")
-}

vendor/github.com/google/gopacket/go.mod

@@ -3,6 +3,9 @@ module github.com/google/gopacket
 go 1.12
 
 require (
-	golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3
+	github.com/vishvananda/netlink v1.1.0
-	golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67
+	github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f
+	golang.org/x/lint v0.0.0-20200302205851-738671d3881b // indirect
+	golang.org/x/net v0.0.0-20190620200207-3b0461eec859
+	golang.org/x/sys v0.0.0-20200217220822-9197077df867
 )

vendor/github.com/google/gopacket/go.sum

@@ -1,7 +1,27 @@
+github.com/vishvananda/netlink v1.1.0 h1:1iyaYNBLmP6L0220aDnYQpo1QEV4t4hJ+xEEhhJH8j0=
+github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
+github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
+github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f h1:p4VB7kIXpOQvVn1ZaTIVp+3vuYAXFe3OJEvjbUYJLaA=
+github.com/vishvananda/netns v0.0.0-20210104183010-2eb08e3e575f/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67 h1:1Fzlr8kkDLQwqMP8GxrhptBLqZG/EDpiATneiZHY998=
 golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200217220822-9197077df867 h1:JoRuNIf+rpHl+VhScRQQvzbHed86tKkqwPMV34T8myw=
+golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7 h1:EBZoQjiKKPaLbPrbpssUfuHtwM6KV/vb4U85g/cigFY=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

vendor/github.com/google/gopacket/packet_test.go

@@ -0,0 +1,62 @@
+// Copyright 2012 Google, Inc. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree.
+
+package gopacket
+
+import (
+	"io"
+	"reflect"
+	"testing"
+)
+
+type embedded struct {
+	A, B int
+}
+
+type embedding struct {
+	embedded
+	C, D int
+}
+
+func TestDumpEmbedded(t *testing.T) {
+	e := embedding{embedded: embedded{A: 1, B: 2}, C: 3, D: 4}
+	if got, want := layerString(reflect.ValueOf(e), false, false), "{A=1 B=2 C=3 D=4}"; got != want {
+		t.Errorf("embedded dump mismatch:\n   got: %v\n  want: %v", got, want)
+	}
+}
+
+type singlePacketSource [1][]byte
+
+func (s *singlePacketSource) ReadPacketData() ([]byte, CaptureInfo, error) {
+	if (*s)[0] == nil {
+		return nil, CaptureInfo{}, io.EOF
+	}
+	out := (*s)[0]
+	(*s)[0] = nil
+	return out, CaptureInfo{}, nil
+}
+
+func TestConcatPacketSources(t *testing.T) {
+	sourceA := &singlePacketSource{[]byte{1}}
+	sourceB := &singlePacketSource{[]byte{2}}
+	sourceC := &singlePacketSource{[]byte{3}}
+	concat := ConcatFinitePacketDataSources(sourceA, sourceB, sourceC)
+	a, _, err := concat.ReadPacketData()
+	if err != nil || len(a) != 1 || a[0] != 1 {
+		t.Errorf("expected [1], got %v/%v", a, err)
+	}
+	b, _, err := concat.ReadPacketData()
+	if err != nil || len(b) != 1 || b[0] != 2 {
+		t.Errorf("expected [2], got %v/%v", b, err)
+	}
+	c, _, err := concat.ReadPacketData()
+	if err != nil || len(c) != 1 || c[0] != 3 {
+		t.Errorf("expected [3], got %v/%v", c, err)
+	}
+	if _, _, err := concat.ReadPacketData(); err != io.EOF {
+		t.Errorf("expected io.EOF, got %v", err)
+	}
+}

vendor/github.com/google/gopacket/time_test.go

@@ -0,0 +1,73 @@
+// Copyright 2019 The GoPacket Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree.
+
+package gopacket
+
+import (
+	"testing"
+	"time"
+)
+
+func TestToDuration(t *testing.T) {
+	for i, test := range []struct {
+		r TimestampResolution
+		d time.Duration
+	}{
+		{
+			TimestampResolutionMillisecond,
+			time.Millisecond,
+		},
+		{
+			TimestampResolutionMicrosecond,
+			time.Microsecond,
+		},
+		{
+			TimestampResolutionNanosecond,
+			time.Nanosecond,
+		},
+		{
+			TimestampResolutionNTP,
+			0, // this is not representable since it's ~0.233 nanoseconds
+		},
+		{
+			TimestampResolution{2, -16},
+			15258,
+		},
+		{
+			TimestampResolution{2, 1},
+			2 * time.Second,
+		},
+		{
+			TimestampResolution{10, 1},
+			10 * time.Second,
+		},
+		{
+			TimestampResolution{10, 0},
+			time.Second,
+		},
+		{
+			TimestampResolution{2, 0},
+			time.Second,
+		},
+		{
+			TimestampResolution{0, 0},
+			0,
+		},
+		{
+			TimestampResolution{3, 2},
+			9 * time.Second,
+		},
+		{
+			TimestampResolution{3, -2},
+			111111111,
+		},
+	} {
+		d := test.r.ToDuration()
+		if d != test.d {
+			t.Errorf("%d: resolution: %s want: %d got: %d", i, test.r, test.d, d)
+		}
+	}
+}

vendor/github.com/google/gopacket/writer_test.go

@@ -0,0 +1,94 @@
+// Copyright 2012 Google, Inc. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree.
+
+package gopacket
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestExponentialSizeIncreasePrepend(t *testing.T) {
+	var b serializeBuffer
+	for i, test := range []struct {
+		prepend, size int
+	}{
+		{2, 2},
+		{2, 4},
+		{2, 8},
+		{2, 8},
+		{2, 16},
+		{2, 16},
+		{2, 16},
+		{2, 16},
+		{2, 32},
+	} {
+		b.PrependBytes(test.prepend)
+		if test.size != cap(b.data) {
+			t.Error(i, "size want", test.size, "got", cap(b.data))
+		}
+	}
+	b.Clear()
+	if b.start != 32 {
+		t.Error(b.start)
+	}
+}
+
+func TestExponentialSizeIncreaseAppend(t *testing.T) {
+	var b serializeBuffer
+	for i, test := range []struct {
+		appnd, size int
+	}{
+		{2, 2},
+		{2, 4},
+		{2, 8},
+		{2, 8},
+		{2, 16},
+		{2, 16},
+		{2, 16},
+		{2, 16},
+		{2, 32},
+	} {
+		b.AppendBytes(test.appnd)
+		if test.size != cap(b.data) {
+			t.Error(i, "size want", test.size, "got", cap(b.data))
+		}
+	}
+	b.Clear()
+	if b.start != 0 {
+		t.Error(b.start)
+	}
+}
+
+func ExampleSerializeBuffer() {
+	b := NewSerializeBuffer()
+	fmt.Println("1:", b.Bytes())
+	bytes, _ := b.PrependBytes(3)
+	copy(bytes, []byte{1, 2, 3})
+	fmt.Println("2:", b.Bytes())
+	bytes, _ = b.AppendBytes(2)
+	copy(bytes, []byte{4, 5})
+	fmt.Println("3:", b.Bytes())
+	bytes, _ = b.PrependBytes(1)
+	copy(bytes, []byte{0})
+	fmt.Println("4:", b.Bytes())
+	bytes, _ = b.AppendBytes(3)
+	copy(bytes, []byte{6, 7, 8})
+	fmt.Println("5:", b.Bytes())
+	b.Clear()
+	fmt.Println("6:", b.Bytes())
+	bytes, _ = b.PrependBytes(2)
+	copy(bytes, []byte{9, 9})
+	fmt.Println("7:", b.Bytes())
+	// Output:
+	// 1: []
+	// 2: [1 2 3]
+	// 3: [1 2 3 4 5]
+	// 4: [0 1 2 3 4 5]
+	// 5: [0 1 2 3 4 5 6 7 8]
+	// 6: []
+	// 7: [9 9]
+}

vendor/vendor.json

@@ -0,0 +1,19 @@
+{
+	"comment": "",
+	"ignore": "",
+	"package": [
+		{
+			"checksumSHA1": "yUc84k7cfnRi9AlPFuRo77Y18Og=",
+			"path": "github.com/golang/glog",
+			"revision": "23def4e6c14b4da8ac2ed8007337bc5eb5007998",
+			"revisionTime": "2016-01-25T20:49:56Z"
+		},
+		{
+			"checksumSHA1": "X5ivYXvxs8wLkNqaPMBcuzNKEv4=",
+			"path": "github.com/google/gopacket",
+			"revision": "3eaba08943250fd212520e5cff00ed808b8fc60a",
+			"revisionTime": "2021-04-29T15:22:48Z"
+		}
+	],
+	"rootPath": "github.com/zr-hebo/sniffer-agent"
+}