* Compare available window to amount of window

	 * Sending of standalone window updates.

	 * known to peer (as advertised window less

	 *

	 * next expected input).  If the difference is at least two

	 * Window updates important when we close our window

	 * max size segments, or at least 50% of the maximum possible

	 * due to a full socket buffer and are opening it again

	 * window, then want to send a window update to peer.

	 * after the application reads data from it.  Once the

	 * Skip this if the connection is in T/TCP half-open state.

	 * window has opened again and the remote end starts to

	 * Don't send pure window updates when the peer has closed

	 * send again the ACK clock takes over and provides the

	 * the connection and won't ever send more data.

	 * most current window information.

	 *

	 * We must avoid to the silly window syndrome whereas

	 * every read from the receive buffer, no matter how

	 * small, causes a window update to be sent. We also

	 * should avoid sending a flurry of window updates when

	 * the socket buffer had queued a lot of data and the

	 * application is doing small reads.

	 *

	 * Don't send an independent window update if a delayed

	 * ACK is pending (it will get piggy-backed on it) or the

	 * remote side already has done a half-close and won't send

	 * more data.  Skip this if the connection is in T/TCP

	 * half-open state.

		long adv = min(recwin, (long)TCP_MAXWIN << tp->rcv_scale) -

		u_int adv = min(recwin, ((u_int)TCP_MAXWIN << tp->rcv_scale) -

			(tp->rcv_adv - tp->rcv_nxt);

			(tp->rcv_adv - tp->rcv_nxt));

		if (adv >= (long) (2 * tp->t_maxseg))

		/*

		 * Send an update when we can increase by more than

		 * 1/4th of the socket buffer capacity.

		 * When the buffer is getting full or is very small

		 * be more aggressive and send an update whenever

		 * we can increase by two mss sized segments.

		 * In all other situations the ACK's to new incoming

		 * data will carry further increases.

		 */

		if (adv >= 2 * tp->t_maxseg &&

		    (adv >= so->so_rcv.sb_hiwat / 4 ||

		     recwin <= so->so_rcv.sb_hiwat / 8 ||

		     so->so_rcv.sb_hiwat <= 8 * tp->t_maxopd))