types

type Event struct {
	Type        string
	PacketCount uint64
	Flow        TcpIpFlow
	Time        time.Time
	HijackSeq   uint32
	HijackAck   uint32
	Payload     []byte
	Winner      []byte
	Loser       []byte
	Base        Sequence
	Start       Sequence
	End         Sequence
}

type HashedTcpIpv4Flow struct {
	Src uint64
	Dst uint64
}

type HashedTcpIpv6Flow struct {
	// ipv6 16 bytes + tcp port 2 bytes == 18
	Src [18]byte
	Dst [18]byte
}

type Logger interface {
	Log(r *Event)
}

type PacketDataSourceCloser interface {
	// ReadPacketData returns the next packet available from this data source.
	// It returns:
	//  data:  The bytes of an individual packet.
	//  ci:  Metadata about the capture
	//  err:  An error encountered while reading packet data.  If err != nil,
	//    then data/ci will be ignored.
	ReadPacketData() (data []byte, ci gopacket.CaptureInfo, err error)
	// Close closes the ethernet sniffer and returns nil if no error was found.
	Close() error
}

type PacketLogger interface {
	WritePacket(rawPacket []byte, timestamp time.Time)
	Start()
	Stop()
	Remove()
	Archive()
	SetFileWriter(io.WriteCloser)
}

type PacketLoggerFactory interface {
	Build(*TcpIpFlow) PacketLogger
}

type PacketManifest struct {
	Timestamp time.Time
	Flow      *TcpIpFlow
	RawPacket []byte
	Ethernet  *layers.Ethernet
	IPv4      *layers.IPv4
	IPv6      *layers.IPv6
	TCP       *layers.TCP
	Payload   gopacket.Payload
}

type PacketSource interface {
	Start()
	Stop()
	SetSupervisor(Supervisor)
	GetStartedChan() chan bool // used for unit tests
}

type Reassembly struct {
	// Seq is the TCP sequence number for this segment
	Seq Sequence

	// Bytes is the next set of bytes in the stream.  May be empty.
	Bytes []byte
	// Skip is set to non-zero if bytes were skipped between this and the
	// last Reassembly.  If this is the first packet in a connection and we
	// didn't see the start, we have no idea how many bytes we skipped, so
	// we set it to -1.  Otherwise, it's set to the number of bytes skipped.
	Skip int
	// Start is set if this set of bytes has a TCP SYN accompanying it.
	Start bool
	// End is set if this set of bytes has a TCP FIN or RST accompanying it.
	End bool
	// IsOrderCoalesce is set if this stream segment was originally received
	// out of order and the later coalesced into the stream.
	IsCoalesce bool
	// IsCoalesceGap is set if this stream segment was the catalyzing segment
	// for triggering the coalescing of latent out-of-order packets.
	IsCoalesceGap bool
	// Seen is the timestamp this set of bytes was pulled off the wire.
	Seen time.Time
}

type Ring struct {
	Reassembly *Reassembly
	// contains filtered or unexported fields
}

type Sequence int64

type SnifferDriverOptions struct {
	DAQ          string
	Filename     string
	Device       string
	Snaplen      int32
	WireDuration time.Duration
	Filter       string
}

type Supervisor interface {
	Stopped()
	Run()
}

type TcpIpFlow struct {
	// contains filtered or unexported fields
}