add windows support
This commit is contained in:
xiaobiao
parent
87a877750f
commit
43c68ecf2f
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,11 @@
|
|||
package capture
|
||||
|
||||
import (
|
||||
"github.com/google/gopacket/layers"
|
||||
)
|
||||
|
||||
type TCPIPPair struct {
|
||||
srcIP string
|
||||
dstIP string
|
||||
tcpPkt *layers.TCP
|
||||
}
|
||||
|
|
@ -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()
|
||||
|
||||
for {
|
||||
var data []byte
|
||||
var ci gopacket.CaptureInfo
|
||||
var err error
|
||||
|
||||
dealTCPIPPacket := func(tcpIPPkt *TCPIPPair) {
|
||||
// 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
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"
|
||||
)
|
||||
|
||||
|
|
|
|||
32
main.go
32
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() {
|
||||
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 initLog() {
|
||||
}
|
||||
|
||||
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()
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
@ -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.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ See [godoc](https://godoc.org/github.com/google/gopacket) for more details.
|
|||
[](https://travis-ci.org/google/gopacket)
|
||||
[](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).
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
}
|
||||
}
|
||||
|
|
@ -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!")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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("}")
|
||||
}
|
||||
|
|
@ -3,6 +3,9 @@ module github.com/google/gopacket
|
|||
go 1.12
|
||||
|
||||
require (
|
||||
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3
|
||||
golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67
|
||||
github.com/vishvananda/netlink v1.1.0
|
||||
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
|
||||
)
|
||||
|
|
|
|||
|
|
@ -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=
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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]
|
||||
}
|
||||
|
|
@ -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"
|
||||
}
|
||||
Loading…
Reference in New Issue