158     "Delay ACK to try and piggyback it onto a data packet");
213     "Follow RFC793 criteria for validating SEG.ACK");
257  * receiving a duplicate ACK with a SACK block, and also
405 	 * If a SYN or SYN/ACK was lost and retransmitted, we have to  in cc_conn_init()
410 		tp->snd_cwnd = maxseg;		/* SYN(-ACK) lost */  in cc_conn_init()
438 		     * Allow ECN reaction on ACK to CWR, if  in cc_cong_signal()
506  * Indicate whether this ack should be delayed.  We can delay the ack if
508  *	- There is no delayed ack timer in progress.
509  *	- Our last ack wasn't a 0-sized window. We never want to delay
510  *	  the ack that opens up a 0-sized window.
565  *   tcp_do_segment processes the ACK and text of the segment for
1072 		 * the flag is only ACK.  A successful lookup creates a new  in tcp_input_with_port()
1096 				 * No syncache entry, or ACK was not for our  in tcp_input_with_port()
1097 				 * SYN/ACK.  Do our protection against double  in tcp_input_with_port()
1098 				 * ACK.  If peer sent us 2 ACKs, then for the  in tcp_input_with_port()
1102 				 * don't want to sent RST for the second ACK,  in tcp_input_with_port()
1105 				 * the ACK is stray indeed, rstreason would  in tcp_input_with_port()
1126 				 * retransmit the ACK for another  in tcp_input_with_port()
1172 		 * Our (SYN|ACK) response was rejected.  in tcp_input_with_port()
1195 		 * (SYN|ACK) is bogus on a listen socket.  in tcp_input_with_port()
1200 				    "SYN|ACK invalid, segment rejected\n",  in tcp_input_with_port()
1386 	 * the segment silently, or send a challenge ACK.  However, we try  in tcp_input_with_port()
1567 	 * If a segment with the ACK-bit set arrives in the SYN-SENT state  in tcp_do_segment()
1568 	 * check SEQ.ACK first.  in tcp_do_segment()
1642 	 * Process options only when we get SYN/ACK back. The SYN case  in tcp_do_segment()
1645 	 * or <SYN,ACK>) segment itself is never scaled.  in tcp_do_segment()
1704 	 * If timestamps were negotiated during SYN/ACK and a  in tcp_do_segment()
1728 	 * If timestamps were not negotiated during SYN/ACK and a  in tcp_do_segment()
1746 	 * candidate.  If the length is zero and the ack moved  in tcp_do_segment()
1750 	 * is non-zero and the ack didn't move, we're the  in tcp_do_segment()
1753 	 * the socket buffer and note that we need a delayed ack.  in tcp_do_segment()
1768 		 * If last ACK falls within this segment's sequence numbers,  in tcp_do_segment()
1786 				 * This is a pure ack for outstanding data.  in tcp_do_segment()
1807 				 * during the SYN+ACK phase, ignore  in tcp_do_segment()
1873 				 * a sufficiently large ACK.  in tcp_do_segment()
1888 				 * or we need to send an ACK.  in tcp_do_segment()
1978 	 *	if seg contains an ACK, but not for our SYN/ACK, send a RST.  in tcp_do_segment()
1997 			 * a subset of the original data), a valid ACK, a  in tcp_do_segment()
2017 	 *	if seg contains a RST with valid ACK (SEQ.ACK has already  in tcp_do_segment()
2019 	 *	if seg contains a RST without an ACK, drop the seg.  in tcp_do_segment()
2023 	 *	if seg contains ack then advance tp->snd_una  in tcp_do_segment()
2072 			 * If there's data, delay ACK; if there's also a FIN  in tcp_do_segment()
2084 			 * Received <SYN,ACK> in SYN_SENT[*] state.  in tcp_do_segment()
2136 		 * our data will be ACK'd; if so, enter normal data segment  in tcp_do_segment()
2137 		 * processing in the middle of step 5, ack processing.  in tcp_do_segment()
2159 	 * drop leading data (and SYN); if nothing left, just ack.  in tcp_do_segment()
2166 		 * - If RST is in window, we send challenge ACK.  in tcp_do_segment()
2212 	 * Send challenge ACK for any SYN in synchronized state.  in tcp_do_segment()
2298 			 * Send an ACK to resynchronize and drop any data.  in tcp_do_segment()
2299 			 * But keep on processing for RST or ACK.  in tcp_do_segment()
2316 			 * ACK now, as the next in-sequence segment  in tcp_do_segment()
2357 	 * (and PUSH and FIN); if nothing left, just ACK.  in tcp_do_segment()
2368 			 * remember to ack.  Otherwise, drop segment  in tcp_do_segment()
2369 			 * and ack.  in tcp_do_segment()
2384 	 * If last ACK falls within this segment's sequence numbers,  in tcp_do_segment()
2393 	 *        Last.ACK.Sent <= SEG.SEQ + SEG.Len  in tcp_do_segment()
2395 	 *        Last.ACK.Sent < SEG.SEQ + SEG.Len,  in tcp_do_segment()
2399 	 *    RTT correctly when RCV.NXT == Last.ACK.Sent.  in tcp_do_segment()
2410 	 * If the ACK bit is off:  if in SYN-RECEIVED state or SENDSYN  in tcp_do_segment()
2430 	 * Ack processing.  in tcp_do_segment()
2433 		/* Checking SEG.ACK against ISS is definitely redundant. */  in tcp_do_segment()
2470 	 * In SYN_RECEIVED state, the ack ACKs our SYN, so enter  in tcp_do_segment()
2472 	 * The ACK was checked above.  in tcp_do_segment()
2518 			 * snd_cwnd reduction that occurs when a TFO SYN|ACK  in tcp_do_segment()
2526 		 * Account for the ACK of our SYN prior to  in tcp_do_segment()
2527 		 * regular ACK processing below, except for  in tcp_do_segment()
2533 		 * If segment contains data or ACK, will call tcp_reass()  in tcp_do_segment()
2545 	 * In ESTABLISHED state: drop duplicate ACKs; ACK out of range  in tcp_do_segment()
2546 	 * ACKs.  If the ack is in the range  in tcp_do_segment()
2549 	 * data from the retransmission queue.  If this ACK reflects  in tcp_do_segment()
2571 			 * from the last ack with SACK doesn't get used.  in tcp_do_segment()
2601 				 * duplicate ack (ie, window info didn't  in tcp_do_segment()
2603 				 * the ack is the biggest we've  in tcp_do_segment()
2716 					/* Congestion signal before ack. */  in tcp_do_segment()
2782 					 * ACK by increasing snd_cwnd by one  in tcp_do_segment()
2810 					 * or we need to send an ACK.  in tcp_do_segment()
2839 			 * This ack is advancing the left edge, reset the  in tcp_do_segment()
2844 			 * If this ack also has new SACK info, increment the  in tcp_do_segment()
2909 		 * If we reach this point, ACK is not a duplicate,  in tcp_do_segment()
2915 			 * SYN has been ACK'd (so connection is now fully  in tcp_do_segment()
2917 			 * increment snd_una for ACK of SYN, and check if  in tcp_do_segment()
2950 		 * If we just performed our first retransmit, and the ACK  in tcp_do_segment()
2974 		 * during the SYN+ACK phase, ignore  in tcp_do_segment()
2996 		 * large ACK.  in tcp_do_segment()
3018 		 * If no data (only SYN) was ACK'd,  in tcp_do_segment()
3019 		 *    skip rest of ACK processing.  in tcp_do_segment()
3097 		 * the ESTABLISHED state if the ACK acknowledges our FIN  in tcp_do_segment()
3111 		 * and/or to be acked, as well as for the ack of our FIN.  in tcp_do_segment()
3129 	 * Don't look at window if no ACK: TAC's send garbage on first SYN.  in tcp_do_segment()
3236 		 * Set DELACK for segments received in order, but ack  in tcp_do_segment()
3360 	 * If FIN is received ACK the FIN and let the user know  in tcp_do_segment()
3369 			 * (ie NEEDSYN flag on) then delay ACK,  in tcp_do_segment()
3372 			 * more input can be expected, send ACK now.  in tcp_do_segment()
3430 	 * Generate an ACK dropping incoming segment if it occupies  in tcp_do_segment()
3431 	 * sequence space, where the ACK reflects our state.  in tcp_do_segment()
3437 	 * In the SYN-RECEIVED state, don't send an ACK unless the  in tcp_do_segment()
3438 	 * segment we received passes the SYN-RECEIVED ACK test.  in tcp_do_segment()
3440 	 * "LAND" DoS attack, and also prevents an ACK storm  in tcp_do_segment()
3478  * Issue RST and make ACK acceptable to originator of segment.
3758 	 * We received an ack for a packet that wasn't retransmitted;  in tcp_xmit_timer()
3785  * segment, or an ICMP need fragmentation datagram. Outgoing SYN/ACK MSS
4086 	 * Compute the amount of data that this ACK is indicating  in tcp_do_prr_ack()
4117 		 * - A partial ack without SACK block beneath snd_recover  in tcp_do_prr_ack()
4122 		 * - Prevent ACK splitting attacks, by being conservative  in tcp_do_prr_ack()
4137 	 * Send snd_cnt new data into the network in response to this ack.  in tcp_do_prr_ack()
4155  * On a partial ack arrives, force the retransmission of the