github.com/gopacket/gopacket@v1.1.0/pcapgo/read_test.go (about)

     1  // Copyright 2014 Damjan Cvetko. 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  package pcapgo
     7  
     8  import (
     9  	"bytes"
    10  	"testing"
    11  	"time"
    12  )
    13  
    14  // test header read
    15  func TestCreatePcapReader(t *testing.T) {
    16  	test := []byte{
    17  		0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00,
    18  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    19  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
    20  	}
    21  	buf := bytes.NewBuffer(test)
    22  	_, err := NewReader(buf)
    23  	if err != nil {
    24  		t.Error(err)
    25  		t.FailNow()
    26  	}
    27  }
    28  
    29  // test big endian file read
    30  func TestCreatePcapReaderBigEndian(t *testing.T) {
    31  	test := []byte{
    32  		0xa1, 0xb2, 0xc3, 0xd4, 0x00, 0x02, 0x00, 0x04,
    33  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    34  		0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01,
    35  	}
    36  	buf := bytes.NewBuffer(test)
    37  	_, err := NewReader(buf)
    38  	if err != nil {
    39  		t.Error(err)
    40  		t.FailNow()
    41  	}
    42  }
    43  
    44  // test opening invalid data
    45  func TestCreatePcapReaderFail(t *testing.T) {
    46  	test := []byte{
    47  		0xd0, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00,
    48  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    49  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
    50  	}
    51  	buf := bytes.NewBuffer(test)
    52  	_, err := NewReader(buf)
    53  	if err == nil {
    54  		t.Error("Should fail but did not")
    55  		t.FailNow()
    56  	}
    57  }
    58  
    59  func TestPacket(t *testing.T) {
    60  	test := []byte{
    61  		0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min
    62  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs
    63  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType
    64  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
    65  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
    66  		0x01, 0x02, 0x03, 0x04, // data
    67  	}
    68  
    69  	buf := bytes.NewBuffer(test)
    70  	r, err := NewReader(buf)
    71  	if err != nil {
    72  		t.Errorf("Failed to get new reader object: %v", err)
    73  	}
    74  
    75  	data, ci, err := r.ReadPacketData()
    76  	if err != nil {
    77  		t.Error(err)
    78  		t.FailNow()
    79  	}
    80  	if !ci.Timestamp.Equal(time.Date(2014, 9, 18, 12, 13, 14, 1000, time.UTC)) {
    81  		t.Error("Invalid time read")
    82  		t.FailNow()
    83  	}
    84  	if ci.CaptureLength != 4 || ci.Length != 8 {
    85  		t.Error("Invalid CapLen or Len")
    86  	}
    87  	want := []byte{1, 2, 3, 4}
    88  	if !bytes.Equal(data, want) {
    89  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data)
    90  	}
    91  }
    92  
    93  func TestPacketNano(t *testing.T) {
    94  	test := []byte{
    95  		0x4d, 0x3c, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min
    96  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs
    97  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType
    98  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
    99  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
   100  		0x01, 0x02, 0x03, 0x04, // data
   101  	}
   102  
   103  	buf := bytes.NewBuffer(test)
   104  	r, err := NewReader(buf)
   105  	if err != nil {
   106  		t.Errorf("Failed to get new reader object: %v", err)
   107  	}
   108  
   109  	data, ci, err := r.ReadPacketData()
   110  	if err != nil {
   111  		t.Error(err)
   112  		t.FailNow()
   113  	}
   114  	if !ci.Timestamp.Equal(time.Date(2014, 9, 18, 12, 13, 14, 1, time.UTC)) {
   115  		t.Error("Invalid time read")
   116  		t.FailNow()
   117  	}
   118  	if ci.CaptureLength != 4 || ci.Length != 8 {
   119  		t.Error("Invalid CapLen or Len")
   120  	}
   121  	want := []byte{1, 2, 3, 4}
   122  	if !bytes.Equal(data, want) {
   123  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data)
   124  	}
   125  }
   126  
   127  func TestGzipPacket(t *testing.T) {
   128  	test := []byte{
   129  		0x1f, 0x8b, 0x08, 0x08, 0x92, 0x4d, 0x81, 0x57,
   130  		0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xbb,
   131  		0x72, 0x78, 0xd3, 0x42, 0x26, 0x06, 0x16, 0x06,
   132  		0x18, 0xf8, 0xff, 0x9f, 0x81, 0x81, 0x11, 0x48,
   133  		0x47, 0x9d, 0x91, 0x0a, 0x01, 0xd1, 0x20, 0x19,
   134  		0x0e, 0x20, 0x66, 0x64, 0x62, 0x66, 0x01, 0x00,
   135  		0xe4, 0x76, 0x9b, 0x75, 0x2c, 0x00, 0x00, 0x00,
   136  	}
   137  	buf := bytes.NewBuffer(test)
   138  	r, err := NewReader(buf)
   139  	if err != nil {
   140  		t.Error("Unexpected error returned:", err)
   141  		t.FailNow()
   142  	}
   143  
   144  	data, ci, err := r.ReadPacketData()
   145  	if err != nil {
   146  		t.Error(err)
   147  		t.FailNow()
   148  	}
   149  	if !ci.Timestamp.Equal(time.Date(2014, 9, 18, 12, 13, 14, 1000, time.UTC)) {
   150  		t.Error("Invalid time read")
   151  		t.FailNow()
   152  	}
   153  	if ci.CaptureLength != 4 || ci.Length != 8 {
   154  		t.Error("Invalid CapLen or Len")
   155  	}
   156  	want := []byte{1, 2, 3, 4}
   157  	if !bytes.Equal(data, want) {
   158  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data)
   159  	}
   160  }
   161  
   162  func TestTruncatedGzipPacket(t *testing.T) {
   163  	test := []byte{
   164  		0x1f, 0x8b, 0x08,
   165  	}
   166  	buf := bytes.NewBuffer(test)
   167  	_, err := NewReader(buf)
   168  	if err == nil {
   169  		t.Error("Should fail but did not")
   170  		t.FailNow()
   171  	}
   172  }
   173  
   174  func TestPacketBufferReuse(t *testing.T) {
   175  	test := []byte{
   176  		0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min
   177  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs
   178  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType
   179  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
   180  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
   181  		0x01, 0x02, 0x03, 0x04, // data
   182  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
   183  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
   184  		0x01, 0x02, 0x03, 0x04, // data
   185  	}
   186  
   187  	buf := bytes.NewBuffer(test)
   188  	r, err := NewReader(buf)
   189  	if err != nil {
   190  		t.Errorf("Failed to get new reader object: %v", err)
   191  	}
   192  
   193  	data1, _, err := r.ReadPacketData()
   194  	if err != nil {
   195  		t.Error(err)
   196  		t.FailNow()
   197  	}
   198  	if want := []byte{1, 2, 3, 4}; !bytes.Equal(data1, want) {
   199  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data1)
   200  	}
   201  	data2, _, err := r.ReadPacketData()
   202  	if err != nil {
   203  		t.Error(err)
   204  		t.FailNow()
   205  	}
   206  	for i := range data1 {
   207  		data1[i] = 0xff // modify data1 after getting data2, make sure we don't overlap buffers.
   208  	}
   209  	if want := []byte{1, 2, 3, 4}; !bytes.Equal(data2, want) {
   210  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data2)
   211  	}
   212  }
   213  
   214  func TestPacketZeroCopy(t *testing.T) {
   215  	test := []byte{
   216  		0xd4, 0xc3, 0xb2, 0xa1, 0x02, 0x00, 0x04, 0x00, // magic, maj, min
   217  		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // tz, sigfigs
   218  		0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // snaplen, linkType
   219  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
   220  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
   221  		0x01, 0x02, 0x03, 0x04, // data
   222  		0x5A, 0xCC, 0x1A, 0x54, 0x01, 0x00, 0x00, 0x00, // sec, usec
   223  		0x04, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, // cap len, full len
   224  		0x05, 0x06, 0x07, 0x08, // data
   225  	}
   226  
   227  	buf := bytes.NewBuffer(test)
   228  	r, err := NewReader(buf)
   229  	if err != nil {
   230  		t.Errorf("Failed to get new reader object: %v", err)
   231  	}
   232  
   233  	data1, _, err := r.ZeroCopyReadPacketData()
   234  	if err != nil {
   235  		t.Error(err)
   236  		t.FailNow()
   237  	}
   238  	if want := []byte{1, 2, 3, 4}; !bytes.Equal(data1, want) {
   239  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data1)
   240  	}
   241  	data2, _, err := r.ZeroCopyReadPacketData()
   242  	if err != nil {
   243  		t.Error(err)
   244  		t.FailNow()
   245  	}
   246  	if want := []byte{5, 6, 7, 8}; !bytes.Equal(data2, want) {
   247  		t.Errorf("buf mismatch:\nwant: %+v\ngot:  %+v", want, data2)
   248  	}
   249  
   250  	if &data1[0] != &data2[0] {
   251  		t.Error("different buffers returned by subsequent ZeroCopyReadPacketData calls")
   252  	}
   253  }