Writing a Wireshark Lua/Tap to Count the Number of TCP Flows - lua

Question

I previously posted a question entitled "Writing a Wireshark Dissector to Count Number of TCP Flows." I got some feedback to use Lua/Tap instead so I set out to write one but I need assistance with the code. I currently have the following functions that a tap must have:
Listener.new,
listener.packet,
listener.draw,
listener.reset.
To get a better understanding of what I want to do, please review my previous question here:
Writing a Wireshark dissector to count number of TCP flows
My new question is, would I need to write a code to do the equivalent of the tshark's command:
tshark -r 1min.pcap -q -n -z conv,tcp
in Lua/Tap to extract the statistics information first before I proceed to write code to count the TCP flows? Or all I need to do is write a code in Lua/Tap to to extract the TCP flow count. In either case, can someone help me with the code? I've search the web but can't find an example close to what I'm looking for so I can customize to suit what I'm trying to achieve. Thanks.

Answer 1

I don't have time to write code for you, but here's some information copied from an edit I made to the answer to your other question:
The C structure passed to TCP taps for each packet is:
/* the tcp header structure, passed to tap listeners */
typedef struct tcpheader {
guint32 th_seq;
guint32 th_ack;
gboolean th_have_seglen; /* TRUE if th_seglen is valid */
guint32 th_seglen;
guint32 th_win; /* make it 32 bits so we can handle some scaling */
guint16 th_sport;
guint16 th_dport;
guint8 th_hlen;
guint16 th_flags;
guint32 th_stream; /* this stream index field is included to help differentiate when address/port pairs are reused */
address ip_src;
address ip_dst;
/* This is the absolute maximum we could find in TCP options (RFC2018, section 3) */
#define MAX_TCP_SACK_RANGES 4
guint8 num_sack_ranges;
guint32 sack_left_edge[MAX_TCP_SACK_RANGES];
guint32 sack_right_edge[MAX_TCP_SACK_RANGES];
} tcp_info_t;
So, for C-language taps, the "data" argument to the tap listener's "packet" routine points to a structure of that sort.
For Lua taps, the "tapinfo" table passed as the third argument to the tap listener's "packet" routine is described as "a table of info based on the Listener's type, or nil.". For a TCP tap, the entries in the table include all the fields in that structure except for sack_left_edge and sack_right_edge; the keys in the table are the structure member names.
The th_stream field identifies the connection; each time the TCP dissector finds a new connection, it assigns a new value. As the comment indicates, "this stream index field is included to help differentiate when address/port pairs are reused", so that if a given connection is closed, and a later connection uses the same endpoints, the two connections have different th_stream values even though they have the same endpoints.
So you'd have a table using the th_stream value as a key. The table would store the endpoints (addresses and ports) and counts of packets and bytes in each direction. For each packet passed to the listener's "packet" routine, you'd look up the th_stream value in the table and, if you don't find it, you'd create a new entry, starting the counts off at zero, and use that new entry; otherwise, you'd use the entry you found. You'd then figure out whether the packet was going from A to B or B to A, and increase the appropriate packet count and byte count.
You'd also keep track of the time stamp. For the first packet, you'd store the time stamp for that packet. For each packet, you'd look at the time stamp and, if it's one minute or more later than the stored time stamp, you'd:
dump out the statistics from the table of connections;
empty out the table of connections;
store the new packet's time stamp, replacing the previous stored time stamp.