Learn / Field guide

TCP: reliable connections

TCP carries most of the traffic you care about: web pages, APIs, email. It opens a connection with a three-way handshake, numbers every byte, confirms what arrived, and resends what didn't.

66 TCP fields, explained

Field names are the ones Wireshark and TShark use, so you can search for them or use them in display filters.

tcp.srcport

The port number on the sending side.

Why it matters: Clients usually pick a random high port; servers use well-known ones like 443.

tcp.dstport

The port number on the receiving side.

Why it matters: 443 is HTTPS, 80 is HTTP, 22 is SSH. The port says which service the packet is for.

tcp.seq

Sequence number: where this segment's data fits in the stream.

Why it matters: The receiver uses it to put data back in order and notice gaps.

tcp.ack

Acknowledgment number: the next byte the sender expects to receive.

Why it matters: It confirms that everything before it arrived.

tcp.hdr_len

The length of the TCP header.

tcp.flags

Control flags that open, confirm, and close connections.

Why it matters: SYN starts a connection, ACK confirms data, FIN closes politely, and RST aborts.

tcp.flags.syn

SYN: "let's start a connection."

Why it matters: A SYN with no reply often means a firewall or an unreachable host.

tcp.flags.ack

ACK: the acknowledgment number in this packet is valid.

Why it matters: Nearly every packet after the first carries it.

tcp.flags.fin

FIN: "I've finished sending."

Why it matters: Each side sends one to close its half of the connection.

tcp.flags.rst

RST: "stop, this connection isn't valid."

Why it matters: In reply to a SYN, it usually means nothing is listening on that port.

tcp.flags.psh

PSH: hand this data to the application right away instead of waiting for more.

tcp.window_size

How many more bytes the sender can accept before it needs to process what it has.

Why it matters: A window that drops to zero means the receiver is overwhelmed.

tcp.checksum

A check value covering the TCP header and data.

tcp.urgent_pointer

Marks urgent data. It's almost never used.

tcp.len

How many bytes of application data this segment carries.

Why it matters: Zero means it's a control packet, such as a pure acknowledgment.

tcp.analysis.retransmission

This data was already sent once, and is being sent again because no acknowledgment arrived in time.

Why it matters: A few are normal. Many point to packet loss or congestion somewhere on the path.

tcp.stream

A number Wireshark gives each TCP connection in the capture.

Why it matters: Handy for filtering one connection: tcp.stream == N.

tcp.stream.pnum

This packet's position within its TCP connection.

tcp.completeness

Which parts of the connection's life Wireshark saw: opening, data, closing, or reset.

Why it matters: An incomplete connection may have started before or ended after the capture.

tcp.completeness.syn

Whether the connection request (SYN) was captured.

tcp.completeness.syn-ack

Whether the acceptance (SYN/ACK) was captured.

tcp.completeness.ack

Whether the handshake's final acknowledgment was captured.

tcp.completeness.data

Whether any data was exchanged.

tcp.completeness.fin

Whether a normal close (FIN) was captured.

tcp.completeness.rst

Whether the connection was reset.

tcp.completeness.str

A short summary of the connection's stages seen, written with symbols.

tcp.seq_raw

The actual sequence number in the packet.

Why it matters: Wireshark usually shows a relative number starting at 0 to make reading easier.

tcp.ack_raw

The actual acknowledgment number in the packet.

tcp.nxtseq

The sequence number the next segment from this side should use.

Why it matters: Generated by Wireshark from this segment's length.

tcp.window_size_value

The window value as written in the packet, before any scaling.

tcp.window_size_scalefactor

How much the window value is multiplied by, agreed during the handshake.

Why it matters: Scaling lets fast connections use windows larger than 64 KB.

tcp.time_relative

Time since this TCP connection's first packet.

tcp.time_delta

Time since the previous packet in this TCP connection.

Why it matters: Long gaps can point to a slow server or a stalled transfer.

tcp.stream.client.contiguity_count

Wireshark's count of in-order data from the client side.

tcp.stream.server.contiguity_count

Wireshark's count of in-order data from the server side.

tcp.payload

The data this segment carries for the application.

tcp.segment_data

Data that is part of a larger message spread over several segments.

tcp.analysis

Wireshark's analysis of this segment in the context of its connection.

Why it matters: These values are calculated, not sent on the network.

tcp.analysis.initial_rtt

The time the TCP handshake took: Wireshark's estimate of one round trip.

Why it matters: A good baseline for how far apart, in time, the two devices are.

tcp.analysis.bytes_in_flight

Data sent but not yet acknowledged.

Why it matters: If this stays high while transfers are slow, the receiver or the network is the bottleneck.

tcp.analysis.push_bytes_sent

Data sent since the last segment with the PSH flag.

tcp.analysis.acks_frame

Which earlier packet this acknowledgment confirms.

tcp.analysis.ack_rtt

Time between sending that data and receiving this acknowledgment.

Why it matters: Another measure of round-trip time.

tcp.analysis.flags

Notes Wireshark raised about this segment, such as retransmissions or duplicate acknowledgments.

tcp.analysis.rto

How long the sender waited before resending.

Why it matters: Long waits mean slow recovery from loss.

tcp.analysis.rto_frame

The packet that this retransmission resends.

tcp.analysis.ambiguous_ack

An acknowledgment that could belong to either the original or the resent data.

tcp.analysis.fast_retransmission

Data resent quickly after the receiver signaled a gap with duplicate acknowledgments.

Why it matters: Faster than waiting for a timeout; a sign of loss on a busy path.

tcp.analysis.duplicate_ack

The receiver repeats an acknowledgment because data after a gap arrived first.

Why it matters: Often comes just before a fast retransmission.

tcp.analysis.zero_window

The receiver has no room for more data right now.

Why it matters: The sender must pause, so transfers stall.

tcp.analysis.lost_segment

Wireshark noticed a gap in the data: an earlier segment wasn't captured.

Why it matters: It may have been lost, or the capture missed it.

tcp.options

Extra settings negotiated when the connection opens.

tcp.options.mss

Maximum segment size: the largest data block this side can receive in one segment.

tcp.options.mss_val

The maximum segment size in bytes. 1460 is typical on Ethernet.

tcp.option_kind

Which TCP option this is.

tcp.option_len

The length of this option.

tcp.options.sack_perm

Selective acknowledgment: lets the receiver report exactly which data is missing.

Why it matters: Helps recover from loss faster.

tcp.options.sack_perm.absent

This side didn't offer selective acknowledgment.

Why it matters: Recovery from packet loss may be slower.

tcp.options.wscale.shift

Window scaling: how many bits the window value is shifted left.

tcp.options.timestamp.tsval

A timestamp used to measure round trips and protect against old duplicate packets.

tcp.connection.syn

Wireshark's note that this packet opens a connection.

tcp.connection.synack

Wireshark's note that this packet accepts a connection.

tcp.connection.fin

Wireshark's note that this packet closes one side of the connection.

tcp.connection.fin_active

This side started the close.

tcp.connection.fin_passive

This side is closing in response to the other side's close.

tcp.connection.rst

Wireshark's note that this packet resets the connection.