vendor/github.com/google/gopacket/reassembly/cap2test.go

   1 // Copyright 2012 Google, Inc. All rights reserved.
   2 //
   3 // Use of this source code is governed by a BSD-style license
   4 // that can be found in the LICENSE file in the root of the source
   5 // tree.
   6
   7 // +build ignore
   8
   9 package main
  10
  11 import (
  12         "bytes"
  13         "flag"
  14         "fmt"
  15         "log"
  16         "os"
  17         "strings"
  18
  19         "github.com/google/gopacket"
  20         "github.com/google/gopacket/layers"
  21         "github.com/google/gopacket/pcap"
  22 )
  23
  24 var input = flag.String("i", "", "Input filename")
  25
  26 func main() {
  27         var handler *pcap.Handle
  28         var err error
  29         flag.Parse()
  30         if *input == "" {
  31                 log.Fatalf("Please specify input filename")
  32         }
  33         if handler, err = pcap.OpenOffline(*input); err != nil {
  34                 log.Fatalf("Failed to open: %s: %s", *input, err)
  35         }
  36         args := flag.Args()
  37         if len(args) > 0 {
  38                 filter := strings.Join(args, " ")
  39                 if err := handler.SetBPFFilter(filter); err != nil {
  40                         log.Fatalf("Failed to set BPF filter \"%s\": %s", filter, err)
  41                 }
  42                 handler.Stats()
  43         }
  44         var decoder gopacket.Decoder
  45         var ok bool
  46         linkType := fmt.Sprintf("%s", handler.LinkType())
  47         if decoder, ok = gopacket.DecodersByLayerName[linkType]; !ok {
  48                 log.Fatalf("Failed to find decoder to pcap's linktype %s", linkType)
  49         }
  50         source := gopacket.NewPacketSource(handler, decoder)
  51         count := uint64(0)
  52         pktNonTcp := uint64(0)
  53         pktTcp := uint64(0)
  54         fmt.Println("test([]testSequence{")
  55         for packet := range source.Packets() {
  56                 count++
  57                 tcp := packet.Layer(layers.LayerTypeTCP)
  58                 if tcp == nil {
  59                         pktNonTcp++
  60                         continue
  61                 } else {
  62                         pktTcp++
  63                         tcp := tcp.(*layers.TCP)
  64                         //fmt.Printf("packet: %s\n", tcp)
  65                         var b bytes.Buffer
  66                         b.WriteString("{\n")
  67                         // TCP
  68                         b.WriteString("tcp: layers.TCP{\n")
  69                         if tcp.SYN {
  70                                 b.WriteString("  SYN: true,\n")
  71                         }
  72                         if tcp.ACK {
  73                                 b.WriteString("  ACK: true,\n")
  74                         }
  75                         if tcp.RST {
  76                                 b.WriteString("  RST: true,\n")
  77                         }
  78                         if tcp.FIN {
  79                                 b.WriteString("  FIN: true,\n")
  80                         }
  81                         b.WriteString(fmt.Sprintf("  SrcPort: %d,\n", tcp.SrcPort))
  82                         b.WriteString(fmt.Sprintf("  DstPort: %d,\n", tcp.DstPort))
  83                         b.WriteString(fmt.Sprintf("  Seq: %d,\n", tcp.Seq))
  84                         b.WriteString(fmt.Sprintf("  Ack: %d,\n", tcp.Ack))
  85                         b.WriteString("  BaseLayer: layers.BaseLayer{Payload: []byte{")
  86                         for _, p := range tcp.Payload {
  87                                 b.WriteString(fmt.Sprintf("%d,", p))
  88                         }
  89                         b.WriteString("}},\n")
  90                         b.WriteString("},\n")
  91                         // CaptureInfo
  92                         b.WriteString("ci: gopacket.CaptureInfo{\n")
  93                         ts := packet.Metadata().CaptureInfo.Timestamp
  94                         b.WriteString(fmt.Sprintf("  Timestamp: time.Unix(%d,%d),\n", ts.Unix(), ts.Nanosecond()))
  95                         b.WriteString("},\n")
  96                         // Struct
  97                         b.WriteString("},\n")
  98                         fmt.Print(b.String())
  99                 }
 100
 101         }
 102         fmt.Println("})")
 103
 104         fmt.Fprintf(os.Stderr, "Total: %d, TCP: %d, non-TCP: %d\n", count, pktTcp, pktNonTcp)
 105 }