Je suis toujours à la recherche d'un outil capable de sortir ces statistiques sous Windows...

Bandwidth estimation : (TCP_ESTATS_BANDWIDTH_ROD_v0 structure)
- OutboundBandwidth: 0 => The computed outbound bandwidth estimate, in bits per second, for the network path for the TCP connection.
- InboundBandwidth: 127675824 => The computed inbound bandwidth estimate, in bits per second, for the network path for the TCP connection.
- OutboundInstability: 0 => A measure, in bits per second, of the instability of the outbound bandwidth estimate for the network path for the TCP connection.
- InboundInstability: 3182011 => A measure, in bits per second, of the instability of the inbound bandwidth estimate for the network path for the TCP connection.
- OutboundBandwidthPeaked: No => A boolean value that indicates if the computed outbound bandwidth estimate for the network path for the TCP connection has reached its peak value.
- InboundBandwidthPeaked: Yes => A boolean value that indicates if the computed inbound bandwidth estimate for the network path for the TCP connection has reached its peak value.

Fine RTT : (TCP_ESTATS_FINE_RTT_ROD_v0 structure)
- Rtt Var: 7327 µs => The round trip time variation, in microseconds, used in receive window auto-tuning when the TCP extended statistics feature is enabled.
- Max Rtt: 14654 µs => The maximum sampled round trip time, in microseconds.
- Min Rtt: 14654 µs => The minimum sampled round trip time, in microseconds.
- Sum Rtt: 14654 µs => A smoothed value round trip time, in microseconds, computed from all sampled round trip times. The smoothing is a weighted additive function that uses the RttVar member.

Data transfert : (TCP_ESTATS_DATA_ROD_v0 structure)
- DataBytesOut: 237 => The number of octets of data contained in transmitted segments, including retransmitted data. Note that this does not include TCP headers.
- DataSegsOut: 1 => The number of segments sent containing a positive length data segment.
- DataBytesIn: 63742140 => The number of octets contained in received data segments, including retransmitted data. Note that this does not include TCP headers.
- DataSegsIn: 43659 => The number of segments received containing a positive length data segment.
- SegsOut: 21082 => The total number of segments sent.
- SegsIn: 43660 => The total number of segments received.
- SoftErrors: 0 => The number of segments that fail various consistency tests during TCP input processing. Soft errors might cause the segment to be discarded but some do not. Some of these soft errors cause the generation of a TCP acknowledgment, while others are silently discarded.
- SoftErrorReason: 0 => A value that identifies which consistency test most recently failed during TCP input processing. This object is set every time the SoftErrors member is incremented.
- SndUna: 1559684330 => The value of the oldest unacknowledged sequence number. Note that this member is a TCP state variable.
- SndNxt: 1559684330 => The next sequence number to be sent. Note that this member is not monotonic (and thus not a counter), because TCP sometimes retransmits lost data by pulling the member back to the missing data.
- SndMax: 1559684330 => The farthest forward (right most or largest) sequence number to be sent. Note that this will be equal to the SndNxt member except when the SndNxt member is pulled back during recovery.
- ThruBytesAcked: 237 => The number of octets for which cumulative acknowledgments have been received. Note that this will be the sum of changes to the SndNxt member.
- RcvNxt: 2886263480 => The next sequence number to be received. Note that this member is not monotonic (and thus not a counter), because TCP sometimes retransmits lost data by pulling the member back to the missing data.
- ThruBytesReceived: 63736300 => The number of octets for which cumulative acknowledgments have been sent. Note that this will be the sum of changes to the RcvNxtmember.

Sender congestion related data : (TCP_ESTATS_SND_CONG_ROD_v0 et TCP_ESTATS_SND_CONG_ROS_v0 structure)
- SndLimTransRwin: 0 => The number of transitions into the "Receiver Limited" state from either the "Congestion Limited" or "Sender Limited" states. This state is entered whenever TCP transmission stops because the sender has filled the announced receiver window.
- SndLimTimeRwin: 0 => The cumulative time, in milliseconds, spent in the "Receiver Limited" state where TCP transmission stops because the sender has filled the announced receiver window.
- SndLimBytesRwin: 0 => The total number of bytes sent in the "Receiver Limited" state.
- SndLimTransCwnd: 0 => The number of transitions into the "Congestion Limited" state from either the "Receiver Limited" or "Sender Limited" states. This state is entered whenever TCP transmission stops because the sender has reached some limit defined by TCP congestion control (the congestion window, for example) or other algorithms (retransmission timeouts) designed to control network traffic.
- SndLimTimeCwnd: 0 => The cumulative time, in milliseconds, spent in the "Congestion Limited" state. When there is a retransmission timeout, it is counted in this member and not the cumulative time for some other state.
- SndLimBytesCwnd: 0 => The total number of bytes sent in the "Congestion Limited" state.
- SndLimTransSnd: 1 => The number of transitions into the "Sender Limited" state from either the "Receiver Limited" or "Congestion Limited" states. This state is entered whenever TCP transmission stops due to some sender limit such as running out of application data or other resources and the Karn algorithm. When TCP stops sending data for any reason, which cannot be classified as "Receiver Limited" or "Congestion Limited", it is treated as "Sender Limited".
- SndLimTimeSnd: 30010 => The cumulative time, in milliseconds, spent in the "Sender Limited" state.
- SndLimBytesSnd: 237 => The total number of bytes sent in the "Sender Limited" state.
- SlowStart: 1 => The number of times the congestion window has been increased by the "Slow Start" algorithm.
- CongAvoid: 0 => The number of times the congestion window has been increased by the "Congestion Avoidance" algorithm.
- OtherReductions: 0 => The number of congestion window reductions made as a result of anything other than congestion control algorithms other than "Slow Start" and "Congestion Avoidance" algorithms.
- CurCwnd: 3157 => The size, in bytes, of the current congestion window.
- MaxSsCwnd: 3157 => The maximum size, in bytes, of the congestion window size used during "Slow Start."
- MaxCaCwnd: 0 => The maximum size, in bytes, of the congestion window used during "Congestion Avoidance."
- CurSsthresh: 4294967295 => The current size, in bytes, of the slow start threshold.
- MaxSsthresh: 4294967295 => The maximum size, in bytes, of the slow start threshold, excluding the initial value.
- MinSsthresh: 4294967295 => The minimum size, in bytes, of the slow start threshold.
- LimCwnd: 4294967295 => The maximum size, in bytes, of the congestion window that may be used.


Network path measurement : (TCP_ESTATS_PATH_ROD_v0 structure)
- FastRetran: 0 => The number of invocations of the Fast Retransmit algorithm.
- Timeouts: 0 => The number of times the retransmit timeout has expired when the retransmission timer backoff multiplier is equal to one.
- SubsequentTimeouts: 0 => The number of times the retransmit timeout has expired after the retransmission timer has been doubled.
- CurTimeoutCount: 0 => The current number of times the retransmit timeout has expired without receiving an acknowledgment for new data. The CurTimeoutCount member is reset to zero when new data is acknowledged and incremented for each invocation of Section 5.5 of RFC 2988.
- AbruptTimeouts: 0 => The number of timeouts that occurred without any immediately preceding duplicate acknowledgments or other indications of congestion. Abrupt timeouts indicate that the path lost an entire window of data or acknowledgments. Timeouts that are preceded by duplicate acknowledgments or other congestion signals (Explicit Congestion Notification, for example) are not counted as abrupt, and might have been avoided by a more sophisticated Fast Retransmit algorithm.
- PktsRetrans: 0 => The number of segments transmitted containing at least some retransmitted data.
- BytesRetrans: 0 => The number of bytes retransmitted.
- DupAcksIn: 0 => The number of duplicate ACKs received.
- SacksRcvd: 0 => The number of Selective Acknowledgement (SACK) options received.
- SackBlocksRcvd: 0 => The number of SACK blocks received (within SACK options).
- CongSignals: 0 => The number of multiplicative downward congestion window adjustments due to all forms of congestion signals, including Fast Retransmit, Explicit Congestion Notification (ECN), and timeouts. This member summarizes all events that invoke the Multiplicative Decrease (MD) portion of Additive Increase Multiplicative Decrease (AIMD) congestion control, and as such is the best indicator of how a congestion windows is being affected by congestion. Note that retransmission timeouts multiplicatively reduce the window implicitly by setting the slow start threshold size, and are included in the value stored in the CongSignals member. In order to minimize spurious congestion indications due to out-of-order segments, the CongSignals member is incremented in association with the Fast Retransmit algorithm.
- PreCongSumCwnd: 0 => The sum of the values of the congestion window, in bytes, captured each time a congestion signal is received. This member is updated each time the CongSignals member is incremented, such that the change in the PreCongSumCwnd member divided by the change in the CongSignals member is the average window (over some interval) just prior to a congestion signal.
- PreCongSumRtt: 0 => The sum, in milliseconds, of the last sample of the network round-trip-time (RTT) prior to the received congestion signals. The last sample of the RTT is stored in the SampleRtt member. The PreCongSumRtt member is updated each time the CongSignals member is incremented, such that the change in the PreCongSumRtt divided by the change in the CongSignals member is the average RTT (over some interval) just prior to a congestion signal.
- PostCongSumRtt: 0 => The sum, in milliseconds, of the first sample of the network RTT (stored in the SampleRtt member) following each congestion signal. The change in the PostCongSumRtt member divided by the change in the PostCongCountRtt member is the average RTT (over some interval) just after a congestion signal.
- PostCongCountRtt: 0 => The number of RTT samples, in bytes, included in the PostCongSumRtt member. The change in the PostCongSumRtt member divided by the change in the PostCongCountRtt member is the average RTT (over some interval) just after a congestion signal.
- EcnSignals: 0 => The number of congestion signals delivered to the TCP sender via ECN. This is typically the number of segments bearing Echo Congestion Experienced (ECE) bits, but also includes segments failing the ECN nonce check or other explicit congestion signals.
- EceRcvd: 0 => The number of segments received with IP headers bearing Congestion Experienced (CE) markings.
- SendStall: 0 => The number of interface stalls or other sender local resource limitations that are treated as congestion signals.
- QuenchRcvd: 0 => Reserved for future use. This member is always set to zero.
- RetranThresh: 3 => The number of duplicate acknowledgments required to trigger Fast Retransmit. Note that although this is constant in traditional Reno TCP implementations, it is adaptive in many newer TCP implementations.
- SndDupAckEpisodes: 0 => The number of Duplicate Acks Sent when prior Ack was not duplicate. This is the number of times that a contiguous series of duplicate acknowledgments have been sent. This is an indication of the number of data segments lost or reordered on the path from the remote TCP endpoint to the near TCP endpoint.
- SumBytesReordered: 0 => The sum of the amounts SND.UNA advances on the acknowledgment which ends a dup-ack episode without a retransmission. Note the change in the SumBytesReordered member divided by the change in the NonRecovDaEpisodes member is an estimate of the average reordering distance, over some interval.
- NonRecovDa: 0 => The number of duplicate acks (or SACKS) that did not trigger a Fast Retransmit because ACK advanced prior to the number of duplicate acknowledgments reaching the RetranThresh. Note that the change in the NonRecovDa member divided by the change in the NonRecovDaEpisodes member is an estimate of the average reordering distance in segments over some interval.
- NonRecovDaEpisodes: 0 => The number of duplicate acknowledgment episodes that did not trigger a Fast Retransmit because ACK advanced prior to the number of duplicate acknowledgments reaching the RetranThresh.
- Ack After Fr: 0 => Reserved for future use. This member is always set to zero.
- DsackDups: 0 => The number of duplicate segments reported to the local host by D-SACK blocks.
- SampleRtt: 20 => The most recent raw network round trip time measurement, in milliseconds, used in calculation of the retransmission timer (RTO).
- SmoothedRtt: 16 => The smoothed round trip time, in milliseconds, used in calculation of the RTO.
- RttVar: 20 => The round trip time variation, in milliseconds, used in calculation of the RTO.
- MaxRtt: 20 => The maximum sampled round trip time in milliseconds.
- MinRtt: 20 => The minimum sampled round trip time in milliseconds.
- SumRtt: 20 => The sum of all sampled round trip times in milliseconds. Note that the change in the SumRtt member divided by the change in the CountRtt member is the mean RTT, uniformly averaged over an enter interval.
- CountRtt: 1 => The number of round trip time samples included in the SumRtt member.
- CurRto: 300 => The current value, in milliseconds, of the retransmit timer.
- MaxRto: 300 => The maximum value, in milliseconds, of the retransmit timer.
- MinRto: 300 => The minimum value, in milliseconds, of the retransmit timer.
- CurMss: 1460 => The current maximum segment size (MSS), in bytes.
- MaxMss: 1460 => The maximum MSS, in bytes.
- MinMss: 1460 => The minimum MSS, in bytes.
- SpuriousRtoDetections: 0 => The number of acknowledgments reporting segments that have already been retransmitted due to a Retransmission Timeout.

Output queuing : (TCP_ESTATS_SEND_BUFF_ROD_v0 structure)
- CurRetxQueue: 0 => The current number of bytes of data occupying the retransmit queue.
- MaxRetxQueue: 237 => The maximum number of bytes of data occupying the retransmit queue.
- CurAppWQueue: 0 => The current number of bytes of application data buffered by TCP, pending the first transmission (to the left of SND.NXT or SndMax). This data will generally be transmitted (and SND.NXT advanced to the left) as soon as there is an available congestion window or receiver window. This is the amount of data readily available for transmission, without scheduling the application. TCP performance may suffer if there is insufficient queued write data.
- MaxAppWQueue: 237 => The maximum number of bytes of application data buffered by TCP, pending the first transmission. This is the maximum value of the CurAppWQueue member. The MaxAppWQueue and CurAppWQueue members can be used to determine if insufficient queued data is steady state (suggesting insufficient queue space) or transient (suggesting insufficient application performance or excessive CPU load or scheduler latency).


Statistics observed on the remote receiver : (TCP_ESTATS_REC_ROD_v0 structure)
- CurRwinRcvd: 15744 => The most recent window advertisement, in bytes, received from the remote receiver.
- MaxRwinRcvd: 15744 => The maximum window advertisement, in bytes, received from the remote receiver.
- MinRwinRcvd: 15744 => The minimum window advertisement, in bytes, received from the remote receiver.
- WinScaleRcvd: 8 => The value of the received window scale option if one was received from the remote receiver; otherwise, a value of -1. Note that if both the WinScaleSent member of the TCP_ESTATS_REC_ROD_v0 structure and the WinScaleRcvd member are not -1, then Snd.Wind.Scale will be the same as this value and used to scale receiver window announcements from the remote host to the local host.

Local receiver : (TCP_ESTATS_REC_ROD_v0 structure)
- CurRwinSent: 430700 => The most recent window advertisement, in bytes, that has been sent.
- MaxRwinSent: 776720 => The maximum window advertisement, in bytes, that has been sent.
- MinRwinSent: 118260 => The minimum window advertisement, in bytes, that has been sent.
- LimRwin: 16776960 => The maximum window advertisement, in bytes, that may be sent.
- DupAckEpisodes: 38 => The number of Duplicate Acks Sent when prior Ack was not duplicate. This is the number of times that a contiguous series of duplicate acknowledgments have been sent. This is an indication of the number of data segments lost or reordered on the path from the remote TCP endpoint to the near TCP endpoint.
- DupAcksOut: 1074 => The number of duplicate ACKs sent. The ratio of the change in the DupAcksOut member to the change in the DupAckEpisodes member is an indication of reorder or recovery distance over some interval.
- CeRcvd: 0 => The number of segments received with IP headers bearing Congestion Experienced (CE) markings.
- EcnSent: 0 => Reserved for future use. This member is always set to zero.
- EcnNoncesRcvd: 0 => Reserved for future use. This member is always set to zero.
- CurReasmQueue: 0 => The current number of bytes of sequence space spanned by the reassembly queue. This is generally the difference between rcv.nxt and the sequence number of the right most edge of the reassembly queue.
- MaxReasmQueue: 102200 => The maximum number of bytes of sequence space spanned by the reassembly queue. This is the maximum value of the CurReasmQueue member.
- CurAppRQueue: 5840 => The current number of bytes of application data that has been acknowledged by TCP but not yet delivered to the application.
- MaxAppRQueue: 27740 => The maximum number of bytes of application data that has been acknowledged by TCP but not yet delivered to the application.
- WinScaleSent: 0x07 => The value of the transmitted window scale option if one was sent; otherwise, a value of -1. Note that if both the WinScaleSent member and the WinScaleRcvd member of the TCP_ESTATS_OBS_REC_ROD_v0 structure are not -1, then Rcv.Wind.Scale will be the same as this value and used to scale receiver window announcements from the local host to the remote host.

Là, c'est un peu plus évolué...

Au passage, si vous savez comment récupérer ca sous Linux... J'arrive a récupérer une partie des informations mais il faut réaliser une capture Wireshark et utiliser tshark pour lire les informations de la capture...

Mon but, c'est de récupérer ca pour un transfert précis (un wget)

A regarder de plus pres l'API .Net a moins de choses... typique de MS ca 

En regardant la doc la fonction GetPerTcpConnectionEStats il  y a un code de demo. En le compilant ca donne un .exe qui fait une connexion local sur lui meme en tcp, genere un peu de trafic et ensuite affiche les stats suivantes:

Dumping Estats for server socket:

<lignes de stats>

Dumping Estats for client connect socket:

<lignes de stats>

Dumping Estats for server socket after client sends data:

<lignes de stats>

Dumping Estats for client socket after client sends data:

<lignes de stats>

pius la meme chose a nouveau en IPv6

avec par block de <lignes de stats>:
Syn Opts
Active Open:    No
Mss Received:   65495
Mss Sent        0

Data
Bytes Out:   0
Segs Out:    0
Bytes In:    0
Segs In:     0
Segs Out:    0
Segs In:     0
Soft Errors: 0
Soft Error Reason: 0
Snd Una:     3771097015
Snd Nxt:     3771097015
Snd Max:     3771097015
Bytes Acked: 0
Rcv Nxt:     3558549856
Bytes Rcv:   0

Snd Cong
Trans Rwin:       0
Lim Time Rwin:    0
Lim Bytes Rwin:   0
Lim Trans Cwnd:   0
Lim Time Cwnd:    0
Lim Bytes Cwnd:   0
Lim Trans Snd:    1
Lim Time Snd:     0
Lim Bytes Snd:    0
Slow Start:       0
Cong Avoid:       0
Other Reductions: 0
Cur Cwnd:         2920
Max Ss Cwnd:      2920
Max Ca Cwnd:      0
Cur Ss Thresh:    0xffffffff (4294967295)
Max Ss Thresh:    0xffffffff (4294967295)
Min Ss Thresh:    0xffffffff (4294967295)
Lim Cwnd:         0xffffffff (4294967295)

Path
Fast Retran:         0
Timeouts:            0
Subsequent Timeouts: 0
Cur Timeout Count:   0
Abrupt Timeouts:     0
Pkts Retrans:        0
Bytes Retrans:       0
Dup Acks In:         0
SacksRcvd:           0
Sack Blocks Rcvd:    0
Cong Signals:        0
Pre Cong Sum Cwnd:   0
Pre Cong Sum Rtt:    0
Post Cong Sum Rtt:   0
Post Cong Count Rtt: 0
Ecn Signals:         0
Ece Rcvd:            0
Send Stall:          0
Quench Rcvd:         0
Retran Thresh:       3
Snd Dup Ack Episodes:  0
Sum Bytes Reordered: 0
Non Recov Da:        0
Non Recov Da Episodes: 0
Ack After Fr:        0
Dsack Dups:          0
Sample Rtt:          0xffffffff (4294967295)
Smoothed Rtt:        0
Rtt Var:             0
Max Rtt:             0
Min Rtt:             0xffffffff (4294967295)
Sum Rtt:             0
Count Rtt:           0
Cur Rto:             300
Max Rto:             300
Min Rto:             300
Cur Mss:             1460
Max Mss:             1460
Min Mss:             1460
Spurious Rto:        0

Send Buff
Cur Retx Queue:   0
Max Retx Queue:   0
Cur App W Queue:  0
Max App W Queue:  0

Rec
Cur Rwin Sent:   0x2000 (8192)
Max Rwin Sent:   0x2000 (8192)
Min Rwin Sent:   0x2000 (8192)
Lim Rwin:        0xffff00 (16776960)
Dup Acks:        0
Dup Acks Out:    0
Ce Rcvd:         0
Ecn Send:        0
Ecn Nonces Rcvd: 0
Cur Reasm Queue: 0
Max Reasm Queue: 0
Cur App R Queue: 0
Max App R Queue: 0
Win Scale Sent:  0x08

Obs Rec
Cur Rwin Rcvd:   0x2000 (8192)
Max Rwin Rcvd:   0x2000 (8192)
Min Rwin Rcvd:   0xffffffff (4294967295)
Win Scale Rcvd:  0x8 (8)

Bandwidth
Outbound Bandwidth:   0
Inbound Bandwidth:    0
Outbound Instability: 0
Inbound Instability:  0
Outbound Bandwidth Peaked: No
Inbound Bandwidth Peaked:  No

Fine RTT
Rtt Var: 0
Max Rtt: 0
Min Rtt: 0xffffffff (4294967295)
Sum Rtt: 0
(ps: le code ne marche pas correctement car ils ont oublié un truc mais l'idée est la .

En fait ca affiche toutes les valeurs dispos venant des stats suivantes:

TcpConnectionEstatsSynOpts
TcpConnectionEstatsData
TcpConnectionEstatsSndCong
TcpConnectionEstatsPath
TcpConnectionEstatsSendBuff
TcpConnectionEstatsRec
TcpConnectionEstatsObsRec
TcpConnectionEstatsBandwidth
TcpConnectionEstatsFineRtt
TcpConnectionEstatsMaximum
Donc exactement ce que tu cherches.

MAIS ces API marchent que par connexion donc doivent être intégrer directement dans le programme qui génère le trafic, donc par exemple prendre le code source de wget et le modifier pour ajouter la collection de ces stats. En effet, il faut explicitement appeler la fonction SetPerTcpConnectionEStats pour activer la collecte des 'extended stats'  et ensuite recuper les valeurs avec la fonction GetPerTcpConnectionEStats quand on le souhaite (début, fin, toutes les X secondes, etc):

The SetPerTcpConnectionEStats function is defined on Windows Vista and later.
The SetPerTcpConnectionEStats function is used to enable or disable extended statistics on an IPv4 TCP connection passed in the Row parameter. Extended statistics on a TCP connection are disabled by default. The SetPerTcpConnectionEStats function is used to set the value of a member in the read/write information for extended statistics for an IPv4 TCP connection. The type and format of the structure to be set is specified by the EstatsType parameter. The Rw parameter contains a pointer to the structure being passed. All members in the structure pointed to by Rw parameter must be specified.

Éventuellement, mais je n'ai pas vérifier en pratique, il serait possible de faire un programme qui lance une autre programme et suit chacune de ses connections TCP avec ces API...ca ne me parait pas trop sorcier à faire...

Comme indiqué, les extented stats ne sont dispo qu'a partir de Vista donc ca ne marchera pas sous XP.

Ca n'est pas vraiment nouveau donc et c'est curieux qu'on ne trouve pas sur Internet un outil qui fait ca deja.

Je n'ai pas trop de temps ces temps ci mais c'est un sujet qui m’intéresse et qui est connexe a mon projet de speedtest donc si tu ne trouves rien d'ici 2 semaines, on peut envisager de développer un outil comme ca. Ca ne me parait pas compliqué du tout, suffit de 'choper' les connexions TCP qu'on veut suivre et utiliser l'API.

A moins qu'un autre dev C/C++Windows traine dans le coin et n'a rien à faire en ce moment :p

Sous Windows ou Linux vous ne connaissez pas un outil type curl ou wget mais qui affiche les paquets retransmis ?

curl donne de nombreuses statistiques sur le découpage du temps entre la résolution DNS, le temps de faire le [SYN / SYN-ACK] le temps entre le wget et le 1er paquet et le temps de transfert effectif.

Maintenant pour comprendre pourquoi le débit est mauvais, il est crucial d'avoir des informations sur le nombre de paquets retransmis ou le nombre de "DupAckEpisodes"...

Sous Windows j'ai aussi trouvé TCP Segment Retransmission Viewer
C'est open source : http://sourceforge.net/projects/tcpsegmentretransmissionviewer/

Sous linux, j'ai trouvé nuttcp qui est mentionné sur le blog de Stéphane Bortzmeyer et qui permet visiblement de voir les paquets retransmis. Le logiciel est dispo sous Ubuntu (sudo apt install nuttcp)

Je vais réaliser des tests.