721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * CDDL HEADER START
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The contents of this file are subject to the terms of the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Common Development and Distribution License (the "License").
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * You may not use this file except in compliance with the License.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * See the License for the specific language governing permissions
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and limitations under the License.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * When distributing Covered Code, include this CDDL HEADER in each
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If applicable, add the following below this CDDL HEADER, with the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fields enclosed by brackets "[]" replaced with your own identifying
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * information: Portions Copyright [yyyy] [name of copyright owner]
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * CDDL HEADER END
66cd0f60c3182913d379abb730ae755bf6367126Kacheong Poon * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
2404c9e6b54f427b32dd0a2d46940d6a4c5299bcPatrick Mooney * Copyright 2016 Joyent, Inc.
633fc3a6eed35d918db16925b7048d7a2e28064aSebastien Roy * Copyright (c) 2014 by Delphix. All rights reserved.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* This file contains all TCP input processing functions. */
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * RFC7323-recommended phrasing of TSTAMP option, for easier parsing
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#define TCPOPT_NOP_NOP_TSTAMP ((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | \
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#define TCPOPT_NOP_NOP_TSTAMP ((10 << 24) | (TCPOPT_TSTAMP << 16) | \
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * PAWS needs a timer for 24 days. This is the number of ticks in 24 days
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#define PAWS_TIMEOUT ((clock_t)(24*24*60*60*hz))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Since tcp_listener is not cleared atomically with tcp_detached
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * being cleared we need this extra bit to tell a detached connection
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * apart from one that is in the process of being accepted.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Steps to do when a tcp_t moves to TIME-WAIT state.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This connection is done, we don't need to account for it. Decrement
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the listener connection counter if needed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Decrement the connection counter of the stack. Note that this counter
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is per CPU. So the total number of connections in a stack is the sum of all
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of them. Since there is no lock for handling all of them exclusively, the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * resulting sum is only an approximation.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Unconditionally clear the exclusive binding bit so this TIME-WAIT
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection won't interfere with new ones.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Start the TIME-WAIT timer. If upper layer has not closed the connection,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the timer is handled within the context of this tcp_t. When the timer
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fires, tcp_clean_death() is called. If upper layer closes the connection
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * during this period, tcp_time_wait_append() will be called to add this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_t to the global TIME-WAIT list. Note that this means that the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * actual wait time in TIME-WAIT state will be longer than the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcps_time_wait_interval since the period before upper layer closes the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection is not accounted for when tcp_time_wait_append() is called.
2404c9e6b54f427b32dd0a2d46940d6a4c5299bcPatrick Mooney * If upper layer has closed the connection, call tcp_time_wait_append()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (uint64_t *)&(tcps)->tcps_sc[CPU->cpu_seqid]->tcp_sc_conn_cnt); \
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCP_TIMER_RESTART(tcp, (tcps)->tcps_time_wait_interval); \
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If tcp_drop_ack_unsent_cnt is greater than 0, when TCP receives more
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * than tcp_drop_ack_unsent_cnt number of ACKs which acknowledge unsent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * data, TCP will not respond with an ACK. RFC 793 requires that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP responds with an ACK for such a bogus ACK. By not following
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the RFC, we prevent TCP from getting into an ACK storm if somehow
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * an attacker successfully spoofs an acceptable segment to our
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * peer; or when our peer is "confused."
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * To protect TCP against attacker using a small window and requesting
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * large amount of data (DoS attack by conuming memory), TCP checks the
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * window advertised in the last ACK of the 3-way handshake. TCP uses
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * the tcp_mss (the size of one packet) value for comparion. The window
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * should be larger than tcp_mss. But while a sane TCP should advertise
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * a receive window larger than or equal to 4*MSS to avoid stop and go
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * tarrfic, not all TCP stacks do that. This is especially true when
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * tcp_mss is a big value.
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * To work around this issue, an additional fixed value for comparison
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * is also used. If the advertised window is smaller than both tcp_mss
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * and tcp_init_wnd_chk, the ACK is considered as invalid. So for large
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * tcp_mss value (say, 8K), a window larger than tcp_init_wnd_chk but
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon * smaller than 8K is considered to be OK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* Process ICMP source quench message or not. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic boolean_t tcp_icmp_source_quench = B_FALSE;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic boolean_t tcp_outbound_squeue_switch = B_FALSE;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic mblk_t *tcp_conn_create_v4(conn_t *, conn_t *, mblk_t *,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic mblk_t *tcp_conn_create_v6(conn_t *, conn_t *, mblk_t *,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_icmp_error_ipv6(tcp_t *, mblk_t *, ip_recv_attr_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic mblk_t *tcp_input_add_ancillary(tcp_t *, mblk_t *, ip_pkt_t *,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_input_listener(void *, mblk_t *, void *, ip_recv_attr_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_process_options(tcp_t *, tcpha_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic mblk_t *tcp_reass(tcp_t *, mblk_t *, uint32_t);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_reass_elim_overlap(tcp_t *, mblk_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_rsrv_input(void *, mblk_t *, void *, ip_recv_attr_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poonstatic void tcp_setcred_data(mblk_t *, ip_recv_attr_t *);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set the MSS associated with a particular tcp based on its current value,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and a new one passed in. Observe minimums and maximums, and reset other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * state variables that we want to view as multiples of MSS.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The value of MSS could be either increased or descreased.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Unless naglim has been set by our client to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a non-mss value, force naglim to track mss.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This can help to aggregate small writes.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (mss < tcp->tcp_naglim || tcp->tcp_mss == tcp->tcp_naglim)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP should be able to buffer at least 4 MSS data for obvious
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * performance reason.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set the send lowater to at least twice of MSS.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update tcp_cwnd according to the new value of MSS. Keep the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * previous ratio to preserve the transmit rate.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_cwnd = (tcp->tcp_cwnd / tcp->tcp_mss) * mss;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Extract option values from a tcp header. We put any found values into the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcpopt struct and return a bitmask saying which options were found.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_parse_options(tcpha_t *tcpha, tcp_opt_t *tcpopt)
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * If timestamp option is aligned as recommended in RFC 7323 Appendix
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * A, and is the only option, return quickly.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen if (TCP_HDR_LENGTH(tcpha) == (uint32_t)TCP_MIN_HEADER_LENGTH +
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen tcpopt->tcp_opt_ts_val = ABE32_TO_U32((up+4));
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen tcpopt->tcp_opt_ts_ecr = ABE32_TO_U32((up+8));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Caller must handle tcp_mss_min and tcp_mss_max_* */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (len < TCPOPT_WS_LEN || up[1] != TCPOPT_WS_LEN)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If TCP is not interested in SACK blks... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the list is empty, allocate one and assume
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * nothing is sack'ed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Make sure tcp_notsack_list is not NULL.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This happens when kmem_alloc(KM_NOSLEEP)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * returns NULL.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Bounds checking. Make sure the SACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * info is within tcp_suna and tcp_snxt.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If this SACK blk is out of bound, ignore
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * it but continue to parse the following
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (len <= 1 || len < (int)up[1] || up[1] == 0)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Process all TCP option in SYN segment. Note that this function should
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be called after tcp_set_destination() is called so that the necessary info
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * from IRE is already set in the tcp structure.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This function sets up the correct tcp_mss value according to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * MSS option value and our header size. It also sets up the window scale
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and timestamp values, and initialize SACK info blocks. But it does not
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * change receive window size after setting the tcp_mss value. The caller
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should do the appropriate change.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_process_options(tcp_t *tcp, tcpha_t *tcpha)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Process MSS option. Note that MSS option value does not account
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for IP or TCP options. This means that it is equal to MTU - minimum
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * IP+TCP header size, which is 40 bytes for IPv4 and 60 bytes for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Process Window Scale option. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Process Timestamp option. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (tcp->tcp_snd_ts_ok || TCP_IS_DETACHED(tcp))) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(connp->conn_ht_ulp_len == TCP_MIN_HEADER_LENGTH);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fill in our template header with basic timestamp option. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon connp->conn_ht_iphc_len += TCPOPT_REAL_TS_LEN;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_tcpha->tha_offset_and_reserved += (3 << 4);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Process SACK options. If SACK is enabled for this connection,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * then allocate the SACK info structure. Note the following ways
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * when tcp_snd_sack_ok is set to true.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For active connection: in tcp_set_destination() called in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_connect().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For passive connection: in tcp_set_destination() called in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_input_listener().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * That's the reason why the extra TCP_IS_DETACHED() check is there.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * That check makes sure that if we did not send a SACK OK option,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we will not enable SACK for this connection even though the other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * side sends us SACK OK option. For active connection, the SACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * info structure has already been allocated. So we need to free
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * it if SACK is disabled.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (tcps->tcps_sack_permitted != 0 && TCP_IS_DETACHED(tcp)))) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Resetting tcp_snd_sack_ok to B_FALSE so that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * no SACK info will be used for this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection. This assumes that SACK usage
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * permission is negotiated. This may need
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to be changed once this is clarified.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Now we know the exact TCP/IP header length, subtract
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that from tcp_mss to get our side's MSS.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Here we assume that the other side's header size will be equal to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * our header size. We calculate the real MSS accordingly. Need to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * take into additional stuffs IPsec puts in.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Real MSS = Opt.MSS - (our TCP/IP header - min TCP/IP header)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcpopt.tcp_opt_mss -= connp->conn_ht_iphc_len +
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IP_SIMPLE_HDR_LENGTH : IPV6_HDR_LEN) + TCP_MIN_HEADER_LENGTH);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set MSS to the smaller one of both ends of the connection.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We should not have called tcp_mss_set() before, but our
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * side of the MSS should have been set to a proper value
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * by tcp_set_destination(). tcp_mss_set() will also set up the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * STREAM head parameters properly.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we have a larger-than-16-bit window but the other side
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * didn't want to do window scale, tcp_rwnd_set() will take
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * care of that.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_mss_set(tcp, MIN(tcpopt.tcp_opt_mss, tcp->tcp_mss));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Initialize tcp_cwnd value. After tcp_mss_set(), tcp_mss has been
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * updated properly.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCP_SET_INIT_CWND(tcp, tcp->tcp_mss, tcps->tcps_slow_start_initial);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Add a new piece to the tcp reassembly queue. If the gap at the beginning
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is filled, return as much as we can. The message passed in may be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * multi-part, chained using b_cont. "start" is the starting sequence
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * number for this piece.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_reass(tcp_t *tcp, mblk_t *mp, uint32_t start)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Walk through all the new pieces. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Empty. Blast it. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* New stuff completely beyond tail? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Link it on end. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* New stuff at the front? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Yes... Check for overlap. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The new piece fits somewhere between the head and tail.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We find our slot, where mp1 precedes us and mp2 trails.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon for (; (mp2 = mp1->b_cont) != NULL; mp1 = mp2) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Link ourselves in */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Trim overlap with following mblk(s) first */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Trim overlap with preceding mblk */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Anything ready to go? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Eat what we can off the queue */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* Eliminate any overlap that mp may have over later mblks */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCPS_UPDATE_MIB(tcps, tcpInDataDupBytes, end - u1);
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * This function does PAWS protection check, per RFC 7323 section 5. Requires
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * that timestamp options are already processed into tcpoptp. Returns B_TRUE if
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * the segment passes the PAWS test, else returns B_FALSE.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonentcp_paws_check(tcp_t *tcp, const tcp_opt_t *tcpoptp)
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen /* This segment is not acceptable. */
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * Connection has been idle for
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * too long. Reset the timestamp
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Defense for the SYN attack -
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 1. When q0 is full, drop from the tail (tcp_eager_prev_drop_q0) the oldest
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * one from the list of droppable eagers. This list is a subset of q0.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * see comments before the definition of MAKE_DROPPABLE().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 2. Don't drop a SYN request before its first timeout. This gives every
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * request at least til the first timeout to complete its 3-way handshake.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 3. Maintain tcp_syn_rcvd_timeout as an accurate count of how many
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * requests currently on the queue that has timed out. This will be used
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * as an indicator of whether an attack is under way, so that appropriate
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * actions can be taken. (It's incremented in tcp_timer() and decremented
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * either when eager goes into ESTABLISHED, or gets freed up.)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 4. The current threshold is - # of timeout > q0len/4 => SYN alert on
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * # of timeout drops back to <= q0len/32 => SYN alert off
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(tcp->tcp_eager_next_q0 != tcp->tcp_eager_prev_q0);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Pick oldest eager from the list of droppable eagers */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If list is empty. return B_FALSE */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If allocated, the mp will be freed in tcp_clean_death_wrapper() */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Take this eager out from the list of droppable eagers since we are
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * going to drop it.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_drop_q0: listen half-open queue (max=%d) overflow"
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon " (%d pending) on %s, drop one", tcps->tcps_conn_req_max_q0,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Put a reference on the conn as we are enqueueing it in the sqeue */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_clean_death_wrapper, eager->tcp_connp, NULL,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Handle a SYN on an AF_INET6 socket; can be either IPv4 or IPv6
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_conn_create_v6(conn_t *lconnp, conn_t *connp, mblk_t *mp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IN6_IPADDR_TO_V4MAPPED(ipha->ipha_dst, &connp->conn_laddr_v6);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IN6_IPADDR_TO_V4MAPPED(ipha->ipha_src, &connp->conn_faddr_v6);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sin6.__sin6_src_id = ip_srcid_find_addr(&connp->conn_laddr_v6,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_recvdstaddr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sin6.sin6_flowinfo = ip6h->ip6_vcf & ~IPV6_VERS_AND_FLOW_MASK;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sin6.__sin6_src_id = ip_srcid_find_addr(&connp->conn_laddr_v6,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Pass up the scope_id of remote addr */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_recvdstaddr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (IN6_IS_ADDR_LINKSCOPE(&connp->conn_laddr_v6))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* Handle a SYN on an AF_INET socket */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_conn_create_v4(conn_t *lconnp, conn_t *connp, mblk_t *mp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IN6_IPADDR_TO_V4MAPPED(ipha->ipha_dst, &connp->conn_laddr_v6);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IN6_IPADDR_TO_V4MAPPED(ipha->ipha_src, &connp->conn_faddr_v6);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (lconnp->conn_recv_ancillary.crb_recvdstaddr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sizeof (sin_t), (t_scalar_t)ltcp->tcp_conn_req_seqnum);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Called via squeue to get on to eager's perimeter. It sends a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TH_RST if eager is in the fanout table. The listener wants the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * eager to disappear either by means of tcp_eager_blowoff() or
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_eager_cleanup() being called. tcp_eager_kill() can also be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * called (via squeue) if the eager cannot be inserted in the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fanout table in tcp_input_listener().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* ARGSUSED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_eager_kill(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We could be called because listener is closing. Since
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the eager was using listener's queue's, we avoid
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * using the listeners queues from now on.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * An eager's conn_fanout will be NULL if it's a duplicate
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for an existing 4-tuples in the conn fanout table.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We don't want to send an RST out in such case.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (econnp->conn_fanout != NULL && eager->tcp_state > TCPS_LISTEN) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* We are here because listener wants this eager gone */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The eager has sent a conn_ind up to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener but listener decides to close
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * instead. We need to drop the extra ref
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * placed on eager in tcp_input_data() before
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sending the conn_ind to listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Reset any eager connection hanging off this listener marked
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * with 'seqnum' and then reclaim it's resources.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_eager_blowoff(tcp_t *listener, t_scalar_t seqnum)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } while (eager->tcp_conn_req_seqnum != seqnum);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp, tcp_eager_kill,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_connp, NULL, SQ_FILL, SQTAG_TCP_EAGER_BLOWOFF);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Reset any eager connection hanging off this listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and then reclaim it's resources.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_eager_cleanup(tcp_t *listener, boolean_t q0_only)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(MUTEX_HELD(&listener->tcp_eager_lock));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* First cleanup q */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Then cleanup q0 */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(eager->tcp_connp->conn_sqp, mp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_eager_kill, eager->tcp_connp, NULL, SQ_FILL,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we are an eager connection hanging off a listener that hasn't
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * formally accepted the connection yet, get off his list and blow off
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * any data that we have accumulated.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(MUTEX_HELD(&listener->tcp_eager_lock));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Remove the eager tcp from q0 */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Take the eager out, if it is in the list of droppable
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* we have timed out before */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon for (; tcpp[0]; tcpp = &tcpp[0]->tcp_eager_next_q) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we are unlinking the last
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * element on the list, adjust
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tail pointer. Set tail pointer
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to nil when list is empty.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We won't get here if there
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is only one eager in the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* BEGIN CSTYLED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The sockfs ACCEPT path:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * =======================
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The eager is now established in its own perimeter as soon as SYN is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * received in tcp_input_listener(). When sockfs receives conn_ind, it
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * completes the accept processing on the acceptor STREAM. The sending
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of conn_ind part is common for both sockfs listener and a TLI/XTI
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener but a TLI/XTI listener completes the accept processing
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on the listener perimeter.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Common control flow for 3 way handshake:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ----------------------------------------
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * incoming SYN (listener perimeter) -> tcp_input_listener()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * incoming SYN-ACK-ACK (eager perim) -> tcp_input_data()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send T_CONN_IND (listener perim) -> tcp_send_conn_ind()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Sockfs ACCEPT Path:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * -------------------
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * open acceptor stream (tcp_open allocates tcp_tli_accept()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * as STREAM entry point)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * soaccept() sends T_CONN_RES on the acceptor STREAM to tcp_tli_accept()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_tli_accept() extracts the eager and makes the q->q_ptr <-> eager
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * association (we are not behind eager's squeue but sockfs is protecting us
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and no one knows about this stream yet. The STREAMS entry point q->q_info
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is changed to point at tcp_wput().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_accept_common() sends any deferred eagers via tcp_send_pending() to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener (done on listener's perimeter).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_tli_accept() calls tcp_accept_finish() on eagers perimeter to finish
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TLI/XTI client ACCEPT path:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ---------------------------
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * soaccept() sends T_CONN_RES on the listener STREAM.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_tli_accept() -> tcp_accept_swap() complete the processing and send
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a M_SETOPS mblk to eager perimeter to finish accept (tcp_accept_finish()).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener->tcp_eager_lock protects the listeners->tcp_eager_next_q0 and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and listeners->tcp_eager_next_q.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Referencing:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ============
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 1) We start out in tcp_input_listener by eager placing a ref on
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener and listener adding eager to listeners->tcp_eager_next_q0.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 2) When a SYN-ACK-ACK arrives, we send the conn_ind to listener. Before
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * doing so we place a ref on the eager. This ref is finally dropped at the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * end of tcp_accept_finish() while unwinding from the squeue, i.e. the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * reference is dropped by the squeue framework.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 3) The ref on listener placed in 1 above is dropped in tcp_accept_finish
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The reference must be released by the same entity that added the reference
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * In the above scheme, the eager is the entity that adds and releases the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * references. Note that tcp_accept_finish executes in the squeue of the eager
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * (albeit after it is attached to the acceptor stream). Though 1. executes
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in the listener's squeue, the eager is nascent at this point and the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * reference can be considered to have been added on behalf of the eager.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Eager getting a Reset or listener closing:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ==========================================
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Once the listener and eager are linked, the listener never does the unlink.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the listener needs to close, tcp_eager_cleanup() is called which queues
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a message on all eager perimeter. The eager then does the unlink, clears
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * any pointers to the listener's queue and drops the reference to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener. The listener waits in tcp_close outside the squeue until its
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * refcount has dropped to 1. This ensures that the listener has waited for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * all eagers to clear their association with the listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Similarly, if eager decides to go away, it can unlink itself and close.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * When the T_CONN_RES comes down, we check if eager has closed. Note that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the reference to eager is still valid because of the extra ref we put
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in tcp_send_conn_ind.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Listener can always locate the eager under the protection
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of the listener->tcp_eager_lock, and then do a refhold
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on the eager during the accept processing.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The acceptor stream accesses the eager in the accept processing
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * based on the ref placed on eager before sending T_conn_ind.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The only entity that can negate this refhold is a listener close
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * which is mutually exclusive with an active acceptor stream.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Eager's reference on the listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ===================================
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the accept happens (even on a closed eager) the eager drops its
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * reference on the listener at the start of tcp_accept_finish. If the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * eager is killed due to an incoming RST before the T_conn_ind is sent up,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the reference is dropped in tcp_closei_local. If the listener closes,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the reference is dropped in tcp_eager_kill. In all cases the reference
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is dropped while executing in the eager's context (squeue).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* END CSTYLED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* Process the SYN packet, mp, directed at the listener 'tcp' */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * THIS FUNCTION IS DIRECTLY CALLED BY IP VIA SQUEUE FOR SYN.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_input_data will not see any packets for listeners since the listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * has conn_recv set to tcp_input_listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* ARGSUSED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_input_listener(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_stack_t *ipst = tcps->tcps_netstack->netstack_ip;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon flags = (unsigned int)tcpha->tha_flags & 0xFF;
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP5(receive, mblk_t *, NULL, ip_xmit_attr_t *, lconnp->conn_ixa,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire __dtrace_tcp_void_ip_t *, mp->b_rptr, tcp_t *, listener,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Note this executes in listener's squeue */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_xmit_listeners_reset(mp, ira, ipst, lconnp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The system is under memory pressure, so we need to do our part
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to relieve the pressure. So we only accept new request if there
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is nothing waiting to be accepted or waiting to complete the 3-way
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * handshake. This means that busy listener will not get too many
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * new requests which they cannot handle in time while non-busy
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener is still functioning properly.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcps->tcps_reclaim && (listener->tcp_conn_req_cnt_q > 0 ||
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (listener->tcp_conn_req_cnt_q >= listener->tcp_conn_req_max) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) strlog(TCP_MOD_ID, 0, 1, SL_TRACE|SL_ERROR,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_input_listener: listen backlog (max=%d) "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "overflow (%d pending) on %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon listener->tcp_conn_req_max + tcps->tcps_conn_req_max_q0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Q0 is full. Drop a pending half-open req from the queue
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to make room for the new SYN req. Also mark the time we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * drop a SYN.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * A more aggressive defense against SYN attack will
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be to set the "tcp_syn_defense" flag now.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon listener->tcp_last_rcv_lbolt = ddi_get_lbolt64();
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_input_listener: listen half-open "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "queue (max=%d) full (%d pending) on %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Enforce the limit set on the number of connections per listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that tlc_cnt starts with 1. So need to add 1 to tlc_max
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for comparison.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_listen_cnt_t *tlc = listener->tcp_listen_cnt;
1a5e258f5471356ca102c7176637cdce45bac147Josef 'Jeff' Sipek if (atomic_inc_32_nv(&tlc->tlc_cnt) > tlc->tlc_max + 1) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "Listener (port %d) connection max (%u) "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "reached: %u attempts dropped total\n",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * IP sets ira_sqp to either the senders conn_sqp (for loopback)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * or based on the ring (for packets from GLD). Otherwise it is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * set based on lbolt i.e., a somewhat random number.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(econnp->conn_netstack == lconnp->conn_netstack);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* We already know the laddr of the new connection is ours */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon econnp->conn_ixa->ixa_src_generation = ipst->ips_src_generation;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION ||
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tpi_mp = tcp_conn_create_v4(lconnp, econnp, mp, ira);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tpi_mp = tcp_conn_create_v6(lconnp, econnp, mp, ira);
707e74bc53cd429bcd731df722227c7dc2de47c6Kacheong Poon * Initialize the eager's tcp_t and inherit some parameters from
707e74bc53cd429bcd731df722227c7dc2de47c6Kacheong Poon * the listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon econnp->conn_ixa->ixa_flags |= IXAF_NO_DEV_FLOW_CTL;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Prepare for diffing against previous packets */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!(ira->ira_flags & IRAF_IS_IPV4) && econnp->conn_bound_if == 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (IN6_IS_ADDR_LINKSCOPE(&econnp->conn_faddr_v6) ||
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon IN6_IS_ADDR_LINKSCOPE(&econnp->conn_laddr_v6)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon econnp->conn_ixa->ixa_flags |= IXAF_SCOPEID_SET;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((ira->ira_flags & (IRAF_IS_IPV4|IRAF_IPV4_OPTIONS)) ==
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Source routing option copyover (reverse it) */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(eager->tcp_conn.tcp_eager_conn_ind == NULL);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the SYN came with a credential, it's a loopback packet or a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * labeled packet; attach the credential to the TPI message.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mblk_setcred(tpi_mp, ira->ira_cred, ira->ira_cpid);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Inherit the listener's non-STREAMS flag */
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson /* All non-STREAMS tcp_ts are sockets */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Pre-allocate the T_ordrel_ind mblk for TPI socket so that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * at close time, we will always have that to send up.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Otherwise, we need to do special handling in case the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * allocation fails at that time.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((eager->tcp_ordrel_mp = mi_tpi_ordrel_ind()) == NULL)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Now that the IP addresses and ports are setup in econnp we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * can do the IPsec policy work.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Inherit the policy from the listener; use
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * actions from ira
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!ip_ipsec_policy_inherit(econnp, lconnp, ira)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_set_destination() may set tcp_rwnd according to the route
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * metrics. If it does not, the eager's receive window will be set
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to the listener's receive window later in this function.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Discard any old label */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If this is an MLP connection or a MAC-Exempt
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection with an unlabeled node, packets are to be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * exchanged using the security label of the received
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * SYN packet instead of the server application's label.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tsol_check_dest called from ip_set_destination
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * might later update TSF_UNLABELED by replacing
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ixa_tsl with a new label.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * conn_connect() called from tcp_set_destination will verify
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the destination is allowed to receive packets at the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * security label of the SYN-ACK we are generating. As part of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that, tsol_check_dest() may create a new effective label for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this connection.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Finally conn_connect() will call conn_update_label.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * All that remains for TCP to do is to call
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * conn_build_hdr_template which is done as part of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_set_destination.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Since we will clear tcp_listener before we clear tcp_detached
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in the accept code we need tcp_hard_binding aka tcp_accept_inprogress
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * so we can tell a TCP_IS_DETACHED_NONEAGER apart.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCP_BIND_HASH(econnp->conn_lport)], eager, 0);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Adapt our mss, ttl, ... based on the remote address.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Undo the bind_hash_insert */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Process all TCP options. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Is the other end ECN capable? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (tcpha->tha_flags & (TH_ECE|TH_CWR)) == (TH_ECE|TH_CWR)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The listener's conn_rcvbuf should be the default window size or a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window size changed via SO_RCVBUF option. First round up the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * eager's tcp_rwnd to the nearest MSS. Then find out the window
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * scale option value if needed. Call tcp_rwnd_set() to finish the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note if there is a rpipe metric associated with the remote host,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we should not inherit receive window size from listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that this is the only place tcp_rwnd_set() is called for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * accepting a connection. We need to call it here instead of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * after the 3-way handshake because we need to tell the other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * side our rwnd in the SYN-ACK segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_connp->conn_rcvbuf == eager->tcp_rwnd);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Put a ref on the listener for the eager. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon listener->tcp_eager_next_q0->tcp_eager_prev_q0 = eager;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_eager_next_q0 = listener->tcp_eager_next_q0;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Set tcp_listener before adding it to tcp_conn_fanout */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set tcp_listen_cnt so that when the connection is done, the counter
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is decremented.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_listen_cnt = listener->tcp_listen_cnt;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Tag this detached tcp vector for later retrieval
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * by our listener client in tcp_accept().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_conn_req_seqnum = listener->tcp_conn_req_seqnum;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * -1 is "special" and defined in TPI as something
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that should never be used in T_CONN_IND
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Don't drop the SYN that comes from a good IP source */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon addr_cache = (ipaddr_t *)(listener->tcp_ip_addr_cache);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (addr_cache != NULL && econnp->conn_faddr_v4 ==
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon addr_cache[IP_ADDR_CACHE_HASH(econnp->conn_faddr_v4)]) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We need to insert the eager in its own perimeter but as soon
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * as we do that, we expose the eager to the classifier and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should not touch any field outside the eager's perimeter.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * So do all the work necessary before inserting the eager
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in its own perimeter. Be optimistic that conn_connect()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will succeed but undo everything if it fails.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon eager->tcp_tcpha->tha_ack = htonl(eager->tcp_rnxt);
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP6(state__change, void, NULL, ip_xmit_attr_t *,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire econnp->conn_ixa, void, NULL, tcp_t *, eager, void, NULL,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp1 = tcp_xmit_mp(eager, eager->tcp_xmit_head, eager->tcp_mss,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon NULL, NULL, eager->tcp_iss, B_FALSE, NULL, B_FALSE);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Increment the ref count as we are going to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * enqueueing an mp in squeue
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We need to start the rto timer. In normal case, we start
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the timer after sending the packet on the wire (or at
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * least believing that packet was sent by waiting for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * conn_ip_output() to return). Since this is the first packet
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * being sent on the wire for the eager, our initial tcp_rto
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is at least tcp_rexmit_interval_min which is a fairly
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * large value to allow the algorithm to adjust slowly to large
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fluctuations of RTT during first few transmissions.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Starting the timer first and then sending the packet in this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * case shouldn't make much difference since tcp_rexmit_interval_min
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is of the order of several 100ms and starting the timer
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * first and then sending the packet will result in difference
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of few micro seconds.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Without this optimization, we are forced to hold the fanout
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * lock across the ipcl_bind_insert() and sending the packet
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * so that we don't race against an incoming packet (maybe RST)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for this eager.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * It is necessary to acquire an extra reference on the eager
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * at this point and hold it until after tcp_send_data() to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ensure against an eager close race.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Insert the eager in its own perimeter now. We are ready to deal
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * with any packets on eager.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(econnp->conn_ixa->ixa_notify_cookie == econnp->conn_tcp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send the SYN-ACK. Use the right squeue so that conn_ixa is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * only used by one thread at a time.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP5(send, mblk_t *, NULL, ip_xmit_attr_t *,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire econnp->conn_ixa, __dtrace_tcp_void_ip_t *, mp1->b_rptr,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire &mp1->b_rptr[econnp->conn_ixa->ixa_ip_hdr_length]);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(econnp->conn_sqp, mp1, tcp_send_synack,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon econnp, NULL, SQ_PROCESS, SQTAG_TCP_SEND_SYNACK);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(econnp->conn_sqp, mp1, tcp_eager_kill,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If a connection already exists, send the mp to that connections so
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that it can be appropriately dealt with.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((econnp = ipcl_classify(mp, ira, ipst)) != NULL) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Something bad happened. ipcl_conn_insert()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * failed because a connection already existed
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in connected hash but we can't find it
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * anymore (someone blew it away). Just
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * free this message and hopefully remote
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will retransmit at which time the SYN can be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * treated as a new connection or dealth with
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a TH_RST if a connection already exists.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(econnp->conn_sqp, mp, tcp_input_data,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Nobody wants this packet */
1a5e258f5471356ca102c7176637cdce45bac147Josef 'Jeff' Sipek atomic_dec_32(&listener->tcp_listen_cnt->tlc_cnt);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * In an ideal case of vertical partition in NUMA architecture, its
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * beneficial to have the listener and all the incoming connections
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tied to the same squeue. The other constraint is that incoming
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connections should be tied to the squeue attached to interrupted
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * CPU for obvious locality reason so this leaves the listener to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be tied to the same squeue. Our only problem is that when listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is binding, the CPU that will get interrupted by the NIC whose
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * IP address the listener is binding to is not even known. So
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the code below allows us to change that binding at the time the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * CPU is interrupted by virtue of incoming connection's squeue.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This is usefull only in case of a listener bound to a specific IP
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * address. For other kind of listeners, they get bound the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * very first time and there is no attempt to rebind them.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_input_listener_unbound(void *arg, mblk_t *mp, void *arg2,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * IP sets ira_sqp to either the senders conn_sqp (for loopback)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * or based on the ring (for packets from GLD). Otherwise it is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * set based on lbolt i.e., a somewhat random number.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!(connp->conn_flags & IPCL_FULLY_BOUND)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * No one from read or write side can access us now
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * except for already queued packets on this squeue.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * But since we haven't changed the squeue yet, they
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * can't execute. If they are processed after we have
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * changed the squeue, they are sent back to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * correct squeue down below.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * But a listner close can race with processing of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * incoming SYN. If incoming SYN processing changes
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the squeue then the listener close which is waiting
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to enter the squeue would operate on the wrong
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * squeue. Hence we don't change the squeue here unless
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the refcount is exactly the minimum refcount. The
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * minimum refcount of 4 is counted as - 1 each for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP and IP, 1 for being in the classifier hash, and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 1 for the mblk being processed.
75d94465dbafa487b716482dc36d5150a4ec9853Josef 'Jeff' Sipek (void) atomic_cas_ptr(&connp->conn_sqp, sqp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* No special MT issues for outbound ixa_sqp hint */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } while (!(connp->conn_flags & IPCL_FULLY_BOUND));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Assume we have picked a good squeue for the listener. Make
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * subsequent SYNs not try to change the squeue.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(connp->conn_sqp, mp, connp->conn_recv, connp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send up all messages queued on tcp_rcv_list.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Can't drain on an eager connection */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Can't be a non-STREAMS connection */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* No need for the push timer now. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) TCP_TIMER_CANCEL(tcp, tcp->tcp_push_tid);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Handle two cases here: we are currently fused or we were
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * previously fused and have some urgent data to be delivered
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * upstream. The latter happens because we either ran out of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * memory or were detached and therefore sending the SIGURG was
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * deferred until this point. In either case we pass control
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * over to tcp_fuse_rcv_drain() since it may need to complete
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((tcp->tcp_fused || tcp->tcp_fused_sigurg)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp_fuse_rcv_drain(q, tcp, tcp->tcp_fused ? NULL :
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Queue data on tcp_rcv_list which is a b_next chain.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_rcv_last_head/tail is the last element of this chain.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Each element of the chain is a b_cont chain.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * M_DATA messages are added to the current element.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Other messages are added as new (b_next) elements.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_rcv_enqueue(tcp_t *tcp, mblk_t *mp, uint_t seg_len, cred_t *cr)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(tcp->tcp_rcv_list == NULL || tcp->tcp_rcv_last_head != NULL);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(cr != NULL || msg_getcred(mp, NULL) != NULL);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Provide for protocols above TCP such as RPC. NOPID leaves
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * db_cpid unchanged.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The cred could have already been set.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } else if (DB_TYPE(mp) == DB_TYPE(tcp->tcp_rcv_last_head)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* Generate an ACK-only (no data) segment for a TCP endpoint */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There are a few cases to be considered while setting the sequence no.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Essentially, we can come here while processing an unacceptable pkt
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in the TCPS_SYN_RCVD state, in which case we set the sequence number
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to snxt (per RFC 793), note the swnd wouldn't have been set yet.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we are here for a zero window probe, stick with suna. In all
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * other cases, we check if suna + swnd encompasses snxt and set
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the sequence number to snxt, if so. If snxt falls outside the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window (the receiver probably shrunk its window), we will go with
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * suna + swnd, otherwise the sequence no will be unacceptable to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (tcp->tcp_suna + tcp->tcp_swnd) : tcp->tcp_snxt;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For the complex case where we have to send some
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * controls (FIN or SYN), let tcp_xmit_mp do it.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon return (tcp_xmit_mp(tcp, NULL, 0, NULL, NULL, seq_no, B_FALSE,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Generate a simple ACK */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Allocate space for TCP + IP headers
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and link-level header
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_num_sack_blk > 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sack_opt_len = num_sack_blk * sizeof (sack_blk_t) +
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon total_hdr_len = connp->conn_ht_iphc_len + sack_opt_len;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_hdr_len = connp->conn_ht_ulp_len + sack_opt_len;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp1 = allocb(total_hdr_len + tcps->tcps_wroff_xtra, BPRI_MED);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Update the latest receive window size in TCP header. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* copy in prototype TCP + IP header */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon bcopy(connp->conn_ht_iphc, rptr, connp->conn_ht_iphc_len);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcpha = (tcpha_t *)&rptr[ixa->ixa_ip_hdr_length];
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Set the TCP sequence number. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Set up the TCP flag field. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* fill in timestamp option if in use */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fill in SACK options */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon for (i = 0; i < num_sack_blk; i++) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ((ipha_t *)rptr)->ipha_length = htons(total_hdr_len);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip6->ip6_plen = htons(total_hdr_len - IPV6_HDR_LEN);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Prime pump for checksum calculation in IP. Include the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * adjustment for a source route if any.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon data_length = (data_length >> 16) + (data_length & 0xFFFF);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon connp->conn_ixa->ixa_flags |= IXAF_REACH_CONF;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon connp->conn_ixa->ixa_flags &= ~IXAF_REACH_CONF;
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * Dummy socket upcalls for if/when the conn_t gets detached from a
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * direct-callback sonode via a user-driven close(). Easy to catch with
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * DTrace FBT, and should be mostly harmless.
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_newconn(sock_upper_handle_t x, sock_lower_handle_t y,
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald sock_downcalls_t *z, cred_t *cr, pid_t pid, sock_upcalls_t **ignored)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_connected(sock_upper_handle_t x, sock_connid_t y, cred_t *cr,
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* Normally we'd crhold(cr) and attach it to socket state. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* LINTED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_disconnected(sock_upper_handle_t x, sock_connid_t y, int blah)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald return (-1);
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_opctl(sock_upper_handle_t x, sock_opctl_action_t y, uintptr_t blah)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* We really want this one to be a harmless NOP for now. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* LINTED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_recv(sock_upper_handle_t x, mblk_t *mp, size_t len, int flags,
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * Consume the message, set ESHUTDOWN, and return an error.
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald * Nobody's home!
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald return (-1);
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_set_proto_props(sock_upper_handle_t x, struct sock_proto_props *y)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_txq_full(sock_upper_handle_t x, boolean_t y)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_signal_oob(sock_upper_handle_t x, ssize_t len)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* Otherwise, this would signal socket state about OOB data. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonaldtcp_dummy_set_error(sock_upper_handle_t x, int err)
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald/* ARGSUSED */
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald ASSERT(0); /* Panic in debug, otherwise ignore. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Handle M_DATA messages from IP. Its called directly from IP via
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * squeue for received IP packets.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The first argument is always the connp/tcp to which the mp belongs.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There are no exceptions to this rule. The caller has already put
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a reference on this connp/tcp and once tcp_input_data() returns,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the squeue will do the refrele.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The TH_SYN for the listener directly go to tcp_input_listener via
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * squeue. ICMP errors go directly to tcp_icmp_input().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sqp: NULL = recursive, sqp != NULL means called from squeue
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_input_data(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon boolean_t ofo_seg = B_FALSE; /* Out of order segment */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * RST from fused tcp loopback peer should trigger an unfuse.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_all != 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Record packet information in the ip_pkt_t
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * IPv6 packets can only be received by applications
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that are prepared to receive IPv6 addresses.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The IP fanout must ensure this.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) ip_find_hdr_v6(mp, (ip6_t *)rptr, B_TRUE, &ipp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Could have caused a pullup? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp->b_wptr - rptr) <= (uintptr_t)INT_MAX);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((mp1 = mp->b_cont) != NULL && mp1->b_datap->db_type == M_DATA) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp1->b_wptr - mp1->b_rptr) <=
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP5(receive, mblk_t *, NULL, ip_xmit_attr_t *, connp->conn_ixa,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_time_wait_processing(tcp, mp, seg_seq, seg_ack,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This is the correct place to update tcp_last_recv_time. Note
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that it is also updated for tcp structure that belongs to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * global and listener queues which do not really need updating.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * But that should not cause any harm. And it is updated for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * all kinds of incoming segments, not only for data segments.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon flags = (unsigned int)tcpha->tha_flags & 0xFF;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon DTRACE_PROBE2(tcp__trace__recv, mblk_t *, mp, tcp_t *, tcp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP can't handle urgent pointers that arrive before
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the connection has been accept()ed since it can't
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * buffer OOB data. Discard segment if this happens.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We can't just rely on a non-null tcp_listener to indicate
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that the accept() has completed since unlinking of the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * eager and completion of the accept are not atomic.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_detached, when it is not set (B_FALSE) indicates
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that the accept() has completed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Nor can it reassemble urgent pointers, so discard
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if it's not the next segment expected.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Otherwise, collapse chain into one mblk (discard if
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that fails). This makes sure the headers, retransmitted
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * data, and new data all are in the same mblk.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_detached || !pullupmsg(mp, -1)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Update pointers into message */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Since we can't handle any data with this urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * pointer that is out of sequence, we expunge
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the data. This allows us to still register
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the urgent mark and generate the M_PCSIG,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * which we can do.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp->b_wptr = (uchar_t *)tcpha + TCP_HDR_LENGTH(tcpha);
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald /* A conn_t may have belonged to a now-closed socket. Be careful. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(connp->conn_initial_sqp == connp->conn_sqp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_final_sqp != connp->conn_sqp) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon DTRACE_PROBE1(conn__final__sqp__same, conn_t *, connp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that our stack cannot send data before a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection is established, therefore the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * following check is valid. Otherwise, it has
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to be changed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Process all TCP options. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The following changes our rwnd to be a multiple of the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * MIN(peer MSS, our MSS) for performance reason.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) tcp_rwnd_set(tcp, MSS_ROUNDUP(connp->conn_rcvbuf,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Is the other end ECN capable? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Clear ECN flags because it may interfere with later
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * processing.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_tcpha->tha_ack = htonl(tcp->tcp_rnxt);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Allocate room for SACK options if needed. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) proto_set_tx_wroff(connp->conn_rq, connp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we can't get the confirmation upstream, pretend
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we didn't even see this one.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * XXX: how can we pretend we didn't see it if we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * have updated rnxt et. al.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For loopback we defer sending up the T_CONN_CON
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * until after some checks below.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_sendmsg() checks tcp_state without entering
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the squeue so tcp_state should be updated before
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * sending up connection confirmation. Probe the
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * state change below when we are sure the connection
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * confirmation has been sent.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* SYN was acked - making progress */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* One for the SYN */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If SYN was retransmitted, need to reset all
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * retransmission info. This is because this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * segment will be treated as a dup ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set tcp_cwnd back to 1 MSS, per
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * recommendation from
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Increasing TCP's Initial Window.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Always send the three-way handshake ack immediately
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * in order to make the connection complete as soon as
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * possible on the accepting host.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * Trace connect-established here.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP5(connect__established, mblk_t *, NULL,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire void_ip_t *, iphdr, tcp_t *, tcp, tcph_t *, tcpha);
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire /* Trace change from SYN_SENT -> ESTABLISHED here */
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP6(state__change, void, NULL, ip_xmit_attr_t *,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Special case for loopback. At this point we have
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * received SYN-ACK from the remote endpoint. In
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * order to ensure that both endpoints reach the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fused state prior to any data exchange, the final
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ACK needs to be sent before we indicate T_CONN_CON
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to the module upstream.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For loopback, we always get a pure SYN-ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and only need to send back the final ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * with no data (this is because the other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp is ours and we don't do T/TCP). This
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * final ACK triggers the passive side to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * perform fusion in ESTABLISHED state.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Send up T_CONN_CON */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Forget fusion; we need to handle more
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * complex cases below. Send the deferred
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * T_CONN_CON message upstream and proceed
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * as usual. Mark this tcp as not capable
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Check to see if there is data to be sent. If
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * yes, set the transmit flag. Then check to see
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if received data processing needs to be done.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If not, go straight to xmit_check. This short
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * cut is OK as we don't support T/TCP.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP6(state__change, void, NULL, ip_xmit_attr_t *,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire connp->conn_ixa, void_ip_t *, NULL, tcp_t *, tcp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp1 = tcp_xmit_mp(tcp, tcp->tcp_xmit_head, tcp->tcp_mss,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon NULL, NULL, tcp->tcp_iss, B_FALSE, NULL, B_FALSE);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * In this state, a SYN|ACK packet is either bogus
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * because the other side must be ACKing our SYN which
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * indicates it has seen the ACK for their SYN and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * shouldn't retransmit it or we're crossing SYNs
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on active open.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((flags & TH_SYN) && !tcp->tcp_active_open) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * NOTE: RFC 793 pg. 72 says this should be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp->tcp_suna <= seg_ack <= tcp->tcp_snxt
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * but that would mean we have an ack that ignored
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * No sane TCP stack will send such a small window
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * without receiving any data. Just drop this invalid
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ACK. We also shorten the abort timeout in case
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this is an attack.
32c3e7eeacbc9a513544d1b4f631fd628cec7da3Kacheong Poon pinit_wnd = ntohs(tcpha->tha_win) << tcp->tcp_snd_ws;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Only a TLI listener can come through this path when a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * acceptor is going back to be a listener and a packet
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for the acceptor hits the classifier. For a socket
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener, this can never happen because a listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * can never accept connection on itself and hence a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * socket acceptor can not go back to being a listener.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_stack_t *ipst = tcps->tcps_netstack->netstack_ip;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Don't accept any input on a closed tcp as this TCP logically
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * does not exist on the system. Don't proceed further with
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this TCP. For instance, this packet could trigger another
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * close of this tcp which would be disastrous for tcp_refcnt.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_close_detached / tcp_clean_death / tcp_closei_local must
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be called at most once on a TCP. In this case we need to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * refeed the packet into the classifier and figure out where
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the packet should go.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Drops ref on new_connp */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* We failed to classify. For now just drop the packet */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Handle the case where the tcp_clean_death() has happened
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on a connection (application hasn't closed yet) but a packet
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * was already queued on squeue before tcp_clean_death()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * was processed. Calling tcp_clean_death() twice on same
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection can result in weird behaviour.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Already on the correct queue/perimeter.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If this is a detached connection and not an eager
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * connection hanging off a listener then new data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * (past the FIN) will cause a reset.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We do a special check here where it
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is out of the main line, rather than check
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if we are detached every time we see new
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * data down below.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (seg_len > 0 && SEQ_GT(seg_seq + seg_len, tcp->tcp_rnxt))) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon DTRACE_PROBE2(tcp__trace__recv, mblk_t *, mp, tcp_t *, tcp);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp->b_rptr = (uchar_t *)tcpha + TCP_HDR_LENGTH(tcpha);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon urp = ntohs(tcpha->tha_urp) - TCP_OLD_URP_INTERPRETATION;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ((tcpha->tha_flags & TH_SYN) ? 0 : tcp->tcp_snd_ws);
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * We are interested in two TCP options: timestamps (if negotiated) and
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * SACK (if negotiated). Skip option parsing if neither is negotiated.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen if (tcp->tcp_snd_ts_ok || tcp->tcp_snd_sack_ok) {
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen options = tcp_parse_options(tcpha, &tcpopt);
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * RST segments must not be subject to PAWS and are not
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * required to have timestamps.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen if (tcp->tcp_snd_ts_ok && !(flags & TH_RST)) {
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * Per RFC 7323 section 3.2., silently drop non-RST
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * segments without expected TSopt. This is a 'SHOULD'
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * requirement.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * Leave a breadcrumb for people to detect this
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen DTRACE_TCP1(droppedtimestamp, tcp_t *, tcp);
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * This segment is not acceptable.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * Drop it and send back an ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * gap is the amount of sequence space between what we expect to see
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and what we got for seg_seq. A positive value for gap means
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * something got lost. A negative value means we got some old stuff.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Old stuff present. Is the SYN in there? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (seg_seq == tcp->tcp_irs && (flags & TH_SYN) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Recompute the gaps after noting the SYN. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Remove the old stuff from seg_len. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Anything left?
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Make sure to check for unack'd FIN when rest of data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * has been previously ack'd.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (seg_len < 0 || (seg_len == 0 && !(flags & TH_FIN))) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Resets are only valid if they lie within our offered
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window. If the RST bit is set, we just ignore this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The arriving of dup data packets indicate that we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * may have postponed an ack for too long, or the other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * side's RTT estimate is out of shape. Start acking
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * more often.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (SEQ_GEQ(seg_seq + seg_len - gap, tcp->tcp_rack) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This segment is "unacceptable". None of its
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sequence space lies within our advertized window.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Adjust seg_len to the original value for tracing.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: unacceptable, gap %d, rgap %d, "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "flags 0x%x, seg_seq %u, seg_ack %u, "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "seg_len %d, rnxt %u, snxt %u, %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Arrange to send an ACK in response to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * unacceptable segment per RFC 793 page 69. There
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is only one small difference between ours and the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * acceptability test in the RFC - we accept ACK-only
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * packet with SEG.SEQ = RCV.NXT+RCV.WND and no ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will be generated.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that we have to ACK an ACK-only packet at least
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for stacks that send 0-length keep-alives with
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * SEG.SEQ = SND.NXT-1 as recommended by RFC1122,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * section 4.2.3.6. As long as we don't ever generate
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * an unacceptable packet in response to an incoming
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * packet that is unacceptable, it should not cause
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * "ACK wars".
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Continue processing this segment in order to use the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ACK information it contains, but skip all other
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sequence-number processing. Processing the ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * information is necessary in order to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * re-synchronize connections that may have lost
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * synchronization.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We clear seg_len and flag fields related to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sequence number processing as they are not
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to be trusted for an unacceptable segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fix seg_seq, and chew the gap off the front. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } while (gap < 0);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the urgent data has already been acknowledged, we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should ignore TH_URG below
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * rgap is the amount of stuff received out of window. A negative
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * value is the amount out of window.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCPS_UPDATE_MIB(tcps, tcpInDataPastWinBytes, -rgap);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * seg_len does not include the FIN, so if more than
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * just the FIN is out of window, we act like we don't
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * see it. (If just the FIN is out of window, rgap
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will be zero and we will go ahead and acknowledge
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fix seg_len and make sure there is something left. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Resets are only valid if they lie within our offered
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window. If the RST bit is set, we just ignore this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Per RFC 793, we need to send back an ACK. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send SIGURG as soon as possible i.e. even
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if the TH_URG was delivered in a window probe
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * packet (which will be unacceptable).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We generate a signal if none has been generated
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for this connection or if this is a new urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * byte. Also send a zero-length "unmarked" message
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to inform SIOCATMARK that this is not the mark.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_urp_last_valid is cleared when the T_exdata_ind
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is sent up. This plus the check for old data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * (gap >= 0) handles the wraparound of the sequence
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * number space without having to always track the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * correct MAX(tcp_urp_last, tcp_rnxt). (BSD tracks
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this max in its rcv_up variable).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This prevents duplicate SIGURGS due to a "late"
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * zero-window probe when the T_EXDATA_IND has already
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * been sent up.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (!tcp->tcp_urp_last_valid || SEQ_GT(urp + seg_seq,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Try again on the rexmit. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the next byte would be the mark
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * then mark with MARKNEXT else mark
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * with NOTMARKNEXT.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If this is a zero window probe, continue to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * process the ACK part. But we need to set seg_len
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to 0 to avoid data processing. Otherwise just
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * drop the segment and send back an ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_rwnd == 0 && seg_seq == tcp->tcp_rnxt) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Pitch out of window stuff off the end. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp2->b_wptr - mp2->b_rptr) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP should check ECN info for segments inside the window only.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Therefore the check should be done here.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that both ECN_CE and CWR can be set in the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * same segment. In this case, we once again turn
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on ECN_ECHO.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon uchar_t tos = ((ipha_t *)rptr)->ipha_type_of_service;
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * Check whether we can update tcp_ts_recent. This test is from RFC
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen * 7323, section 5.3.
1f183ba0b0be3e10202501aa3740753df6512804Lauri Tirkkonen if (tcp->tcp_snd_ts_ok && !(flags & TH_RST) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TSTMP_GEQ(tcpopt.tcp_opt_ts_val, tcp->tcp_ts_recent) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (seg_seq != tcp->tcp_rnxt || tcp->tcp_reass_head) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * FIN in an out of order segment. We record this in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_valid_bits and the seq num of FIN in tcp_ofo_fin_seq.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Clear the FIN so that any check on FIN flag will fail.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Remember that FIN also counts in the sequence number
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * space. So we need to ack out of order FIN only segments.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fill in the SACK blk list. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Attempt reassembly and see if we have something
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ready to go.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Always ack out of order packets */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * A gap is filled and the seq num and len
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of the gap match that of a previously
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * received FIN, put the FIN flag back in.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((tcp->tcp_valid_bits & TCP_OFO_FIN_VALID) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Restart the timer if there is still
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * data in the reassembly queue.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Keep going even with NULL mp.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There may be a useful ACK or something else
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we don't want to miss.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * But TCP should not perform fast retransmit
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * because of the ack number. TCP uses
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * seg_len == 0 to determine if it is a pure
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ACK. And this is not a pure ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } else if (seg_len > 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCPS_UPDATE_MIB(tcps, tcpInDataInorderBytes, seg_len);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If an out of order FIN was received before, and the seq
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * num and len of the new segment match that of the FIN,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * put the FIN flag back in.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((tcp->tcp_valid_bits & TCP_OFO_FIN_VALID) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((flags & (TH_RST | TH_SYN | TH_URG | TH_ACK)) != TH_ACK) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * See RFC 793, Page 71
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The seq number must be in the window as it should
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be "fixed" above. If it is outside window, it should
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be already rejected. Note that we allow seg_seq to be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * rnxt + rwnd because we want to accept 0 window probe.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SEQ_LEQ(seg_seq, tcp->tcp_rnxt + tcp->tcp_rwnd));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the ACK flag is not set, just use our snxt as the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * seq number of the RST segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_xmit_ctl("TH_SYN", tcp, seg_ack, seg_seq + 1,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * urp could be -1 when the urp field in the packet is 0
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and TCP_OLD_URP_INTERPRETATION is set. This implies that the urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * byte was at seg_seq - 1, in which case we ignore the urgent flag.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Non-STREAMS sockets handle the urgent data a litte
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * differently from STREAMS based sockets. There is no
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * need to mark any mblks with the MSG{NOT,}MARKNEXT
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * flags to keep SIOCATMARK happy. Instead a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * su_signal_oob upcall is made to update the mark.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Neither is a T_EXDATA_IND mblk needed to be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * prepended to the urgent data. The urgent data is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * delivered using the su_recv upcall, where we set
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the MSG_OOB flag to indicate that it is urg data.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Neither TH_SEND_URP_MARK nor TH_MARKNEXT_NEEDED
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * are used by non-STREAMS sockets.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we haven't generated the signal yet for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this urgent pointer value, do it now. Also,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send up a zero-length M_DATA indicating
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * whether or not this is the mark. The latter
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is not needed when a T_EXDATA_IND is sent up.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * However, if there are allocation failures
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this code relies on the sender retransmitting
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and the socket code for determining the mark
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should not block waiting for the peer to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * transmit. Thus, for simplicity we always
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send up the mark indication.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Try again on the rexmit. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Mark with NOTMARKNEXT for now.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The code below will change this to MARKNEXT
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if we are at the mark.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If there are allocation failures (e.g. in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * dupmsg below) the next time tcp_input_data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sees the urgent segment it will send up the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * MSGMARKNEXT message.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: sent M_PCSIG 2 seq %x urp %x "
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "last %x, %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * An allocation failure prevented the previous
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_input_data from sending up the allocated
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * MSG*MARKNEXT message - send it up this time
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the urgent byte is in this segment, make sure that it is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * all by itself. This makes it much easier to deal with the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * possibility of an allocation failure on the T_exdata_ind.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that seg_len is the number of bytes in the segment, and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * urp is the offset into the segment of the urgent byte.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * urp < seg_len means that the urgent byte is in this segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Break it up and feed it back in.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Re-attach the IP header.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There is stuff before the urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Trim from urgent byte on.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The rest will come back.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Feed this piece back in. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the data passed back in was not
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * processed (ie: bad ACK) sending
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the remainder back in will cause a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * loop. In this case, drop the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * packet and let the sender try
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sending a good packet.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There is stuff after the urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Trim everything beyond the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * urgent byte. The rest will
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the data passed back in was not
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * processed (ie: bad ACK) sending
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the remainder back in will cause a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * loop. In this case, drop the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * packet and let the sender try
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sending a good packet.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This segment contains only the urgent byte. We
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * have to allocate the T_exdata_ind, if we can.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We should never be in middle of a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fallback, the squeue guarantees that.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Sigh... It'll be back.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Generate any MSG*MARK message now.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: allocated exdata_ind %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * There is no need to send a separate MSG*MARK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * message since the T_EXDATA_IND will be sent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Now we are all set. On the next putnext upstream,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_urp_mp will be non-NULL and will get prepended
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to what has to be this piece containing the urgent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * byte. If for any reason we abort this segment below,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if it comes back, we will have this ready, or it
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will get blown off in close.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The urgent byte is the next byte after this sequence
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * number. If this endpoint is non-STREAMS, then there
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is nothing to do here since the socket has already
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * been notified about the urg pointer by the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * su_signal_oob call above.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * In case of STREAMS, some more work might be needed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If there is data it is marked with MSGMARKNEXT and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and any tcp_urp_mark_mp is discarded since it is not
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * needed. Otherwise, if the code above just allocated
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a zero-length tcp_urp_mark_mp message, that message
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is tagged with MSGMARKNEXT. Sending up these
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * MSGMARKNEXT messages makes SIOCATMARK work correctly
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * even though the T_EXDATA_IND will not be sent up
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * until the urgent byte arrives.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: AT MARK, len %d, flags 0x%x, %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Data left until we hit mark */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: URP %d bytes left, %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * tcp_sendmsg() checks tcp_state without entering
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * the squeue so tcp_state should be updated before
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * sending up a connection confirmation or a new
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * connection indication.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * We are seeing the final ack in the three way
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * hand shake of a active open'ed connection
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * so we must send up a T_CONN_CON
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson if (!tcp_conn_con(tcp, iphdr, mp, NULL, ira)) {
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Don't fuse the loopback endpoints for
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * simultaneous active opens.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * For simultaneous active open, trace receipt of final
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * ACK as tcp:::connect-established.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson DTRACE_TCP5(connect__established, mblk_t *, NULL,
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson ip_xmit_attr_t *, connp->conn_ixa, void_ip_t *,
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * 3-way handshake has completed, so notify socket
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * of the new connection.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * We are here means eager is fine but it can
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * get a TH_RST at any point between now and till
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * accept completes and disappear. We need to
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * ensure that reference to eager is valid after
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * we get out of eager's perimeter. So we do
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * an extra refhold.
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson * The state-change probe for SYN_RCVD ->
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson * ESTABLISHED has not fired yet. We reset
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson * the state to SYN_RCVD so that future
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson * state-change probes report correct state
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson * transistions.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson /* notification did not go up, so drop ref */
e82bc0ba9649a7146fdab88089eaa4b8502b2da4Anders Persson /* ... and close the eager */
a897f6d2e042f2b384406dc1ec922005859b5f10Dan McDonald * tcp_newconn_notify() changes conn_upcalls and
a897f6d2e042f2b384406dc1ec922005859b5f10Dan McDonald * connp->conn_upper_handle. Fix things now, in case
a897f6d2e042f2b384406dc1ec922005859b5f10Dan McDonald * there's data attached to this ack.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * For passive open, trace receipt of final ACK as
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * tcp:::accept-established.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson DTRACE_TCP5(accept__established, mlbk_t *, NULL,
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson ip_xmit_attr_t *, connp->conn_ixa, void_ip_t *,
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * 3-way handshake complete - this is a STREAMS based
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * socket, so pass up the T_CONN_IND.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mblk_t *mp = tcp->tcp_conn.tcp_eager_conn_ind;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We are here means eager is fine but it can
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * get a TH_RST at any point between now and till
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * accept completes and disappear. We need to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ensure that reference to eager is valid after
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we get out of eager's perimeter. So we do
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * an extra refhold.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The listener also exists because of the refhold
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * done in tcp_input_listener. Its possible that it
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * might have closed. We will check that once we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * get inside listeners context.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We optimize by not calling an SQUEUE_ENTER
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * on the listener since we know that the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * listener and eager squeues are the same.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We are able to make this check safely only
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * because neither the eager nor the listener
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * can change its squeue. Only an active connect
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * can change its squeue
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(listener->tcp_connp->conn_sqp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(listener->tcp_connp->conn_sqp,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * For passive open, trace receipt of final ACK as
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire * tcp:::accept-established.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP5(accept__established, mlbk_t *, NULL,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire ip_xmit_attr_t *, connp->conn_ixa, void_ip_t *,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_suna = tcp->tcp_iss + 1; /* One for the SYN */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* SYN was acked - making progress */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If SYN was retransmitted, need to reset all
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * retransmission info as this segment will be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * treated as a dup ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We set the send window to zero here.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This is needed if there is data to be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * processed already on the queue.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Later (at swnd_update label), the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * "new_swnd > tcp_swnd" condition is satisfied
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the XMIT_NEEDED flag is set in the current
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * (SYN_RCVD) state. This ensures tcp_wput_data() is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * called if there is already data on queue in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * this state.
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire /* Trace change from SYN_RCVD -> ESTABLISHED here */
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire DTRACE_TCP6(state__change, void, NULL, ip_xmit_attr_t *,
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire connp->conn_ixa, void, NULL, tcp_t *, tcp, void, NULL,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Fuse when both sides are in ESTABLISHED state */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* This code follows 4.4BSD-Lite2 mostly. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If TCP is ECN capable and the congestion experience bit is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * set, reduce tcp_cwnd and tcp_ssthresh. But this should only be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * done once per window (or more loosely, per RTT).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_cwr && SEQ_GT(seg_ack, tcp->tcp_cwr_snd_max))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon npkt = ((tcp->tcp_snxt - tcp->tcp_suna) >> 1) / mss;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the cwnd is 0, use the timer to clock out
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * new segments. This is required by the ECN spec.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This makes sure that when the ACK comes
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * back, we will increase tcp_cwnd by 1 MSS.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This marks the end of the current window of in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * flight data. That is why we don't use
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_suna + tcp_swnd. Only data in flight can
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * provide ECN info.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!ofo_seg && seg_len == 0 && new_swnd == tcp->tcp_swnd) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Fast retransmit. When we have seen exactly three
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * identical ACKs while we have unacked data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * outstanding we take it as a hint that our peer
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * dropped something.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If TCP is retransmitting, don't do fast retransmit.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Do Limited Transmit */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * What we need to do is temporarily
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * increase tcp_cwnd so that new
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * data can be sent if it is allowed
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * by the receive window (tcp_rwnd).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_wput_data() will take care of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the connection is SACK capable,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * only do limited xmit when there
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is SACK info.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note how tcp_cwnd is incremented.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The first dup ACK will increase
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * it by 1 MSS. The second dup ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will increase it by 2 MSS. This
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * means that only 1 new segment will
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be sent for each dup ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we have reduced tcp_ssthresh
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * because of ECN, do not reduce it again
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * unless it is already one window of data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * away. After one window of data, tcp_cwr
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should then be cleared. Note that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for non ECN capable connection, tcp_cwr
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should always be false.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Adjust cwnd since the duplicate
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ack indicates that a packet was
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * dropped (due to congestion.)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We do Hoe's algorithm. Refer to her
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * paper "Improving the Start-up Behavior
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of a Congestion Control Scheme for TCP,"
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * appeared in SIGCOMM'96.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Save highest seq no we have sent so far.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Be careful about the invisible FIN byte.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Calculate tcp_pipe, which is the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * estimated number of bytes in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_fack is the highest sack'ed seq num
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP has received.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_pipe is explained in the above quoted
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Fall and Floyd's paper. tcp_fack is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * explained in Mathis and Mahdavi's
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * "Forward Acknowledgment: Refining TCP
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Congestion Control" in SIGCOMM '96.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Always initialize tcp_pipe
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * even though we don't have
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * any SACK info. If later
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we get SACK info and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_pipe is not initialized,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * funny things will happen.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } /* tcp_snd_sack_ok */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Here we perform congestion
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * avoidance, but NOT slow start.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This is known as the Fast
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Recovery Algorithm.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We know that one more packet has
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * left the pipe thus we can update
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the window has opened, need to arrange
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to send additional data.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* tcp_suna != tcp_snxt */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Packet contains a window update */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Transmit starting with tcp_suna since
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the one byte probe is not ack'ed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If TCP has sent more than one identical
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * probe, tcp_rexmit will be set. That means
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_ss_rexmit() will send out the one
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * byte along with new data. Otherwise,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fake the retransmission.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Check for "acceptability" of ACK value per RFC 793, pages 72 - 73.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the ACK value acks something that we have not yet sent, it might
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * be an old duplicate segment. Send an ACK to re-synchronize the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * other side.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note: reset in response to unacceptable ACK in SYN_RECEIVE
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * state is handled above, so we can always just drop the segment and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send an ACK here.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * In the case where the peer shrinks the window, we see the new window
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * update, but all the data sent previously is queued up by the peer.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * To account for this, in tcp_process_shrunk_swnd(), the sequence
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * number, which was already sent, and within window, is recorded.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_snxt is then updated.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the window has previously shrunk, and an ACK for data not yet
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sent, according to tcp_snxt is recieved, it may still be valid. If
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the ACK is for data within the window at the time the window was
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * shrunk, then the ACK is acceptable. In this case tcp_snxt is set to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the sequence number ACK'ed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the ACK covers all the data sent at the time the window was
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * shrunk, we can now set tcp_is_wnd_shrnk to B_FALSE.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Should we send ACKs in response to ACK only segments?
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon data_acked_ahead_snxt = seg_ack - tcp->tcp_snxt;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* drop the received segment */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send back an ACK. If tcp_drop_ack_unsent_cnt is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * greater than 0, check if the number of such
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * bogus ACks is greater than that count. If yes,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * don't send back any ACK. This prevents TCP from
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * getting into an ACK storm if somehow an attacker
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * successfully spoofs an acceptable segment to our
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * peer. If this continues (count > 2 X threshold),
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we should abort this connection.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } else if (tcp->tcp_is_wnd_shrnk && SEQ_GEQ(seg_ack,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP gets a new ACK, update the notsack'ed list to delete those
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * blocks that are covered by this ACK.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_notsack_list != NULL) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_notsack_remove(&(tcp->tcp_notsack_list), seg_ack,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon &(tcp->tcp_num_notsack_blk), &(tcp->tcp_cnt_notsack_list));
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we got an ACK after fast retransmit, check to see
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * if it is a partial ACK. If it is not and the congestion
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window was inflated to account for the other side's
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * cached packets, retract it. If it is, do Hoe's algorithm.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_dupack_cnt >= tcps->tcps_dupack_fast_retransmit) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Restore the orig tcp_cwnd_ssthresh after
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fast retransmit phase.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Remove all notsack info to avoid confusion with
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the next fast retrasnmit/recovery phase.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Hoe's algorithm:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Retransmit the unack'ed segment and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * restart fast recovery. Note that we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * need to scale back tcp_cwnd to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * original value when we started fast
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * recovery. This is to prevent overly
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * aggressive behaviour in sending new
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP is retranmitting. If the ACK ack's all
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * outstanding data, update tcp_rexmit_max and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_rexmit_nxt. Otherwise, update tcp_rexmit_nxt
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to the correct value.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that SEQ_LEQ() is used. This is to avoid
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * unnecessary fast retransmit caused by dup ACKs
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * received when TCP does slow start retransmission
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * after a time out. During this phase, TCP may
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send out segments which are already received.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This causes dup ACKs to be sent back.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCPS_UPDATE_MIB(tcps, tcpInAckBytes, bytes_acked);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If tcp_xmit_head is NULL, then it must be the FIN being ack'ed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that it cannot be the SYN being ack'ed. The code flow
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * will not reach here.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update the congestion window.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If TCP is not ECN capable or TCP is ECN capable but the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * congestion experience bit is not set, increase the tcp_cwnd as
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This is to prevent an increase of less than 1 MSS of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_cwnd. With partial increase, tcp_wput_data()
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * may send out tinygrams in order to preserve mblk
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * boundaries.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * By initializing tcp_cwnd_cnt to new tcp_cwnd and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * decrementing it by 1 MSS for every ACKs, tcp_cwnd is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * increased by 1 MSS for every RTTs.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_cwnd = MIN(cwnd + add, tcp->tcp_cwnd_max);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* See if the latest urgent data has been acknowledged */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Can we update the RTT estimates? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Ignore zero timestamp echo-reply. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If needed, restart the timer. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update tcp_csuna in case the other side stops sending
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * us timestamps.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * An ACK sequence we haven't seen before, so get the RTT
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * and update the RTO. But first check if the timestamp is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * valid to use.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SEQ_GT(seg_ack, (uint32_t)(uintptr_t)(mp1->b_next)))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Remeber the last sequence to be ACKed */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Eat acknowledged bytes off the xmit queue. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(wptr - mp1->b_rptr) <= (uintptr_t)INT_MAX);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set a new timestamp if all the bytes timed by the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * old timestamp have been ack'ed.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This notification is required for some zero-copy
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * clients to maintain a copy semantic. After the data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is ack'ed, client is safe to modify or reuse the buffer.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (mp2->b_datap->db_struioflag & STRUIO_ZCNOTIFY))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Everything is ack'ed, clear the tail. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Cancel the timer unless we are still
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * waiting for an ACK for the FIN packet.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(mp1->b_wptr - mp1->b_rptr) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_xmit_tail_unsent = (int)(mp1->b_wptr -
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * More was acked but there is nothing more
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * outstanding. This means that the FIN was
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * just acked or that we're talking to a clown.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* FIN was acked - making progress */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We should never get here because
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we have already checked that the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * number of bytes ack'ed should be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * smaller than or equal to what we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * have sent so far (it is the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * acceptability check of the ACK).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We can only get here if the send
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * queue is corrupted.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Terminate the connection and
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * panic the system. It is better
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for us to panic instead of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * continuing to avoid other disaster.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "detected for connection %s.",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /*NOTREACHED*/
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The following check is different from most other implementations.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For bi-directional transfer, when segments are dropped, the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * "normal" check will not accept a window update in those
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * retransmitted segemnts. Failing to do that, TCP may send out
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * segments which are outside receiver's window. As TCP accepts
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the ack in those retransmitted segments, if the window update in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the same segment is not accepted, TCP will incorrectly calculates
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that it can send more segments. This can create a deadlock
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * with the receiver if its window becomes zero.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (tcp->tcp_swl1 == seg_seq && new_swnd > tcp->tcp_swnd)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The criteria for update is:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 1. the segment acknowledges some data. Or
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 2. the segment is new, i.e. it has a higher seq num. Or
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 3. the segment is not old and the advertised window is
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * larger than the previous advertised window.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_unsent && new_swnd > tcp->tcp_swnd)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We implement the non-standard BSD/SunOS
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * FIN_WAIT_2 flushing algorithm.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If there is no user attached to this
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP endpoint, then this TCP struct
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * could hang around forever in FIN_WAIT_2
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * state if the peer forgets to send us
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a FIN. To prevent this, we wait only
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * 2*MSL (a convenient time value) for
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the FIN to arrive. If it doesn't show up,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * we flush the TCP endpoint. This algorithm,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * though a violation of RFC-793, has worked
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for over 10 years in BSD systems.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note: SunOS 4.x waits 675 seconds before
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * flushing the FIN_WAIT_2 connection.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon break; /* Shutdown hook? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Make sure we ack the fin */
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Generate the ordrel_ind at the end unless the
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * conn is detached or it is a STREAMS based eager.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * In the eager case we defer the notification until
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * tcp_accept_finish has run.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson if (!TCP_IS_DETACHED(tcp) && (IPCL_IS_NONSTR(connp) ||
9cd928fe5e3ea4e05f64cfb380beb54b2623e7dcAlan Maguire /* Keepalive? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Keepalive? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* FALLTHRU */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * implies data piggybacked on FIN.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * break to handle data.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The header has been consumed, so we remove the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * zero-length mblk here.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We have more unacked data than we should - send
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * an ACK now.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_rack_cur_max = tcp->tcp_rack_abs_max;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* We don't have an ACK timer for detached TCP. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we get a segment that is less than an mss, and we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * already have unacknowledged data, and the amount
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * unacknowledged is not a multiple of mss, then we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * better generate an ACK now. Otherwise, this may be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the tail piece of a transaction, and we would rather
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * wait for the response.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT((uintptr_t)(tcp->tcp_rnxt - tcp->tcp_rack) <=
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Start delayed ack timer */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Update SACK list */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_num_sack_blk > 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_sack_remove(tcp->tcp_sack_list, tcp->tcp_rnxt,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Ready for a new signal. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: sending exdata_ind %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Check for ancillary data changes compared to last segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_all != 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp = tcp_input_add_ancillary(tcp, mp, &ipp, ira);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Non-STREAMS socket
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald if ((*sockupcalls->su_recv)(connp->conn_upper_handle,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We should never be in middle of a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * fallback, the squeue guarantees that.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon } else if (push) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* PUSH bit set and sockfs is not flow controlled */
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson } else if (tcp->tcp_listener != NULL || tcp->tcp_hard_binding) {
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Side queue inbound data until the accept happens.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * tcp_accept/tcp_rput drains this when the accept happens.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * M_DATA is queued on b_cont. Otherwise (T_OPTDATA_IND or
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * T_EXDATA_IND) it is queued on b_next.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * XXX Make urgent data use this. Requires:
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Removing tcp_listener check for TH_URG
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Making M_PCPROTO and MARK messages skip the eager case
dd49f125507979bb2ab505a8daf2a46d1be27051Anders Persson tcp_rcv_enqueue(tcp, mp, seg_len, ira->ira_cred);
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson /* Active STREAMS socket */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: sending MSGMARKNEXT %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_rcv_cnt + seg_len >= connp->conn_rcvbuf >> 3) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Enqueue the new segment first and then
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * call tcp_rcv_drain() to send all data
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * up. The other way to do this is to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send all queued data up and then call
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * putnext() to send the new segment up.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This way can remove the else part later
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We don't do this to avoid one more call to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * canputnext() as tcp_rcv_drain() needs to
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * call canputnext().
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Enqueue all packets when processing an mblk
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * from the co queue and also enqueue normal packets.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp_rcv_enqueue(tcp, mp, seg_len, ira->ira_cred);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Make sure the timer is running if we have data waiting
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * for a push bit. This provides resiliency against
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * implementations that do not correctly generate push bits.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (tcp->tcp_rcv_list != NULL && tcp->tcp_push_tid == 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The connection may be closed at this point, so don't
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * do anything for a detached tcp.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Is there anything left to do? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((flags & (TH_REXMIT_NEEDED|TH_XMIT_NEEDED|TH_ACK_NEEDED|
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TH_NEED_SACK_REXMIT|TH_LIMIT_XMIT|TH_ACK_TIMER_NEEDED|
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Any transmit work to do and a non-zero window? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((flags & (TH_REXMIT_NEEDED|TH_XMIT_NEEDED|TH_NEED_SACK_REXMIT|
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon uint32_t snd_size = tcp->tcp_snxt - tcp->tcp_suna;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp1 = tcp_xmit_mp(tcp, tcp->tcp_xmit_head, snd_size,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For TH_LIMIT_XMIT, tcp_wput_data() is called to send
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * out new segment. Note that tcp_rexmit should not be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * set, otherwise TH_LIMIT_XMIT should not be set.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Adjust tcp_cwnd back to normal value after sending
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * new data segments.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_cwnd -= mss << (tcp->tcp_dupack_cnt - 1);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This will restart the timer. Restarting the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * timer is used to avoid a timeout before the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * limited transmitted segment's ACK gets back.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Anything more to do? */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((flags & (TH_ACK_NEEDED|TH_ACK_TIMER_NEEDED|
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send up any queued data and then send the mark message
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(tcp->tcp_rcv_list == NULL || tcp->tcp_fused_sigurg);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "tcp_rput: sending zero-length %s %s",
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ((mp1->b_flag & MSGMARKNEXT) ? "MSGMARKNEXT" :
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon "MSGNOTMARKNEXT"),
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon#endif /* DEBUG */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Time to send an ack for some reason.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (void) TCP_TIMER_CANCEL(tcp, tcp->tcp_ack_tid);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Arrange for deferred ACK or push wait timeout.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Start timer if it is not already running.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_ack_tid = TCP_TIMER(tcp, tcp_ack_timer,
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Notify upper layer about an orderly release. If this is
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * a non-STREAMS socket, then just make an upcall. For STREAMS
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * we send up an ordrel_ind, unless this is an eager, in which
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * case the ordrel will be sent when tcp_accept_finish runs.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * Note that for non-STREAMS we make an upcall even if it is an
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson * eager, because we have an upper handle to send it to.
3e95bd4ab92abca814bd28e854607d1975c7dc88Anders Persson ASSERT(IPCL_IS_NONSTR(connp) || tcp->tcp_listener == NULL);
f2297e9296e52199b01691617a851111fa19a0b2Dan McDonald (*sockupcalls->su_opctl)(connp->conn_upper_handle,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Push any mblk(s) enqueued from co processing.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ASSERT(tcp->tcp_rcv_list == NULL || tcp->tcp_fused_sigurg);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Attach ancillary data to a received TCP segments for the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ancillary pieces requested by the application that are
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * different than they were in the previous data segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Save the "current" values once memory allocation is ok so that
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * when memory allocation fails we can just wait for the next data segment.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_input_add_ancillary(tcp_t *tcp, mblk_t *mp, ip_pkt_t *ipp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for pktinfo and the index has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ip_recvpktinfo &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon sizeof (struct in6_pktinfo);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for hoplimit and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ipv6_recvhoplimit &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon optlen += sizeof (struct T_opthdr) + sizeof (uint_t);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for tclass and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ipv6_recvtclass &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon optlen += sizeof (struct T_opthdr) + sizeof (uint_t);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If app asked for hopbyhop headers and it has changed ...
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * For security labels, note that (1) security labels can't change on
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * a connected socket at all, (2) we're connected to at most one peer,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * (3) if anything changes, then it must be some other extra option.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ipv6_recvhopopts &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_cmpbuf(tcp->tcp_hopopts, tcp->tcp_hopoptslen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon optlen += sizeof (struct T_opthdr) + ipp->ipp_hopoptslen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon &tcp->tcp_hopoptslen, (ipp->ipp_fields & IPPF_HOPOPTS),
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for dst headers before routing headers ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ipv6_recvrthdrdstopts &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_cmpbuf(tcp->tcp_rthdrdstopts, tcp->tcp_rthdrdstoptslen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ipp->ipp_rthdrdstopts, ipp->ipp_rthdrdstoptslen)) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!ip_allocbuf((void **)&tcp->tcp_rthdrdstopts,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ipp->ipp_rthdrdstopts, ipp->ipp_rthdrdstoptslen))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for routing headers and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_recv_ancillary.crb_ipv6_recvrthdr &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon optlen += sizeof (struct T_opthdr) + ipp->ipp_rthdrlen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon &tcp->tcp_rthdrlen, (ipp->ipp_fields & IPPF_RTHDR),
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for dest headers and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((connp->conn_recv_ancillary.crb_ipv6_recvdstopts ||
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon connp->conn_recv_ancillary.crb_old_ipv6_recvdstopts) &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_cmpbuf(tcp->tcp_dstopts, tcp->tcp_dstoptslen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon optlen += sizeof (struct T_opthdr) + ipp->ipp_dstoptslen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon &tcp->tcp_dstoptslen, (ipp->ipp_fields & IPPF_DSTOPTS),
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Nothing to add */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp1 = allocb(sizeof (struct T_optdata_ind) + optlen, BPRI_MED);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Defer sending ancillary data until the next TCP segment
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If app asked for pktinfo and the index has changed ...
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Note that the local address never changes for the connection.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as "last" value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for hoplimit and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as "last" value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If app asked for tclass and it has changed ... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as "last" value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon toh->len = sizeof (*toh) + ipp->ipp_hopoptslen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon bcopy((uchar_t *)ipp->ipp_hopopts, optptr, ipp->ipp_hopoptslen);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as last value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_savebuf((void **)&tcp->tcp_hopopts, &tcp->tcp_hopoptslen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon toh->len = sizeof (*toh) + ipp->ipp_rthdrdstoptslen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon bcopy(ipp->ipp_rthdrdstopts, optptr, ipp->ipp_rthdrdstoptslen);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as last value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ipp->ipp_rthdrdstopts, ipp->ipp_rthdrdstoptslen);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon bcopy(ipp->ipp_rthdr, optptr, ipp->ipp_rthdrlen);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as last value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_savebuf((void **)&tcp->tcp_rthdr, &tcp->tcp_rthdrlen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon toh->len = sizeof (*toh) + ipp->ipp_dstoptslen;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon bcopy(ipp->ipp_dstopts, optptr, ipp->ipp_dstoptslen);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Save as last value */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_savebuf((void **)&tcp->tcp_dstopts, &tcp->tcp_dstoptslen,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* The minimum of smoothed mean deviation in RTO calculation. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Set RTO for this connection. The formula is from Jacobson and Karels'
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * "Congestion Avoidance and Control" in SIGCOMM '88. The variable names
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * are the same as those in Appendix A.2 of that paper.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * m = new measurement
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sa = smoothed RTT average (8 * average estimates).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * sv = smoothed mean deviation (mdev) of RTT (4 * deviation estimates).
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* tcp_rtt_sa is not 0 means this is a new sample. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update average estimator:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * new rtt = 7/8 old rtt + 1/8 Error
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* m is now Error in estimate. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if ((sa += m) <= 0) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Don't allow the smoothed average to be negative.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We use 0 to denote reinitialization of the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update deviation estimator:
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * new mdev = 3/4 old mdev + 1/4 (abs(Error) - old mdev)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This follows BSD's implementation. So the reinitialized
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * RTO is 3 * m. We cannot go less than 2 because if the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * link is bandwidth dominated, doubling the window size
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * during slow start means doubling the RTT. We want to be
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * more conservative when we reinitialize our estimates. 3
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is just a convenient number.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * We do not know that if sa captures the delay ACK
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * effect as in a long train of segments, a receiver
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * does not delay its ACKs. So set the minimum of sv
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * to be TCP_SD_MIN, which is default to 400 ms, twice
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of BSD DATO. That means the minimum of mean
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * deviation is 100 ms.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * RTO = average estimates (sa / 8) + 4 * deviation estimates (sv)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Add tcp_rexmit_interval extra in case of extreme environment
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * where the algorithm fails to work. The default value of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_rexmit_interval_extra should be 0.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * As we use a finer grained clock than BSD and update
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * RTO for every ACKs, add in another .25 of RTT to the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * deviation of RTO to accomodate burstiness of 1/4 of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window size.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon rto = (sa >> 3) + sv + tcps->tcps_rexmit_interval_extra + (sa >> 5);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Now, we can reset tcp_timer_backoff to use the new RTO... */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * On a labeled system we have some protocols above TCP, such as RPC, which
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * appear to assume that every mblk in a chain has a db_credp.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_setcred_data(mblk_t *mp, ip_recv_attr_t *ira)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Learn the latest rwnd information that we sent to the other side. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon thwin = ((uint_t)ntohs(tcp->tcp_tcpha->tha_win))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* This is peer's calculated send window (our receive window). */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Increase the receive window to max. But we need to do receiver
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * SWS avoidance. This means that we need to check the increase of
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * of receive window is at least 1 MSS.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (connp->conn_rcvbuf - thwin >= tcp->tcp_mss) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If the window that the other side knows is less than max
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * deferred acks segments, send an update immediately.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (thwin < tcp->tcp_rack_cur_max * tcp->tcp_mss) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon TCPS_BUMP_MIB(tcp->tcp_tcps, tcpOutWinUpdate);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Handle a packet that has been reclassified by TCP.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * This function drops the ref on connp that the caller had.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_reinput(conn_t *connp, mblk_t *mp, ip_recv_attr_t *ira, ip_stack_t *ipst)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ipsec_stack_t *ipss = ipst->ips_netstack->netstack_ipsec;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon connp->conn_incoming_ifindex != ira->ira_ruifindex) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (CONN_INBOUND_POLICY_PRESENT_V6(connp, ipss) ||
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon mp = ipsec_check_inbound_policy(mp, connp, ipha, ip6h, ira);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon BUMP_MIB(&ipst->ips_ip_mib, ipIfStatsInDiscards);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Note that mp is NULL */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ip_drop_input("ipIfStatsInDiscards", mp, NULL);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * do not drain, certain use cases can blow
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Not TCP; must be SOCK_RAW, IPPROTO_TCP */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* ARGSUSED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_rsrv_input(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Not flow-controlled, open rwnd */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Send back a window update immediately if TCP is above
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ESTABLISHED state and the increase of the rcv window
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * that the other side knows is at least 1 MSS after flow
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * control is lifted.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The read side service routine is called mostly when we get back-enabled as a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * result of flow control relief. Since we don't actually queue anything in
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP, we have no data to send out of here. What we do is clear the receive
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * window, and send out a window update.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* No code does a putq on the read side */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If tcp->tcp_rsrv_mp == NULL, it means that tcp_rsrv() has already
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * been run. So just return.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon SQUEUE_ENTER_ONE(connp->conn_sqp, mp, tcp_rsrv_input, connp,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* At minimum we need 8 bytes in the TCP header for the lookup */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_icmp_input is called as conn_recvicmp to process ICMP error messages
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * passed up by IP. The message is always received on the correct tcp_t.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Assumes that IP has pulled up everything up to and including the ICMP header.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* ARGSUSED2 */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_icmp_input(void *arg1, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Assume IP provides aligned packets */
8b21eaf3a143f926835cd96a4d4afd0150be1f35Robert Mustacchi * It's possible we have a closed, but not yet destroyed, TCP
8b21eaf3a143f926835cd96a4d4afd0150be1f35Robert Mustacchi * connection. Several fields (e.g. conn_ixa->ixa_ire) are invalid
8b21eaf3a143f926835cd96a4d4afd0150be1f35Robert Mustacchi * in the closed state, so don't take any chances and drop the packet.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Verify IP version. Anything other than IPv4 or IPv6 packet is sent
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * upstream. ICMPv6 is handled in tcp_icmp_error_ipv6.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Skip past the outer IP and ICMP headers */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon icmph = (icmph_t *)&mp->b_rptr[iph_hdr_length];
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we don't have the correct outer IP header length
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * or if we don't have a complete inner IP header
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (ipha_t *)&icmph[1] + 1 > (ipha_t *)mp->b_wptr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Skip past the inner IP and find the ULP header */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcpha = (tcpha_t *)((char *)ipha + iph_hdr_length);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * If we don't have the correct inner IP header length or if the ULP
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * is not IPPROTO_TCP or if we don't have at least ICMP_MIN_TCP_HDR
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * bytes of TCP header, drop it.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon (uchar_t *)tcpha + ICMP_MIN_TCP_HDR > mp->b_wptr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update Path MTU, then try to send something out.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * ICMP can snipe away incipient
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP connections as long as
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * seq number is same as initial
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * send seq number.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Record the error in case we finally time out. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (icmph->icmph_code == ICMP_HOST_UNREACHABLE)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Ditch the half-open connection if we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * suspect a SYN attack is under way.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * use a global boolean to control
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * whether TCP should respond to ICMP_SOURCE_QUENCH.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * The default is false.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Reduce the sending rate as if we got a
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * retransmit timeout
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon npkt = ((tcp->tcp_snxt - tcp->tcp_suna) >> 1) /
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcp->tcp_cwnd_ssthresh = MAX(npkt, 2) * tcp->tcp_mss;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * tcp_icmp_error_ipv6 is called from tcp_icmp_input to process ICMPv6
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * error messages passed up by IP.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Assumes that IP has pulled up all the extension headers as well
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * as the ICMPv6 header.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_icmp_error_ipv6(tcp_t *tcp, mblk_t *mp, ip_recv_attr_t *ira)
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon uint16_t iph_hdr_length = ira->ira_ip_hdr_length;
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Verify that we have a complete IP header.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon icmp6 = (icmp6_t *)&mp->b_rptr[iph_hdr_length];
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Verify if we have a complete ICMP and inner IP header.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (!ip_hdr_length_nexthdr_v6(mp, ip6h, &iph_hdr_length, &nexthdrp))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon tcpha = (tcpha_t *)((char *)ip6h + iph_hdr_length);
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Validate inner header. If the ULP is not IPPROTO_TCP or if we don't
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * have at least ICMP_MIN_TCP_HDR bytes of TCP header drop the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon ((uchar_t *)tcpha + ICMP_MIN_TCP_HDR) > mp->b_wptr) {
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Update Path MTU, then try to send something out.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* Record the error in case we finally time out. */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Ditch the half-open connection if we
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * suspect a SYN attack is under way.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* If this corresponds to an ICMP_PROTOCOL_UNREACHABLE */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (icmp6->icmp6_code == ICMP6_PARAMPROB_NEXTHEADER &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * CALLED OUTSIDE OF SQUEUE! It can not follow any pointers that tcp might
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * change. But it can refer to fields like tcp_suna and tcp_snxt.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * Function tcp_verifyicmp is called as conn_verifyicmp to verify the ICMP
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * error messages received by IP. The message is always received on the correct
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon/* ARGSUSED */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poontcp_verifyicmp(conn_t *connp, void *arg2, icmph_t *icmph, icmp6_t *icmp6,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * TCP sequence number contained in payload of the ICMP error message
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * should be within the range SND.UNA <= SEG.SEQ < SND.NXT. Otherwise,
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * the message is either a stale ICMP error, or an attack from the
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon * network. Fail the verification.
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (SEQ_LT(seq, tcp->tcp_suna) || SEQ_GEQ(seq, tcp->tcp_snxt))
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon /* For "too big" we also check the ignore flag */
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon if (icmph->icmph_type == ICMP_DEST_UNREACHABLE &&
721fffe35d40e548a5a58dc53a2ec9c6762172d9Kacheong Poon icmph->icmph_code == ICMP_FRAGMENTATION_NEEDED &&