vendor/github.com/google/gopacket/reassembly/tcpassembly_test.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 package reassembly
   8
   9 import (
  10         "encoding/hex"
  11         "fmt"
  12         "net"
  13         "reflect"
  14         "runtime"
  15         "testing"
  16         "time"
  17
  18         "github.com/google/gopacket"
  19         "github.com/google/gopacket/layers"
  20 )
  21
  22 var netFlow gopacket.Flow
  23
  24 var testDebug = false
  25
  26 func init() {
  27         netFlow, _ = gopacket.FlowFromEndpoints(
  28                 layers.NewIPEndpoint(net.IP{1, 2, 3, 4}),
  29                 layers.NewIPEndpoint(net.IP{5, 6, 7, 8}))
  30 }
  31
  32 type Reassembly struct {
  33         Bytes []byte
  34         Start bool
  35         End   bool
  36         Skip  int
  37 }
  38
  39 type testSequence struct {
  40         in   layers.TCP
  41         want []Reassembly
  42 }
  43
  44 /* For benchmark: do nothing */
  45 type testFactoryBench struct {
  46 }
  47
  48 func (t *testFactoryBench) New(a, b gopacket.Flow, tcp *layers.TCP, ac AssemblerContext) Stream {
  49         return t
  50 }
  51 func (t *testFactoryBench) Accept(tcp *layers.TCP, ci gopacket.CaptureInfo, dir TCPFlowDirection, seq Sequence, start *bool, ac AssemblerContext) bool {
  52         return true
  53 }
  54 func (t *testFactoryBench) ReassembledSG(sg ScatterGather, ac AssemblerContext) {
  55 }
  56 func (t *testFactoryBench) ReassemblyComplete(ac AssemblerContext) bool {
  57         return true
  58 }
  59
  60 /* For tests: append bytes */
  61 type testFactory struct {
  62         reassembly []Reassembly
  63 }
  64
  65 func (t *testFactory) New(a, b gopacket.Flow, tcp *layers.TCP, ac AssemblerContext) Stream {
  66         return t
  67 }
  68 func (t *testFactory) Reassembled(r []Reassembly) {
  69         t.reassembly = r
  70         for i := 0; i < len(r); i++ {
  71                 //t.reassembly[i].Seen = time.Time{}
  72         }
  73 }
  74 func (t *testFactory) ReassembledSG(sg ScatterGather, ac AssemblerContext) {
  75         _, start, end, skip := sg.Info()
  76         l, _ := sg.Lengths()
  77         t.reassembly = append(t.reassembly, Reassembly{
  78                 Bytes: sg.Fetch(l),
  79                 Skip:  skip,
  80                 Start: start,
  81                 End:   end,
  82         })
  83 }
  84
  85 func (t *testFactory) ReassemblyComplete(ac AssemblerContext) bool {
  86         return true
  87 }
  88
  89 func (t *testFactory) Accept(tcp *layers.TCP, ci gopacket.CaptureInfo, dir TCPFlowDirection, seq Sequence, start *bool, ac AssemblerContext) bool {
  90         return true
  91 }
  92
  93 /* For memory checks: counts bytes */
  94 type testMemoryFactory struct {
  95         bytes int
  96 }
  97
  98 func (tf *testMemoryFactory) New(a, b gopacket.Flow, tcp *layers.TCP, ac AssemblerContext) Stream {
  99         return tf
 100 }
 101 func (tf *testMemoryFactory) Accept(tcp *layers.TCP, ci gopacket.CaptureInfo, dir TCPFlowDirection, seq Sequence, start *bool, ac AssemblerContext) bool {
 102         return true
 103 }
 104 func (tf *testMemoryFactory) ReassembledSG(sg ScatterGather, ac AssemblerContext) {
 105         bytes, _ := sg.Lengths()
 106         tf.bytes += bytes
 107 }
 108 func (tf *testMemoryFactory) ReassemblyComplete(ac AssemblerContext) bool {
 109         return true
 110 }
 111
 112 /*
 113  * Tests
 114  */
 115
 116 func test(t *testing.T, s []testSequence) {
 117         fact := &testFactory{}
 118         p := NewStreamPool(fact)
 119         a := NewAssembler(p)
 120         a.MaxBufferedPagesPerConnection = 4
 121         for i, test := range s {
 122                 fact.reassembly = []Reassembly{}
 123                 if testDebug {
 124                         fmt.Printf("#### test: #%d: sending:%s\n", i, hex.EncodeToString(test.in.BaseLayer.Payload))
 125                 }
 126                 a.Assemble(netFlow, &test.in)
 127                 final := []Reassembly{}
 128                 if len(test.want) > 0 {
 129                         final = append(final, Reassembly{})
 130                         for _, w := range test.want {
 131                                 final[0].Bytes = append(final[0].Bytes, w.Bytes...)
 132                                 if w.End {
 133                                         final[0].End = true
 134                                 }
 135                                 if w.Start {
 136                                         final[0].Start = true
 137                                 }
 138                                 if w.Skip != 0 {
 139                                         final[0].Skip = w.Skip
 140                                 }
 141                         }
 142                 }
 143                 if !reflect.DeepEqual(fact.reassembly, final) {
 144                         t.Fatalf("test %v:\nwant: %v\n got: %v\n", i, final, fact.reassembly)
 145                 }
 146                 if testDebug {
 147                         fmt.Printf("test %v passing...(%s)\n", i, final)
 148                 }
 149         }
 150 }
 151
 152 func TestReorder(t *testing.T) {
 153         test(t, []testSequence{
 154                 {
 155                         in: layers.TCP{
 156                                 SrcPort:   1,
 157                                 DstPort:   2,
 158                                 Seq:       1001,
 159                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}},
 160                         },
 161                         want: []Reassembly{},
 162                 },
 163                 {
 164                         in: layers.TCP{
 165                                 SrcPort:   1,
 166                                 DstPort:   2,
 167                                 Seq:       1004,
 168                                 BaseLayer: layers.BaseLayer{Payload: []byte{4, 5, 6}},
 169                         },
 170                         want: []Reassembly{},
 171                 },
 172                 {
 173                         in: layers.TCP{
 174                                 SrcPort:   1,
 175                                 DstPort:   2,
 176                                 Seq:       1010,
 177                                 BaseLayer: layers.BaseLayer{Payload: []byte{10, 11, 12}},
 178                         },
 179                         want: []Reassembly{},
 180                 },
 181                 {
 182                         in: layers.TCP{
 183                                 SrcPort:   1,
 184                                 DstPort:   2,
 185                                 Seq:       1007,
 186                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9}},
 187                         },
 188                         want: []Reassembly{
 189                                 Reassembly{
 190                                         Skip:  -1,
 191                                         Bytes: []byte{1, 2, 3},
 192                                 },
 193                                 Reassembly{
 194                                         Bytes: []byte{4, 5, 6},
 195                                 },
 196                                 Reassembly{
 197                                         Bytes: []byte{7, 8, 9},
 198                                 },
 199                                 Reassembly{
 200                                         Bytes: []byte{10, 11, 12},
 201                                 },
 202                         },
 203                 },
 204                 {
 205                         in: layers.TCP{
 206                                 SrcPort:   1,
 207                                 DstPort:   2,
 208                                 Seq:       1016,
 209                                 BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}},
 210                         },
 211                         want: []Reassembly{},
 212                 },
 213                 {
 214                         in: layers.TCP{
 215                                 SrcPort:   1,
 216                                 DstPort:   2,
 217                                 Seq:       1019,
 218                                 BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}},
 219                         },
 220                         want: []Reassembly{},
 221                 },
 222                 {
 223                         in: layers.TCP{
 224                                 SrcPort:   1,
 225                                 DstPort:   2,
 226                                 Seq:       1013,
 227                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}},
 228                         },
 229                         want: []Reassembly{
 230                                 Reassembly{
 231                                         Bytes: []byte{1, 2, 3},
 232                                 },
 233                                 Reassembly{
 234                                         Bytes: []byte{2, 2, 3},
 235                                 },
 236                                 Reassembly{
 237                                         Bytes: []byte{3, 2, 3},
 238                                 },
 239                         },
 240                 },
 241         })
 242 }
 243
 244 func TestMaxPerSkip(t *testing.T) {
 245         test(t, []testSequence{
 246                 {
 247                         in: layers.TCP{
 248                                 SrcPort:   1,
 249                                 DstPort:   2,
 250                                 Seq:       1000,
 251                                 SYN:       true,
 252                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}},
 253                         },
 254                         want: []Reassembly{
 255                                 Reassembly{
 256                                         Start: true,
 257                                         Bytes: []byte{1, 2, 3},
 258                                 },
 259                         },
 260                 },
 261                 {
 262                         in: layers.TCP{
 263                                 SrcPort:   1,
 264                                 DstPort:   2,
 265                                 Seq:       1007,
 266                                 BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}},
 267                         },
 268                         want: []Reassembly{},
 269                 },
 270                 {
 271                         in: layers.TCP{
 272                                 SrcPort:   1,
 273                                 DstPort:   2,
 274                                 Seq:       1010,
 275                                 BaseLayer: layers.BaseLayer{Payload: []byte{4, 2, 3}},
 276                         },
 277                         want: []Reassembly{},
 278                 },
 279                 {
 280                         in: layers.TCP{
 281                                 SrcPort:   1,
 282                                 DstPort:   2,
 283                                 Seq:       1013,
 284                                 BaseLayer: layers.BaseLayer{Payload: []byte{5, 2, 3}},
 285                         },
 286                         want: []Reassembly{},
 287                 },
 288                 {
 289                         in: layers.TCP{
 290                                 SrcPort:   1,
 291                                 DstPort:   2,
 292                                 Seq:       1016,
 293                                 BaseLayer: layers.BaseLayer{Payload: []byte{6, 2, 3}},
 294                         },
 295                         want: []Reassembly{
 296                                 Reassembly{
 297                                         Skip:  3,
 298                                         Bytes: []byte{3, 2, 3},
 299                                 },
 300                                 Reassembly{
 301                                         Bytes: []byte{4, 2, 3},
 302                                 },
 303                                 Reassembly{
 304                                         Bytes: []byte{5, 2, 3},
 305                                 },
 306                                 Reassembly{
 307                                         Bytes: []byte{6, 2, 3},
 308                                 },
 309                         },
 310                 },
 311         })
 312 }
 313
 314 func TestReorderFast(t *testing.T) {
 315         test(t, []testSequence{
 316                 {
 317                         in: layers.TCP{
 318                                 SrcPort:   1,
 319                                 DstPort:   2,
 320                                 SYN:       true,
 321                                 Seq:       1000,
 322                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}},
 323                         },
 324                         want: []Reassembly{
 325                                 Reassembly{
 326                                         Start: true,
 327                                         Bytes: []byte{1, 2, 3},
 328                                 },
 329                         },
 330                 },
 331                 {
 332                         in: layers.TCP{
 333                                 SrcPort:   1,
 334                                 DstPort:   2,
 335                                 Seq:       1007,
 336                                 BaseLayer: layers.BaseLayer{Payload: []byte{3, 2, 3}},
 337                         },
 338                         want: []Reassembly{},
 339                 },
 340                 {
 341                         in: layers.TCP{
 342                                 SrcPort:   1,
 343                                 DstPort:   2,
 344                                 Seq:       1004,
 345                                 BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}},
 346                         },
 347                         want: []Reassembly{
 348                                 Reassembly{
 349                                         Bytes: []byte{2, 2, 3},
 350                                 },
 351                                 Reassembly{
 352                                         Bytes: []byte{3, 2, 3},
 353                                 },
 354                         },
 355                 },
 356         })
 357 }
 358
 359 func TestOverlap(t *testing.T) {
 360         test(t, []testSequence{
 361                 {
 362                         in: layers.TCP{
 363                                 SrcPort:   1,
 364                                 DstPort:   2,
 365                                 SYN:       true,
 366                                 Seq:       1000,
 367                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 368                         },
 369                         want: []Reassembly{
 370                                 Reassembly{
 371                                         Start: true,
 372                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 373                                 },
 374                         },
 375                 },
 376                 {
 377                         in: layers.TCP{
 378                                 SrcPort:   1,
 379                                 DstPort:   2,
 380                                 Seq:       1007,
 381                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}},
 382                         },
 383                         want: []Reassembly{
 384                                 Reassembly{
 385                                         Bytes: []byte{1, 2, 3, 4, 5},
 386                                 },
 387                         },
 388                 },
 389                 {
 390                         in: layers.TCP{
 391                                 SrcPort:   1,
 392                                 DstPort:   2,
 393                                 Seq:       1010,
 394                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 1, 2, 3, 4, 5, 6, 7}},
 395                         },
 396                         want: []Reassembly{
 397                                 Reassembly{
 398                                         Bytes: []byte{6, 7},
 399                                 },
 400                         },
 401                 },
 402         })
 403 }
 404
 405 func TestBufferedOverlap1(t *testing.T) {
 406         test(t, []testSequence{
 407                 {
 408                         in: layers.TCP{
 409                                 SrcPort:   1,
 410                                 DstPort:   2,
 411                                 Seq:       1007,
 412                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}},
 413                         },
 414                         want: []Reassembly{},
 415                 },
 416                 {
 417                         in: layers.TCP{
 418                                 SrcPort:   1,
 419                                 DstPort:   2,
 420                                 Seq:       1010,
 421                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 1, 2, 3, 4, 5, 6, 7}},
 422                         },
 423                         want: []Reassembly{},
 424                 },
 425                 {
 426                         in: layers.TCP{
 427                                 SrcPort:   1,
 428                                 DstPort:   2,
 429                                 SYN:       true,
 430                                 Seq:       1000,
 431                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 432                         },
 433                         want: []Reassembly{
 434                                 Reassembly{
 435                                         Start: true,
 436                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 437                                 },
 438                                 Reassembly{
 439                                         Bytes: []byte{1, 2, 3, 4, 5},
 440                                 },
 441                                 Reassembly{
 442                                         Bytes: []byte{6, 7},
 443                                 },
 444                         },
 445                 },
 446         })
 447 }
 448
 449 func TestBufferedOverlapCase6(t *testing.T) {
 450         test(t, []testSequence{
 451                 {
 452                         in: layers.TCP{
 453                                 SrcPort:   1,
 454                                 DstPort:   2,
 455                                 Seq:       1007,
 456                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}},
 457                         },
 458                         want: []Reassembly{},
 459                 },
 460                 {
 461                         in: layers.TCP{
 462                                 SrcPort:   1,
 463                                 DstPort:   2,
 464                                 Seq:       1010,
 465                                 BaseLayer: layers.BaseLayer{Payload: []byte{10, 11, 12, 13, 14}},
 466                         },
 467                         want: []Reassembly{},
 468                 },
 469                 {
 470                         in: layers.TCP{
 471                                 SrcPort:   1,
 472                                 DstPort:   2,
 473                                 SYN:       true,
 474                                 Seq:       1000,
 475                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 476                         },
 477                         want: []Reassembly{
 478                                 Reassembly{
 479                                         Start: true,
 480                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 481                                 },
 482                                 Reassembly{
 483                                         Bytes: []byte{11, 12, 13, 14, 5},
 484                                 },
 485                         },
 486                 },
 487         })
 488 }
 489
 490 func TestBufferedOverlapExisting(t *testing.T) {
 491         test(t, []testSequence{
 492                 {
 493                         in: layers.TCP{
 494                                 SrcPort:   1,
 495                                 DstPort:   2,
 496                                 Seq:       1000,
 497                                 SYN:       true,
 498                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7}},
 499                         },
 500                         want: []Reassembly{
 501                                 Reassembly{
 502                                         Start: true,
 503                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7},
 504                                 },
 505                         },
 506                 },
 507                 {
 508                         in: layers.TCP{
 509                                 SrcPort:   1,
 510                                 DstPort:   2,
 511                                 Seq:       1005,
 512                                 BaseLayer: layers.BaseLayer{Payload: []byte{5, 6, 7, 8, 9, 10}},
 513                         },
 514                         want: []Reassembly{
 515                                 Reassembly{
 516                                         Bytes: []byte{8, 9, 10},
 517                                 },
 518                         },
 519                 },
 520         })
 521 }
 522
 523 func TestBufferedOverlapReemit(t *testing.T) {
 524         test(t, []testSequence{
 525                 {
 526                         in: layers.TCP{
 527                                 SrcPort:   1,
 528                                 DstPort:   2,
 529                                 Seq:       1000,
 530                                 SYN:       true,
 531                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7}},
 532                         },
 533                         want: []Reassembly{
 534                                 Reassembly{
 535                                         Start: true,
 536                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7},
 537                                 },
 538                         },
 539                 },
 540                 {
 541                         in: layers.TCP{
 542                                 SrcPort:   1,
 543                                 DstPort:   2,
 544                                 Seq:       1003,
 545                                 BaseLayer: layers.BaseLayer{Payload: []byte{3, 4, 5}},
 546                         },
 547                         want: []Reassembly{},
 548                 },
 549         })
 550 }
 551
 552 func TestReorderRetransmission2(t *testing.T) {
 553         test(t, []testSequence{
 554                 {
 555                         in: layers.TCP{
 556                                 SrcPort:   1,
 557                                 DstPort:   2,
 558                                 Seq:       1001,
 559                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3}},
 560                         },
 561                         want: []Reassembly{},
 562                 },
 563                 {
 564                         in: layers.TCP{
 565                                 SrcPort:   1,
 566                                 DstPort:   2,
 567                                 Seq:       1007,
 568                                 BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}},
 569                         },
 570                         want: []Reassembly{},
 571                 },
 572                 {
 573                         in: layers.TCP{
 574                                 SrcPort:   1,
 575                                 DstPort:   2,
 576                                 Seq:       1007,
 577                                 BaseLayer: layers.BaseLayer{Payload: []byte{2, 2, 3}},
 578                         },
 579                         want: []Reassembly{},
 580                 },
 581                 {
 582                         in: layers.TCP{
 583                                 SrcPort:   1,
 584                                 DstPort:   2,
 585                                 Seq:       1010,
 586                                 BaseLayer: layers.BaseLayer{Payload: []byte{10, 11}},
 587                         },
 588                         want: []Reassembly{},
 589                 },
 590                 {
 591                         in: layers.TCP{
 592                                 SrcPort:   1,
 593                                 DstPort:   2,
 594                                 Seq:       1004,
 595                                 BaseLayer: layers.BaseLayer{Payload: []byte{6, 6, 6, 2, 2}},
 596                         },
 597                         want: []Reassembly{
 598                                 Reassembly{
 599                                         Skip:  -1,
 600                                         Bytes: []byte{1, 2, 3},
 601                                 },
 602                                 Reassembly{
 603                                         Bytes: []byte{6, 6, 6},
 604                                 },
 605                                 Reassembly{
 606                                         Bytes: []byte{2, 2, 3},
 607                                 },
 608                                 Reassembly{
 609                                         Bytes: []byte{10, 11},
 610                                 },
 611                         },
 612                 },
 613         })
 614 }
 615
 616 func TestOverrun1(t *testing.T) {
 617         test(t, []testSequence{
 618                 {
 619                         in: layers.TCP{
 620                                 SrcPort:   1,
 621                                 DstPort:   2,
 622                                 SYN:       true,
 623                                 Seq:       0xFFFFFFFF,
 624                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 625                         },
 626                         want: []Reassembly{
 627                                 Reassembly{
 628                                         Start: true,
 629                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 630                                 },
 631                         },
 632                 },
 633                 {
 634                         in: layers.TCP{
 635                                 SrcPort:   1,
 636                                 DstPort:   2,
 637                                 Seq:       10,
 638                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4}},
 639                         },
 640                         want: []Reassembly{
 641                                 Reassembly{
 642                                         Bytes: []byte{1, 2, 3, 4},
 643                                 },
 644                         },
 645                 },
 646         })
 647 }
 648
 649 func TestOverrun2(t *testing.T) {
 650         test(t, []testSequence{
 651                 {
 652                         in: layers.TCP{
 653                                 SrcPort:   1,
 654                                 DstPort:   2,
 655                                 Seq:       10,
 656                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4}},
 657                         },
 658                         want: []Reassembly{},
 659                 },
 660                 {
 661                         in: layers.TCP{
 662                                 SrcPort:   1,
 663                                 DstPort:   2,
 664                                 SYN:       true,
 665                                 Seq:       0xFFFFFFFF,
 666                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 667                         },
 668                         want: []Reassembly{
 669                                 Reassembly{
 670                                         Start: true,
 671                                         Bytes: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 672                                 },
 673                                 Reassembly{
 674                                         Bytes: []byte{1, 2, 3, 4},
 675                                 },
 676                         },
 677                 },
 678         })
 679 }
 680
 681 func TestCacheLargePacket(t *testing.T) {
 682         data := make([]byte, pageBytes*3)
 683         test(t, []testSequence{
 684                 {
 685                         in: layers.TCP{
 686                                 SrcPort:   1,
 687                                 DstPort:   2,
 688                                 Seq:       1001,
 689                                 BaseLayer: layers.BaseLayer{Payload: data},
 690                         },
 691                         want: []Reassembly{},
 692                 },
 693                 {
 694                         in: layers.TCP{
 695                                 SrcPort:   1,
 696                                 DstPort:   2,
 697                                 Seq:       1000,
 698                                 SYN:       true,
 699                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
 700                         },
 701                         want: []Reassembly{
 702                                 Reassembly{
 703                                         Start: true,
 704                                         Bytes: []byte{},
 705                                 },
 706                                 Reassembly{
 707                                         Bytes: data[:pageBytes],
 708                                 },
 709                                 Reassembly{
 710                                         Bytes: data[pageBytes : pageBytes*2],
 711                                 },
 712                                 Reassembly{
 713                                         Bytes: data[pageBytes*2 : pageBytes*3],
 714                                 },
 715                         },
 716                 },
 717         })
 718 }
 719
 720 /*
 721  * Keep
 722  */
 723 type testKeepFactory struct {
 724         keep    int
 725         bytes   []byte
 726         skipped int
 727         t       *testing.T
 728 }
 729
 730 func (tkf *testKeepFactory) New(a, b gopacket.Flow, tcp *layers.TCP, ac AssemblerContext) Stream {
 731         return tkf
 732 }
 733 func (tkf *testKeepFactory) ReassembledSG(sg ScatterGather, ac AssemblerContext) {
 734         l, _ := sg.Lengths()
 735         _, _, _, tkf.skipped = sg.Info()
 736         tkf.bytes = sg.Fetch(l)
 737         sg.KeepFrom(tkf.keep)
 738 }
 739 func (tkf *testKeepFactory) ReassemblyComplete(ac AssemblerContext) bool {
 740         return true
 741 }
 742
 743 func (tkf *testKeepFactory) Accept(tcp *layers.TCP, ci gopacket.CaptureInfo, dir TCPFlowDirection, seq Sequence, start *bool, ac AssemblerContext) bool {
 744         return true
 745 }
 746
 747 type testKeepSequence struct {
 748         tcp     layers.TCP
 749         keep    int
 750         want    []byte
 751         skipped int
 752 }
 753
 754 func testKeep(t *testing.T, s []testKeepSequence) {
 755         fact := &testKeepFactory{t: t}
 756         p := NewStreamPool(fact)
 757         a := NewAssembler(p)
 758         a.MaxBufferedPagesPerConnection = 4
 759         port := layers.TCPPort(0)
 760         for i, test := range s {
 761                 // Fake some values according to ports
 762                 flow := netFlow
 763                 dir := TCPDirClientToServer
 764                 if port == 0 {
 765                         port = test.tcp.SrcPort
 766                 }
 767                 if port != test.tcp.SrcPort {
 768                         dir = dir.Reverse()
 769                         flow = flow.Reverse()
 770                 }
 771                 test.tcp.SetInternalPortsForTesting()
 772                 fact.keep = test.keep
 773                 fact.bytes = []byte{}
 774                 if testDebug {
 775                         fmt.Printf("#### testKeep: #%d: sending:%s\n", i, hex.EncodeToString(test.tcp.BaseLayer.Payload))
 776                 }
 777                 a.Assemble(flow, &test.tcp)
 778                 if !reflect.DeepEqual(fact.bytes, test.want) {
 779                         t.Fatalf("#%d: invalid bytes: got %v, expected %v", i, fact.bytes, test.want)
 780                 }
 781                 if fact.skipped != test.skipped {
 782                         t.Fatalf("#%d: expecting %d skipped bytes, got %d", i, test.skipped, fact.skipped)
 783                 }
 784                 if testDebug {
 785                         fmt.Printf("#### testKeep: #%d: bytes: %s\n", i, hex.EncodeToString(fact.bytes))
 786                 }
 787         }
 788 }
 789
 790 func TestKeepSimpleOnBoundary(t *testing.T) {
 791         testKeep(t, []testKeepSequence{
 792                 {
 793                         tcp: layers.TCP{
 794                                 SrcPort:   1,
 795                                 DstPort:   2,
 796                                 SYN:       true,
 797                                 Seq:       1000,
 798                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 799                         },
 800                         keep: 0,
 801                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 802                 },
 803                 {
 804                         tcp: layers.TCP{
 805                                 SrcPort:   1,
 806                                 DstPort:   2,
 807                                 Seq:       1007,
 808                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}},
 809                         },
 810                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5},
 811                 },
 812         })
 813 }
 814
 815 func TestKeepSimpleNotBoundaryLive(t *testing.T) {
 816         testKeep(t, []testKeepSequence{
 817                 {
 818                         tcp: layers.TCP{
 819                                 SrcPort:   1,
 820                                 DstPort:   2,
 821                                 SYN:       true,
 822                                 Seq:       1000,
 823                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
 824                         },
 825                         keep: 1,
 826                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0},
 827                 },
 828                 {
 829                         tcp: layers.TCP{
 830                                 SrcPort:   1,
 831                                 DstPort:   2,
 832                                 Seq:       1007,
 833                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0, 1, 2, 3, 4, 5}},
 834                         },
 835                         want: []byte{2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5},
 836                 },
 837         })
 838 }
 839
 840 func TestKeepSimpleNotBoundaryAlreadyKept(t *testing.T) {
 841         testKeep(t, []testKeepSequence{
 842                 {
 843                         tcp: layers.TCP{
 844                                 SrcPort:   1,
 845                                 DstPort:   2,
 846                                 SYN:       true,
 847                                 Seq:       1000,
 848                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0x10}},
 849                         },
 850                         keep: 0, // 1→10
 851                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0x10},
 852                 },
 853                 {
 854                         tcp: layers.TCP{
 855                                 SrcPort:   1,
 856                                 DstPort:   2,
 857                                 Seq:       1007,
 858                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15}},
 859                         },
 860                         keep: 11, // 12→15
 861                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15},
 862                 },
 863                 {
 864                         tcp: layers.TCP{
 865                                 SrcPort:   1,
 866                                 DstPort:   2,
 867                                 Seq:       1016,
 868                                 BaseLayer: layers.BaseLayer{Payload: []byte{0x16, 0x17, 0x18}},
 869                         },
 870                         want: []byte{0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18},
 871                 },
 872         })
 873 }
 874
 875 func TestKeepLonger(t *testing.T) {
 876         testKeep(t, []testKeepSequence{
 877                 {
 878                         tcp: layers.TCP{
 879                                 SrcPort:   1,
 880                                 DstPort:   2,
 881                                 SYN:       true,
 882                                 Seq:       1000,
 883                                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}},
 884                         },
 885                         keep: 0,
 886                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
 887                 },
 888                 {
 889                         tcp: layers.TCP{
 890                                 SrcPort:   1,
 891                                 DstPort:   2,
 892                                 Seq:       1007,
 893                                 BaseLayer: layers.BaseLayer{Payload: []byte{7, 8, 9, 10, 11, 12, 13, 14, 15}},
 894                         },
 895                         keep: 0,
 896                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
 897                 },
 898                 {
 899                         tcp: layers.TCP{
 900                                 SrcPort:   1,
 901                                 DstPort:   2,
 902                                 Seq:       1010,
 903                                 BaseLayer: layers.BaseLayer{Payload: []byte{10, 11, 12, 13, 14, 15, 16, 17}},
 904                         },
 905                         want: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
 906                 },
 907         })
 908 }
 909
 910 func TestKeepWithFlush(t *testing.T) {
 911         testKeep(t, []testKeepSequence{
 912                 {
 913                         tcp: layers.TCP{
 914                                 SrcPort:   1,
 915                                 DstPort:   2,
 916                                 SYN:       true,
 917                                 Seq:       1000,
 918                                 BaseLayer: layers.BaseLayer{Payload: []byte{1}},
 919                         },
 920                         keep: 1,
 921                         want: []byte{1},
 922                 },
 923                 {
 924                         tcp: layers.TCP{
 925                                 SrcPort:   1,
 926                                 DstPort:   2,
 927                                 Seq:       1003,
 928                                 BaseLayer: layers.BaseLayer{Payload: []byte{3}},
 929                         },
 930                         keep: 0,
 931                         want: []byte{},
 932                 },
 933                 {
 934                         tcp: layers.TCP{
 935                                 SrcPort:   1,
 936                                 DstPort:   2,
 937                                 Seq:       1004,
 938                                 BaseLayer: layers.BaseLayer{Payload: []byte{4}},
 939                         },
 940                         keep: 0,
 941                         want: []byte{},
 942                 },
 943                 {
 944                         tcp: layers.TCP{
 945                                 SrcPort:   1,
 946                                 DstPort:   2,
 947                                 Seq:       1006,
 948                                 BaseLayer: layers.BaseLayer{Payload: []byte{6}},
 949                         },
 950                         keep: 0,
 951                         want: []byte{},
 952                 },
 953                 // Exceeding 4 pages: flushing first continuous pages
 954                 {
 955                         tcp: layers.TCP{
 956                                 SrcPort:   1,
 957                                 DstPort:   2,
 958                                 Seq:       1008,
 959                                 BaseLayer: layers.BaseLayer{Payload: []byte{8}},
 960                         },
 961                         keep:    0,
 962                         skipped: 1,
 963                         want:    []byte{3, 4},
 964                 },
 965                 {
 966                         tcp: layers.TCP{
 967                                 SrcPort:   1,
 968                                 DstPort:   2,
 969                                 Seq:       1010,
 970                                 BaseLayer: layers.BaseLayer{Payload: []byte{10}},
 971                         },
 972                         keep:    0,
 973                         skipped: 1,
 974                         want:    []byte{6},
 975                 },
 976                 {
 977                         tcp: layers.TCP{
 978                                 SrcPort:   1,
 979                                 DstPort:   2,
 980                                 Seq:       1012,
 981                                 BaseLayer: layers.BaseLayer{Payload: []byte{12}},
 982                         },
 983                         keep:    0,
 984                         skipped: 1,
 985                         want:    []byte{8},
 986                 },
 987         })
 988 }
 989
 990 /*
 991  * FSM tests
 992  */
 993 /* For FSM: bump nb on accepted packet */
 994 type testFSMFactory struct {
 995         nb  int
 996         fsm TCPSimpleFSM
 997 }
 998
 999 func (t *testFSMFactory) New(a, b gopacket.Flow, tcp *layers.TCP, ac AssemblerContext) Stream {
1000         return t
1001 }
1002 func (t *testFSMFactory) ReassembledSG(sg ScatterGather, ac AssemblerContext) {
1003 }
1004 func (t *testFSMFactory) ReassemblyComplete(ac AssemblerContext) bool {
1005         return false
1006 }
1007
1008 func (t *testFSMFactory) Accept(tcp *layers.TCP, ci gopacket.CaptureInfo, dir TCPFlowDirection, seq Sequence, start *bool, ac AssemblerContext) bool {
1009         ok := t.fsm.CheckState(tcp, dir)
1010         if ok {
1011                 t.nb++
1012         }
1013         return ok
1014 }
1015
1016 type testFSMSequence struct {
1017         tcp layers.TCP
1018         ci  gopacket.CaptureInfo
1019         nb  int
1020 }
1021
1022 func (seq *testFSMSequence) GetCaptureInfo() gopacket.CaptureInfo {
1023         return seq.ci
1024 }
1025
1026 func testFSM(t *testing.T, s []testFSMSequence) {
1027         fact := &testFSMFactory{}
1028         p := NewStreamPool(fact)
1029         a := NewAssembler(p)
1030         //a.MaxBufferedPagesPerConnection = 4
1031         fact.nb = 0
1032         port := layers.TCPPort(0)
1033         for i, test := range s {
1034                 // Fake some values according to ports
1035                 flow := netFlow
1036                 dir := TCPDirClientToServer
1037                 if port == 0 {
1038                         port = test.tcp.SrcPort
1039                 }
1040                 if port != test.tcp.SrcPort {
1041                         dir = dir.Reverse()
1042                         flow = flow.Reverse()
1043                 }
1044                 test.tcp.SetInternalPortsForTesting()
1045                 a.AssembleWithContext(flow, &test.tcp, &test)
1046                 if fact.nb != test.nb {
1047                         t.Fatalf("#%d: packet rejected: got %d, expected %d", i, fact.nb, test.nb)
1048                 }
1049         }
1050 }
1051
1052 func TestFSMnormalFlow(t *testing.T) {
1053         testFSM(t, []testFSMSequence{
1054                 {
1055                         tcp: layers.TCP{
1056                                 SYN:       true,
1057                                 SrcPort:   54842,
1058                                 DstPort:   53,
1059                                 Seq:       374511116,
1060                                 Ack:       0,
1061                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1062                         },
1063                         ci: gopacket.CaptureInfo{
1064                                 Timestamp: time.Unix(1432538521, 566690000),
1065                         },
1066                         nb: 1,
1067                 },
1068                 {
1069                         tcp: layers.TCP{
1070                                 SYN:       true,
1071                                 ACK:       true,
1072                                 SrcPort:   53,
1073                                 DstPort:   54842,
1074                                 Seq:       3465787765,
1075                                 Ack:       374511117,
1076                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1077                         },
1078                         ci: gopacket.CaptureInfo{
1079                                 Timestamp: time.Unix(1432538521, 590332000),
1080                         },
1081                         nb: 2,
1082                 },
1083                 {
1084                         tcp: layers.TCP{
1085                                 ACK:       true,
1086                                 SrcPort:   54842,
1087                                 DstPort:   53,
1088                                 Seq:       374511117,
1089                                 Ack:       3465787766,
1090                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1091                         },
1092                         ci: gopacket.CaptureInfo{
1093                                 Timestamp: time.Unix(1432538521, 590346000),
1094                         },
1095                         nb: 3,
1096                 },
1097                 {
1098                         tcp: layers.TCP{
1099                                 ACK:       true,
1100                                 SrcPort:   54842,
1101                                 DstPort:   53,
1102                                 Seq:       374511117,
1103                                 Ack:       3465787766,
1104                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 31, 104, 196, 0, 32, 0, 1, 0, 0, 0, 0, 0, 1, 2, 85, 83, 0, 0, 6, 0, 1, 0, 0, 41, 16, 0, 0, 0, 128, 0, 0, 0}},
1105                         },
1106                         ci: gopacket.CaptureInfo{
1107                                 Timestamp: time.Unix(1432538521, 590387000),
1108                         },
1109                         nb: 4,
1110                 },
1111                 {
1112                         tcp: layers.TCP{
1113                                 ACK:       true,
1114                                 SrcPort:   53,
1115                                 DstPort:   54842,
1116                                 Seq:       3465787766,
1117                                 Ack:       374511150,
1118                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1119                         },
1120                         ci: gopacket.CaptureInfo{
1121                                 Timestamp: time.Unix(1432538521, 613687000),
1122                         },
1123                         nb: 5,
1124                 },
1125                 {
1126                         tcp: layers.TCP{
1127                                 ACK:       true,
1128                                 SrcPort:   53,
1129                                 DstPort:   54842,
1130                                 Seq:       3465787766,
1131                                 Ack:       374511150,
1132                                 BaseLayer: layers.BaseLayer{Payload: []byte{8, 133, 104, 196, 132, 0, 0, 1, 0, 2, 0, 7, 0, 19, 2, 85, 83, 0, 0, 6, 0, 1, 2, 117, 115, 0, 0, 6, 0, 1, 0, 0, 3, 132, 0, 54, 1, 97, 5, 99, 99, 116, 108, 100, 192, 20, 10, 104, 111, 115, 116, 109, 97, 115, 116, 101, 114, 7, 110, 101, 117, 115, 116, 97, 114, 3, 98, 105, 122, 0, 120, 18, 40, 205, 0, 0, 3, 132, 0, 0, 3, 132, 0, 9, 58, 128, 0, 1, 81, 128, 192, 20, 0, 46, 0, 1, 0, 0, 3, 132, 0, 150, 0, 6, 5, 1, 0, 0, 3, 132, 85, 138, 90, 146, 85, 98, 191, 130, 27, 78, 2, 117, 115, 0, 69, 13, 35, 189, 141, 225, 107, 238, 108, 182, 207, 44, 105, 31, 212, 103, 32, 93, 217, 108, 20, 231, 188, 28, 241, 237, 104, 182, 117, 121, 195, 112, 64, 96, 237, 248, 6, 181, 186, 96, 60, 6, 18, 29, 188, 96, 201, 140, 251, 61, 71, 177, 108, 156, 9, 83, 125, 172, 188, 75, 81, 67, 218, 55, 93, 131, 243, 15, 190, 75, 4, 165, 226, 124, 49, 67, 142, 131, 239, 240, 76, 225, 10, 242, 68, 88, 240, 200, 27, 97, 102, 73, 92, 73, 133, 170, 175, 198, 99, 109, 90, 16, 162, 101, 95, 96, 102, 250, 91, 74, 80, 3, 87, 167, 50, 230, 9, 213, 7, 222, 197, 87, 183, 190, 148, 247, 207, 204, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 10, 1, 102, 5, 99, 99, 116, 108, 100, 192, 12, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 97, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 98, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 99, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 101, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 107, 193, 8, 192, 118, 0, 46, 0, 1, 0, 7, 233, 0, 0, 150, 0, 2, 5, 1, 0, 7, 233, 0, 85, 127, 33, 92, 85, 87, 134, 98, 27, 78, 2, 117, 115, 0, 19, 227, 175, 75, 88, 245, 164, 158, 150, 198, 57, 253, 150, 179, 161, 52, 24, 56, 229, 176, 175, 40, 45, 232, 188, 171, 131, 197, 107, 125, 218, 192, 78, 221, 146, 33, 114, 55, 43, 12, 131, 213, 51, 98, 37, 2, 102, 161, 232, 115, 177, 210, 51, 169, 215, 133, 56, 190, 91, 75, 8, 222, 231, 202, 139, 28, 187, 249, 72, 21, 23, 56, 63, 72, 126, 142, 242, 195, 242, 64, 208, 134, 100, 157, 197, 159, 43, 148, 20, 70, 117, 152, 159, 35, 200, 220, 49, 234, 173, 210, 91, 34, 210, 192, 7, 197, 112, 117, 208, 234, 42, 49, 133, 237, 197, 14, 244, 149, 191, 142, 36, 252, 42, 48, 182, 189, 9, 68, 1, 65, 5, 67, 67, 84, 76, 68, 193, 126, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 124, 70, 1, 66, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 125, 70, 194, 26, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 3, 209, 174, 255, 255, 255, 255, 255, 255, 255, 255, 255, 126, 1, 67, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 127, 70, 1, 69, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 126, 70, 1, 70, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 209, 173, 58, 70, 194, 108, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 0, 54, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 1, 75, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 128, 70, 194, 154, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 3, 226, 57, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 194, 2, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 230, 49, 85, 73, 83, 2, 27, 78, 2, 117, 115, 0, 82, 36, 11, 141, 74, 85, 70, 98, 179, 63, 173, 83, 8, 70, 155, 41, 102, 166, 140, 62, 71, 178, 130, 38, 171, 200, 180, 68, 2, 215, 45, 6, 43, 59, 171, 146, 223, 215, 9, 77, 5, 104, 167, 42, 237, 170, 30, 114, 205, 129, 59, 225, 152, 224, 79, 1, 65, 68, 208, 153, 121, 237, 199, 87, 2, 251, 100, 105, 59, 24, 73, 226, 169, 121, 250, 91, 41, 124, 14, 23, 135, 52, 2, 86, 72, 224, 100, 135, 70, 216, 16, 107, 84, 59, 13, 168, 58, 187, 54, 98, 230, 167, 246, 42, 46, 156, 206, 238, 120, 199, 25, 144, 98, 249, 70, 162, 34, 43, 145, 114, 186, 233, 47, 42, 75, 95, 152, 235, 194, 26, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 160, 95, 100, 37, 167, 82, 93, 165, 126, 247, 147, 173, 238, 154, 206, 174, 96, 175, 209, 7, 8, 169, 171, 223, 29, 201, 161, 177, 98, 54, 94, 62, 70, 127, 142, 109, 206, 42, 179, 109, 156, 160, 156, 20, 59, 24, 147, 164, 13, 121, 192, 84, 157, 26, 56, 177, 151, 210, 7, 197, 229, 110, 60, 58, 224, 42, 77, 5, 59, 80, 216, 221, 248, 19, 66, 102, 74, 199, 238, 120, 231, 201, 187, 29, 11, 46, 195, 164, 8, 221, 128, 25, 205, 42, 247, 152, 112, 176, 14, 117, 150, 223, 245, 32, 212, 107, 4, 245, 27, 126, 224, 216, 0, 89, 106, 238, 185, 206, 44, 56, 204, 175, 7, 139, 233, 228, 127, 175, 194, 26, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 28, 5, 3, 0, 0, 28, 32, 85, 108, 217, 174, 85, 69, 70, 242, 27, 78, 2, 117, 115, 0, 172, 117, 89, 89, 73, 249, 245, 211, 100, 127, 48, 135, 224, 97, 172, 146, 128, 30, 190, 72, 199, 170, 97, 179, 136, 109, 86, 110, 235, 214, 47, 50, 115, 11, 226, 168, 56, 198, 24, 212, 205, 207, 2, 116, 104, 112, 99, 234, 236, 44, 70, 19, 19, 215, 127, 200, 162, 215, 142, 45, 135, 91, 219, 217, 86, 231, 154, 87, 222, 161, 32, 66, 196, 55, 117, 20, 186, 9, 134, 252, 249, 219, 9, 196, 128, 8, 222, 201, 131, 210, 182, 232, 142, 72, 160, 171, 95, 231, 232, 156, 28, 34, 54, 94, 73, 183, 38, 160, 123, 175, 157, 21, 163, 8, 214, 155, 172, 237, 169, 28, 15, 138, 105, 107, 251, 109, 131, 240, 194, 72, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 77, 207, 197, 130, 236, 138, 192, 241, 225, 114, 8, 22, 76, 54, 43, 121, 42, 44, 9, 92, 56, 253, 224, 179, 191, 131, 40, 176, 94, 61, 33, 12, 43, 82, 156, 236, 211, 29, 187, 100, 220, 243, 24, 134, 42, 204, 46, 161, 214, 91, 68, 119, 40, 252, 53, 54, 146, 136, 196, 168, 204, 195, 131, 110, 6, 73, 16, 161, 86, 35, 150, 153, 162, 185, 227, 65, 228, 160, 203, 42, 250, 121, 14, 42, 115, 221, 232, 96, 99, 164, 230, 29, 195, 149, 85, 206, 41, 1, 252, 77, 188, 88, 8, 182, 37, 249, 6, 158, 6, 244, 158, 254, 141, 203, 6, 158, 198, 103, 130, 98, 123, 34, 245, 44, 126, 77, 24, 187, 194, 90, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 108, 194, 203, 85, 69, 51, 125, 27, 78, 2, 117, 115, 0, 86, 26, 187, 56, 252, 194, 199, 140, 229, 133, 186, 187, 20, 174, 26, 48, 212, 129, 10, 20, 167, 179, 53, 72, 176, 92, 153, 48, 146, 15, 163, 182, 80, 138, 181, 135, 98, 129, 17, 66, 55, 184, 76, 225, 72, 104, 7, 221, 40, 71, 41, 202, 246, 154, 166, 199, 74, 175, 146, 54, 25, 56, 115, 243}},
1133                         },
1134                         ci: gopacket.CaptureInfo{
1135                                 Timestamp: time.Unix(1432538521, 621198000),
1136                         },
1137                         nb: 6,
1138                 },
1139                 {
1140                         tcp: layers.TCP{
1141                                 ACK:       true,
1142                                 SrcPort:   54842,
1143                                 DstPort:   53,
1144                                 Seq:       374511150,
1145                                 Ack:       3465789226,
1146                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1147                         },
1148                         ci: gopacket.CaptureInfo{
1149                                 Timestamp: time.Unix(1432538521, 621220000),
1150                         },
1151                         nb: 7,
1152                 },
1153                 {
1154                         tcp: layers.TCP{
1155                                 ACK:       true,
1156                                 SrcPort:   53,
1157                                 DstPort:   54842,
1158                                 Seq:       3465789226,
1159                                 Ack:       374511150,
1160                                 BaseLayer: layers.BaseLayer{Payload: []byte{153, 141, 101, 187, 110, 15, 63, 42, 81, 100, 95, 68, 241, 85, 160, 227, 3, 1, 12, 80, 166, 1, 98, 2, 44, 98, 63, 203, 70, 164, 99, 195, 23, 152, 223, 253, 208, 10, 12, 19, 66, 121, 9, 158, 205, 96, 218, 0, 80, 70, 58, 95, 41, 124, 216, 13, 122, 135, 102, 200, 181, 233, 129, 174, 194, 108, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 108, 223, 157, 85, 69, 74, 55, 27, 78, 2, 117, 115, 0, 149, 71, 215, 149, 16, 165, 115, 229, 141, 136, 187, 158, 88, 225, 131, 231, 182, 218, 235, 27, 48, 65, 244, 77, 186, 135, 72, 18, 87, 52, 180, 128, 130, 67, 75, 173, 160, 243, 104, 178, 103, 117, 96, 209, 36, 51, 108, 47, 232, 214, 254, 15, 208, 182, 218, 174, 248, 237, 88, 150, 35, 190, 239, 249, 171, 151, 9, 236, 2, 252, 255, 13, 79, 190, 147, 36, 161, 210, 202, 80, 209, 136, 167, 180, 186, 68, 246, 249, 48, 123, 46, 11, 132, 103, 132, 207, 186, 68, 110, 133, 142, 109, 194, 19, 122, 57, 203, 217, 120, 93, 67, 168, 91, 252, 87, 38, 33, 228, 229, 162, 190, 170, 23, 188, 89, 15, 241, 71, 194, 108, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 28, 5, 3, 0, 0, 28, 32, 85, 108, 217, 174, 85, 69, 70, 242, 27, 78, 2, 117, 115, 0, 206, 97, 120, 37, 255, 252, 7, 156, 162, 192, 43, 84, 105, 94, 125, 55, 13, 247, 234, 9, 25, 100, 246, 25, 77, 168, 199, 208, 187, 209, 164, 123, 234, 138, 238, 15, 86, 45, 163, 108, 162, 117, 247, 128, 3, 187, 100, 185, 193, 191, 134, 86, 161, 254, 236, 99, 66, 66, 35, 173, 91, 243, 175, 3, 175, 94, 79, 68, 246, 109, 200, 154, 209, 185, 11, 210, 50, 147, 136, 213, 158, 81, 111, 17, 149, 239, 110, 114, 25, 234, 247, 158, 233, 33, 36, 181, 66, 84, 189, 37, 207, 58, 9, 171, 143, 66, 69, 137, 192, 6, 187, 59, 16, 51, 80, 56, 89, 170, 12, 195, 69, 133, 188, 110, 171, 17, 17, 213, 194, 154, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 123, 36, 154, 4, 158, 41, 96, 252, 116, 114, 16, 137, 28, 177, 206, 33, 192, 88, 89, 1, 69, 252, 206, 88, 89, 152, 210, 179, 248, 44, 202, 239, 95, 131, 126, 147, 249, 93, 57, 166, 215, 184, 211, 164, 196, 71, 170, 3, 25, 18, 177, 214, 94, 147, 181, 148, 197, 11, 171, 219, 107, 48, 105, 81, 239, 110, 249, 140, 68, 127, 193, 146, 176, 161, 246, 108, 75, 141, 205, 211, 73, 247, 125, 205, 120, 156, 82, 55, 130, 250, 26, 15, 44, 214, 91, 115, 11, 103, 22, 83, 184, 96, 107, 138, 2, 127, 168, 191, 92, 102, 137, 161, 63, 225, 134, 17, 178, 242, 11, 43, 8, 30, 164, 28, 140, 195, 83, 121, 194, 154, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 28, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 189, 98, 234, 251, 237, 24, 143, 210, 30, 242, 97, 66, 50, 211, 47, 109, 110, 121, 244, 239, 89, 0, 39, 92, 218, 155, 71, 5, 23, 136, 231, 107, 95, 52, 231, 118, 253, 206, 250, 178, 209, 136, 13, 36, 36, 54, 157, 237, 35, 110, 134, 253, 80, 237, 162, 163, 38, 21, 54, 241, 240, 253, 73, 33, 191, 128, 32, 6, 198, 165, 35, 203, 244, 15, 166, 250, 159, 67, 149, 56, 19, 243, 230, 87, 6, 44, 150, 90, 79, 107, 18, 121, 112, 23, 176, 104, 50, 110, 176, 138, 250, 6, 209, 22, 41, 73, 234, 4, 124, 233, 208, 218, 236, 117, 232, 217, 10, 172, 18, 215, 143, 119, 193, 113, 10, 59, 255, 221, 0, 0, 41, 16, 0, 0, 0, 128, 0, 0, 0}},
1161                         },
1162                         ci: gopacket.CaptureInfo{
1163                                 Timestamp: time.Unix(1432538521, 622508000),
1164                         },
1165                         nb: 8,
1166                 },
1167                 {
1168                         tcp: layers.TCP{
1169                                 ACK:       true,
1170                                 SrcPort:   54842,
1171                                 DstPort:   53,
1172                                 Seq:       374511150,
1173                                 Ack:       3465789949,
1174                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1175                         },
1176                         ci: gopacket.CaptureInfo{
1177                                 Timestamp: time.Unix(1432538521, 622531000),
1178                         },
1179                         nb: 9,
1180                 },
1181                 {
1182                         tcp: layers.TCP{
1183                                 ACK:       true,
1184                                 FIN:       true,
1185                                 SrcPort:   54842,
1186                                 DstPort:   53,
1187                                 Seq:       374511150,
1188                                 Ack:       3465789949,
1189                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1190                         },
1191                         ci: gopacket.CaptureInfo{
1192                                 Timestamp: time.Unix(1432538521, 622907000),
1193                         },
1194                         nb: 10,
1195                 },
1196                 {
1197                         tcp: layers.TCP{
1198                                 ACK:       true,
1199                                 FIN:       true,
1200                                 SrcPort:   53,
1201                                 DstPort:   54842,
1202                                 Seq:       3465789949,
1203                                 Ack:       374511151,
1204                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1205                         },
1206                         ci: gopacket.CaptureInfo{
1207                                 Timestamp: time.Unix(1432538521, 652784000),
1208                         },
1209                         nb: 11,
1210                 },
1211                 {
1212                         tcp: layers.TCP{
1213                                 ACK:       true,
1214                                 SrcPort:   54842,
1215                                 DstPort:   53,
1216                                 Seq:       374511151,
1217                                 Ack:       3465789950,
1218                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1219                         },
1220                         ci: gopacket.CaptureInfo{
1221                                 Timestamp: time.Unix(1432538521, 652809000),
1222                         },
1223                         nb: 12,
1224                 },
1225         })
1226 }
1227
1228 func TestFSMearlyRST(t *testing.T) {
1229         testFSM(t, []testFSMSequence{
1230                 {
1231                         tcp: layers.TCP{
1232                                 SYN:       true,
1233                                 SrcPort:   54842,
1234                                 DstPort:   53,
1235                                 Seq:       374511116,
1236                                 Ack:       0,
1237                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1238                         },
1239                         ci: gopacket.CaptureInfo{
1240                                 Timestamp: time.Unix(1432538521, 566690000),
1241                         },
1242                         nb: 1,
1243                 },
1244                 {
1245                         tcp: layers.TCP{
1246                                 SYN:       true,
1247                                 ACK:       true,
1248                                 SrcPort:   53,
1249                                 DstPort:   54842,
1250                                 Seq:       3465787765,
1251                                 Ack:       374511117,
1252                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1253                         },
1254                         ci: gopacket.CaptureInfo{
1255                                 Timestamp: time.Unix(1432538521, 590332000),
1256                         },
1257                         nb: 2,
1258                 },
1259                 {
1260                         tcp: layers.TCP{
1261                                 RST:       true,
1262                                 SrcPort:   54842,
1263                                 DstPort:   53,
1264                                 Seq:       374511117,
1265                                 Ack:       3465787766,
1266                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1267                         },
1268                         ci: gopacket.CaptureInfo{
1269                                 Timestamp: time.Unix(1432538521, 590346000),
1270                         },
1271                         nb: 3,
1272                 },
1273                 {
1274                         tcp: layers.TCP{
1275                                 ACK:       true,
1276                                 SrcPort:   54842,
1277                                 DstPort:   53,
1278                                 Seq:       374511117,
1279                                 Ack:       3465787766,
1280                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 31, 104, 196, 0, 32, 0, 1, 0, 0, 0, 0, 0, 1, 2, 85, 83, 0, 0, 6, 0, 1, 0, 0, 41, 16, 0, 0, 0, 128, 0, 0, 0}},
1281                         },
1282                         ci: gopacket.CaptureInfo{
1283                                 Timestamp: time.Unix(1432538521, 590387000),
1284                         },
1285                         nb: 3,
1286                 },
1287                 {
1288                         tcp: layers.TCP{
1289                                 ACK:       true,
1290                                 SrcPort:   53,
1291                                 DstPort:   54842,
1292                                 Seq:       3465787766,
1293                                 Ack:       374511150,
1294                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1295                         },
1296                         ci: gopacket.CaptureInfo{
1297                                 Timestamp: time.Unix(1432538521, 613687000),
1298                         },
1299                         nb: 3,
1300                 },
1301         })
1302 }
1303
1304 func TestFSMestablishedThenRST(t *testing.T) {
1305         testFSM(t, []testFSMSequence{
1306                 {
1307                         tcp: layers.TCP{
1308                                 SYN:       true,
1309                                 SrcPort:   54842,
1310                                 DstPort:   53,
1311                                 Seq:       374511116,
1312                                 Ack:       0,
1313                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1314                         },
1315                         ci: gopacket.CaptureInfo{
1316                                 Timestamp: time.Unix(1432538521, 566690000),
1317                         },
1318                         nb: 1,
1319                 },
1320                 {
1321                         tcp: layers.TCP{
1322                                 SYN:       true,
1323                                 ACK:       true,
1324                                 SrcPort:   53,
1325                                 DstPort:   54842,
1326                                 Seq:       3465787765,
1327                                 Ack:       374511117,
1328                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1329                         },
1330                         ci: gopacket.CaptureInfo{
1331                                 Timestamp: time.Unix(1432538521, 590332000),
1332                         },
1333                         nb: 2,
1334                 },
1335                 {
1336                         tcp: layers.TCP{
1337                                 ACK:       true,
1338                                 SrcPort:   54842,
1339                                 DstPort:   53,
1340                                 Seq:       374511117,
1341                                 Ack:       3465787766,
1342                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1343                         },
1344                         ci: gopacket.CaptureInfo{
1345                                 Timestamp: time.Unix(1432538521, 590346000),
1346                         },
1347                         nb: 3,
1348                 },
1349                 {
1350                         tcp: layers.TCP{
1351                                 ACK:       true,
1352                                 SrcPort:   54842,
1353                                 DstPort:   53,
1354                                 Seq:       374511117,
1355                                 Ack:       3465787766,
1356                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 31, 104, 196, 0, 32, 0, 1, 0, 0, 0, 0, 0, 1, 2, 85, 83, 0, 0, 6, 0, 1, 0, 0, 41, 16, 0, 0, 0, 128, 0, 0, 0}},
1357                         },
1358                         ci: gopacket.CaptureInfo{
1359                                 Timestamp: time.Unix(1432538521, 590387000),
1360                         },
1361                         nb: 4,
1362                 },
1363                 {
1364                         tcp: layers.TCP{
1365                                 RST:       true,
1366                                 SrcPort:   53,
1367                                 DstPort:   54842,
1368                                 Seq:       3465787766,
1369                                 Ack:       374511150,
1370                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1371                         },
1372                         ci: gopacket.CaptureInfo{
1373                                 Timestamp: time.Unix(1432538521, 613687000),
1374                         },
1375                         nb: 5,
1376                 },
1377                 {
1378                         tcp: layers.TCP{
1379                                 ACK:       true,
1380                                 SrcPort:   53,
1381                                 DstPort:   54842,
1382                                 Seq:       3465787766,
1383                                 Ack:       374511150,
1384                                 BaseLayer: layers.BaseLayer{Payload: []byte{8, 133, 104, 196, 132, 0, 0, 1, 0, 2, 0, 7, 0, 19, 2, 85, 83, 0, 0, 6, 0, 1, 2, 117, 115, 0, 0, 6, 0, 1, 0, 0, 3, 132, 0, 54, 1, 97, 5, 99, 99, 116, 108, 100, 192, 20, 10, 104, 111, 115, 116, 109, 97, 115, 116, 101, 114, 7, 110, 101, 117, 115, 116, 97, 114, 3, 98, 105, 122, 0, 120, 18, 40, 205, 0, 0, 3, 132, 0, 0, 3, 132, 0, 9, 58, 128, 0, 1, 81, 128, 192, 20, 0, 46, 0, 1, 0, 0, 3, 132, 0, 150, 0, 6, 5, 1, 0, 0, 3, 132, 85, 138, 90, 146, 85, 98, 191, 130, 27, 78, 2, 117, 115, 0, 69, 13, 35, 189, 141, 225, 107, 238, 108, 182, 207, 44, 105, 31, 212, 103, 32, 93, 217, 108, 20, 231, 188, 28, 241, 237, 104, 182, 117, 121, 195, 112, 64, 96, 237, 248, 6, 181, 186, 96, 60, 6, 18, 29, 188, 96, 201, 140, 251, 61, 71, 177, 108, 156, 9, 83, 125, 172, 188, 75, 81, 67, 218, 55, 93, 131, 243, 15, 190, 75, 4, 165, 226, 124, 49, 67, 142, 131, 239, 240, 76, 225, 10, 242, 68, 88, 240, 200, 27, 97, 102, 73, 92, 73, 133, 170, 175, 198, 99, 109, 90, 16, 162, 101, 95, 96, 102, 250, 91, 74, 80, 3, 87, 167, 50, 230, 9, 213, 7, 222, 197, 87, 183, 190, 148, 247, 207, 204, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 10, 1, 102, 5, 99, 99, 116, 108, 100, 192, 12, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 97, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 98, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 99, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 101, 193, 8, 192, 118, 0, 2, 0, 1, 0, 7, 233, 0, 0, 4, 1, 107, 193, 8, 192, 118, 0, 46, 0, 1, 0, 7, 233, 0, 0, 150, 0, 2, 5, 1, 0, 7, 233, 0, 85, 127, 33, 92, 85, 87, 134, 98, 27, 78, 2, 117, 115, 0, 19, 227, 175, 75, 88, 245, 164, 158, 150, 198, 57, 253, 150, 179, 161, 52, 24, 56, 229, 176, 175, 40, 45, 232, 188, 171, 131, 197, 107, 125, 218, 192, 78, 221, 146, 33, 114, 55, 43, 12, 131, 213, 51, 98, 37, 2, 102, 161, 232, 115, 177, 210, 51, 169, 215, 133, 56, 190, 91, 75, 8, 222, 231, 202, 139, 28, 187, 249, 72, 21, 23, 56, 63, 72, 126, 142, 242, 195, 242, 64, 208, 134, 100, 157, 197, 159, 43, 148, 20, 70, 117, 152, 159, 35, 200, 220, 49, 234, 173, 210, 91, 34, 210, 192, 7, 197, 112, 117, 208, 234, 42, 49, 133, 237, 197, 14, 244, 149, 191, 142, 36, 252, 42, 48, 182, 189, 9, 68, 1, 65, 5, 67, 67, 84, 76, 68, 193, 126, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 124, 70, 1, 66, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 125, 70, 194, 26, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 3, 209, 174, 255, 255, 255, 255, 255, 255, 255, 255, 255, 126, 1, 67, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 127, 70, 1, 69, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 126, 70, 1, 70, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 209, 173, 58, 70, 194, 108, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 0, 54, 130, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 1, 75, 194, 4, 0, 1, 0, 1, 0, 0, 28, 32, 0, 4, 156, 154, 128, 70, 194, 154, 0, 28, 0, 1, 0, 0, 28, 32, 0, 16, 32, 1, 5, 3, 226, 57, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 194, 2, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 230, 49, 85, 73, 83, 2, 27, 78, 2, 117, 115, 0, 82, 36, 11, 141, 74, 85, 70, 98, 179, 63, 173, 83, 8, 70, 155, 41, 102, 166, 140, 62, 71, 178, 130, 38, 171, 200, 180, 68, 2, 215, 45, 6, 43, 59, 171, 146, 223, 215, 9, 77, 5, 104, 167, 42, 237, 170, 30, 114, 205, 129, 59, 225, 152, 224, 79, 1, 65, 68, 208, 153, 121, 237, 199, 87, 2, 251, 100, 105, 59, 24, 73, 226, 169, 121, 250, 91, 41, 124, 14, 23, 135, 52, 2, 86, 72, 224, 100, 135, 70, 216, 16, 107, 84, 59, 13, 168, 58, 187, 54, 98, 230, 167, 246, 42, 46, 156, 206, 238, 120, 199, 25, 144, 98, 249, 70, 162, 34, 43, 145, 114, 186, 233, 47, 42, 75, 95, 152, 235, 194, 26, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 160, 95, 100, 37, 167, 82, 93, 165, 126, 247, 147, 173, 238, 154, 206, 174, 96, 175, 209, 7, 8, 169, 171, 223, 29, 201, 161, 177, 98, 54, 94, 62, 70, 127, 142, 109, 206, 42, 179, 109, 156, 160, 156, 20, 59, 24, 147, 164, 13, 121, 192, 84, 157, 26, 56, 177, 151, 210, 7, 197, 229, 110, 60, 58, 224, 42, 77, 5, 59, 80, 216, 221, 248, 19, 66, 102, 74, 199, 238, 120, 231, 201, 187, 29, 11, 46, 195, 164, 8, 221, 128, 25, 205, 42, 247, 152, 112, 176, 14, 117, 150, 223, 245, 32, 212, 107, 4, 245, 27, 126, 224, 216, 0, 89, 106, 238, 185, 206, 44, 56, 204, 175, 7, 139, 233, 228, 127, 175, 194, 26, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 28, 5, 3, 0, 0, 28, 32, 85, 108, 217, 174, 85, 69, 70, 242, 27, 78, 2, 117, 115, 0, 172, 117, 89, 89, 73, 249, 245, 211, 100, 127, 48, 135, 224, 97, 172, 146, 128, 30, 190, 72, 199, 170, 97, 179, 136, 109, 86, 110, 235, 214, 47, 50, 115, 11, 226, 168, 56, 198, 24, 212, 205, 207, 2, 116, 104, 112, 99, 234, 236, 44, 70, 19, 19, 215, 127, 200, 162, 215, 142, 45, 135, 91, 219, 217, 86, 231, 154, 87, 222, 161, 32, 66, 196, 55, 117, 20, 186, 9, 134, 252, 249, 219, 9, 196, 128, 8, 222, 201, 131, 210, 182, 232, 142, 72, 160, 171, 95, 231, 232, 156, 28, 34, 54, 94, 73, 183, 38, 160, 123, 175, 157, 21, 163, 8, 214, 155, 172, 237, 169, 28, 15, 138, 105, 107, 251, 109, 131, 240, 194, 72, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 112, 190, 140, 85, 73, 36, 78, 27, 78, 2, 117, 115, 0, 77, 207, 197, 130, 236, 138, 192, 241, 225, 114, 8, 22, 76, 54, 43, 121, 42, 44, 9, 92, 56, 253, 224, 179, 191, 131, 40, 176, 94, 61, 33, 12, 43, 82, 156, 236, 211, 29, 187, 100, 220, 243, 24, 134, 42, 204, 46, 161, 214, 91, 68, 119, 40, 252, 53, 54, 146, 136, 196, 168, 204, 195, 131, 110, 6, 73, 16, 161, 86, 35, 150, 153, 162, 185, 227, 65, 228, 160, 203, 42, 250, 121, 14, 42, 115, 221, 232, 96, 99, 164, 230, 29, 195, 149, 85, 206, 41, 1, 252, 77, 188, 88, 8, 182, 37, 249, 6, 158, 6, 244, 158, 254, 141, 203, 6, 158, 198, 103, 130, 98, 123, 34, 245, 44, 126, 77, 24, 187, 194, 90, 0, 46, 0, 1, 0, 0, 28, 32, 0, 150, 0, 1, 5, 3, 0, 0, 28, 32, 85, 108, 194, 203, 85, 69, 51, 125, 27, 78, 2, 117, 115, 0, 86, 26, 187, 56, 252, 194, 199, 140, 229, 133, 186, 187, 20, 174, 26, 48, 212, 129, 10, 20, 167, 179, 53, 72, 176, 92, 153, 48, 146, 15, 163, 182, 80, 138, 181, 135, 98, 129, 17, 66, 55, 184, 76, 225, 72, 104, 7, 221, 40, 71, 41, 202, 246, 154, 166, 199, 74, 175, 146, 54, 25, 56, 115, 243}},
1385                         },
1386                         ci: gopacket.CaptureInfo{
1387                                 Timestamp: time.Unix(1432538521, 621198000),
1388                         },
1389                         nb: 5,
1390                 },
1391                 {
1392                         tcp: layers.TCP{
1393                                 ACK:       true,
1394                                 SrcPort:   54842,
1395                                 DstPort:   53,
1396                                 Seq:       374511150,
1397                                 Ack:       3465789226,
1398                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1399                         },
1400                         ci: gopacket.CaptureInfo{
1401                                 Timestamp: time.Unix(1432538521, 621220000),
1402                         },
1403                         nb: 5,
1404                 },
1405         })
1406 }
1407
1408 func TestFSMmissingSYNACK(t *testing.T) {
1409         testFSM(t, []testFSMSequence{
1410                 {
1411                         tcp: layers.TCP{
1412                                 SYN:       true,
1413                                 SrcPort:   54842,
1414                                 DstPort:   53,
1415                                 Seq:       374511116,
1416                                 Ack:       0,
1417                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1418                         },
1419                         ci: gopacket.CaptureInfo{
1420                                 Timestamp: time.Unix(1432538521, 566690000),
1421                         },
1422                         nb: 1,
1423                 },
1424                 {
1425                         tcp: layers.TCP{
1426                                 ACK:       true,
1427                                 SrcPort:   54842,
1428                                 DstPort:   53,
1429                                 Seq:       374511117,
1430                                 Ack:       3465787766,
1431                                 BaseLayer: layers.BaseLayer{Payload: []byte{}},
1432                         },
1433                         ci: gopacket.CaptureInfo{
1434                                 Timestamp: time.Unix(1432538521, 590346000),
1435                         },
1436                         nb: 1,
1437                 },
1438                 {
1439                         tcp: layers.TCP{
1440                                 ACK:       true,
1441                                 SrcPort:   54842,
1442                                 DstPort:   53,
1443                                 Seq:       374511117,
1444                                 Ack:       3465787766,
1445                                 BaseLayer: layers.BaseLayer{Payload: []byte{0, 31, 104, 196, 0, 32, 0, 1, 0, 0, 0, 0, 0, 1, 2, 85, 83, 0, 0, 6, 0, 1, 0, 0, 41, 16, 0, 0, 0, 128, 0, 0, 0}},
1446                         },
1447                         ci: gopacket.CaptureInfo{
1448                                 Timestamp: time.Unix(1432538521, 590387000),
1449                         },
1450                         nb: 1,
1451                 },
1452         })
1453 }
1454
1455 /*
1456  * Memory test
1457  */
1458 func TestMemoryShrink(t *testing.T) {
1459         tcp := layers.TCP{
1460                 SrcPort:   1,
1461                 DstPort:   2,
1462                 SYN:       true,
1463                 Seq:       999,
1464                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1465         }
1466         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1467         var before runtime.MemStats
1468         runtime.GC()
1469         runtime.ReadMemStats(&before)
1470         run := 1050
1471         // Allocate > initial
1472         for i := 0; i < run; i++ {
1473                 a.Assemble(netFlow, &tcp)
1474                 if tcp.SYN {
1475                         tcp.SYN = false
1476                         tcp.Seq += 1 + 1
1477                 }
1478                 tcp.Seq += 10
1479         }
1480         var after runtime.MemStats
1481         a.FlushAll()
1482         runtime.GC()
1483         runtime.ReadMemStats(&after)
1484         if after.HeapAlloc < before.HeapAlloc {
1485                 t.Fatalf("Nothing allocated for %d run: before: %d, after: %d", run, before.HeapAlloc, after.HeapAlloc)
1486         }
1487         before = after
1488         // Do ~ initial allocs+free()
1489         run *= 2
1490         for i := 0; i < run; i++ {
1491                 a.Assemble(netFlow, &tcp)
1492                 if i%50 == 0 {
1493                         a.FlushAll()
1494                 }
1495                 tcp.Seq += 10
1496         }
1497         runtime.GC()
1498         runtime.ReadMemStats(&after)
1499         if after.HeapAlloc >= before.HeapAlloc {
1500                 t.Fatalf("Nothing freed for %d run: before: %d, after: %d", run, before.HeapAlloc, after.HeapAlloc)
1501         }
1502 }
1503
1504 /*
1505  * Benchmark tests
1506  */
1507 func BenchmarkSingleStreamNo(b *testing.B) {
1508         t := layers.TCP{
1509                 SrcPort:   1,
1510                 DstPort:   2,
1511                 SYN:       true,
1512                 Seq:       1000,
1513                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1514         }
1515         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1516         for i := 0; i < b.N; i++ {
1517                 a.Assemble(netFlow, &t)
1518                 if t.SYN {
1519                         t.SYN = false
1520                         t.Seq++
1521                 }
1522                 t.Seq += 10
1523         }
1524 }
1525
1526 func BenchmarkSingleStreamSkips(b *testing.B) {
1527         t := layers.TCP{
1528                 SrcPort:   1,
1529                 DstPort:   2,
1530                 SYN:       true,
1531                 Seq:       1000,
1532                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1533         }
1534         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1535         skipped := false
1536         for i := 0; i < b.N; i++ {
1537                 if i%10 == 9 {
1538                         t.Seq += 10
1539                         skipped = true
1540                 } else if skipped {
1541                         t.Seq -= 20
1542                 }
1543                 a.Assemble(netFlow, &t)
1544                 if t.SYN {
1545                         t.SYN = false
1546                         t.Seq++
1547                 }
1548                 t.Seq += 10
1549                 if skipped {
1550                         t.Seq += 10
1551                         skipped = false
1552                 }
1553         }
1554 }
1555
1556 func BenchmarkSingleStreamLoss(b *testing.B) {
1557         t := layers.TCP{
1558                 SrcPort:   1,
1559                 DstPort:   2,
1560                 SYN:       true,
1561                 Seq:       1000,
1562                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1563         }
1564         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1565         for i := 0; i < b.N; i++ {
1566                 a.Assemble(netFlow, &t)
1567                 t.SYN = false
1568                 t.Seq += 11
1569         }
1570 }
1571
1572 func BenchmarkMultiStreamGrow(b *testing.B) {
1573         t := layers.TCP{
1574                 SrcPort:   1,
1575                 DstPort:   2,
1576                 Seq:       0,
1577                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1578         }
1579         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1580         for i := 0; i < b.N; i++ {
1581                 t.SrcPort = layers.TCPPort(i)
1582                 a.Assemble(netFlow, &t)
1583                 t.Seq += 10
1584         }
1585 }
1586
1587 func BenchmarkMultiStreamConn(b *testing.B) {
1588         t := layers.TCP{
1589                 SrcPort:   1,
1590                 DstPort:   2,
1591                 Seq:       0,
1592                 SYN:       true,
1593                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1594         }
1595         a := NewAssembler(NewStreamPool(&testFactoryBench{}))
1596         for i := 0; i < b.N; i++ {
1597                 t.SrcPort = layers.TCPPort(i)
1598                 a.Assemble(netFlow, &t)
1599                 if i%65536 == 65535 {
1600                         if t.SYN {
1601                                 t.SYN = false
1602                                 t.Seq++
1603                         }
1604                         t.Seq += 10
1605                 }
1606         }
1607 }
1608
1609 type testMemoryContext struct{}
1610
1611 func (t *testMemoryContext) GetCaptureInfo() gopacket.CaptureInfo {
1612         return gopacket.CaptureInfo{
1613                 Timestamp: time.Unix(1432538521, 590387000),
1614         }
1615 }
1616
1617 func TestFullyOrderedAndCompleteStreamDoesNotAlloc(t *testing.T) {
1618         c2s := layers.TCP{
1619                 SrcPort:   1,
1620                 DstPort:   2,
1621                 Seq:       0,
1622                 SYN:       true,
1623                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1624         }
1625         s2c := layers.TCP{
1626                 SrcPort:   c2s.DstPort,
1627                 DstPort:   c2s.SrcPort,
1628                 Seq:       0,
1629                 SYN:       true,
1630                 ACK:       true,
1631                 BaseLayer: layers.BaseLayer{Payload: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}},
1632         }
1633         tf := testMemoryFactory{}
1634         a := NewAssembler(NewStreamPool(&tf))
1635
1636         ctx := &testMemoryContext{}
1637         // First packet
1638         a.AssembleWithContext(netFlow, &c2s, ctx)
1639         a.AssembleWithContext(netFlow.Reverse(), &s2c, ctx)
1640         c2s.SYN, s2c.SYN = false, false
1641         c2s.ACK = true
1642         c2s.Seq++
1643         s2c.Seq++
1644         N := 1000
1645         if n := testing.AllocsPerRun(N, func() {
1646                 c2s.Seq += 10
1647                 s2c.Seq += 10
1648                 c2s.Ack += 10
1649                 s2c.Ack += 10
1650                 a.AssembleWithContext(netFlow, &c2s, ctx)
1651                 a.AssembleWithContext(netFlow.Reverse(), &s2c, ctx)
1652         }); n > 0 {
1653                 t.Error(n, "mallocs for normal TCP stream")
1654         }
1655         // Ensure all bytes have been through the stream
1656         // +1 for first packet and +1 because AllocsPerRun seems to run fun N+1 times.
1657         if tf.bytes != 10*2*(N+1+1) {
1658                 t.Error(tf.bytes, "bytes handled, expected", 10*2*(N+1+1))
1659         }
1660 }