1721fffe3SKacheong Poon /*
2721fffe3SKacheong Poon * CDDL HEADER START
3721fffe3SKacheong Poon *
4721fffe3SKacheong Poon * The contents of this file are subject to the terms of the
5721fffe3SKacheong Poon * Common Development and Distribution License (the "License").
6721fffe3SKacheong Poon * You may not use this file except in compliance with the License.
7721fffe3SKacheong Poon *
8721fffe3SKacheong Poon * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9721fffe3SKacheong Poon * or http://www.opensolaris.org/os/licensing.
10721fffe3SKacheong Poon * See the License for the specific language governing permissions
11721fffe3SKacheong Poon * and limitations under the License.
12721fffe3SKacheong Poon *
13721fffe3SKacheong Poon * When distributing Covered Code, include this CDDL HEADER in each
14721fffe3SKacheong Poon * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15721fffe3SKacheong Poon * If applicable, add the following below this CDDL HEADER, with the
16721fffe3SKacheong Poon * fields enclosed by brackets "[]" replaced with your own identifying
17721fffe3SKacheong Poon * information: Portions Copyright [yyyy] [name of copyright owner]
18721fffe3SKacheong Poon *
19721fffe3SKacheong Poon * CDDL HEADER END
20721fffe3SKacheong Poon */
21721fffe3SKacheong Poon
22721fffe3SKacheong Poon /*
2366cd0f60SKacheong Poon * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
2445a4b79dSSebastien Roy * Copyright (c) 2014, 2017 by Delphix. All rights reserved.
252ad53042SDan McDonald * Copyright 2020 Joyent, Inc.
26*1edba515SAndy Fiddaman * Copyright 2024 Oxide Computer Company
27721fffe3SKacheong Poon */
28721fffe3SKacheong Poon
29721fffe3SKacheong Poon /* This file contains all TCP output processing functions. */
30721fffe3SKacheong Poon
31721fffe3SKacheong Poon #include <sys/types.h>
32721fffe3SKacheong Poon #include <sys/stream.h>
33721fffe3SKacheong Poon #include <sys/strsun.h>
34721fffe3SKacheong Poon #include <sys/strsubr.h>
35721fffe3SKacheong Poon #include <sys/stropts.h>
36721fffe3SKacheong Poon #include <sys/strlog.h>
37721fffe3SKacheong Poon #define _SUN_TPI_VERSION 2
38721fffe3SKacheong Poon #include <sys/tihdr.h>
39721fffe3SKacheong Poon #include <sys/suntpi.h>
40721fffe3SKacheong Poon #include <sys/xti_inet.h>
41721fffe3SKacheong Poon #include <sys/timod.h>
42721fffe3SKacheong Poon #include <sys/pattr.h>
43721fffe3SKacheong Poon #include <sys/squeue_impl.h>
44721fffe3SKacheong Poon #include <sys/squeue.h>
45721fffe3SKacheong Poon #include <sys/sockio.h>
46721fffe3SKacheong Poon #include <sys/tsol/tnet.h>
47721fffe3SKacheong Poon
48721fffe3SKacheong Poon #include <inet/common.h>
49721fffe3SKacheong Poon #include <inet/ip.h>
50721fffe3SKacheong Poon #include <inet/tcp.h>
51721fffe3SKacheong Poon #include <inet/tcp_impl.h>
52721fffe3SKacheong Poon #include <inet/snmpcom.h>
53721fffe3SKacheong Poon #include <inet/proto_set.h>
54721fffe3SKacheong Poon #include <inet/ipsec_impl.h>
55721fffe3SKacheong Poon #include <inet/ip_ndp.h>
56*1edba515SAndy Fiddaman #include <inet/tcp_sig.h>
57721fffe3SKacheong Poon
58721fffe3SKacheong Poon static mblk_t *tcp_get_seg_mp(tcp_t *, uint32_t, int32_t *);
59721fffe3SKacheong Poon static void tcp_wput_cmdblk(queue_t *, mblk_t *);
60721fffe3SKacheong Poon static void tcp_wput_flush(tcp_t *, mblk_t *);
61721fffe3SKacheong Poon static void tcp_wput_iocdata(tcp_t *tcp, mblk_t *mp);
62721fffe3SKacheong Poon static int tcp_xmit_end(tcp_t *);
63721fffe3SKacheong Poon static int tcp_send(tcp_t *, const int, const int, const int,
64c12492cfSSebastien Roy const int, int *, uint32_t *, int *, mblk_t **, mblk_t *);
65721fffe3SKacheong Poon static void tcp_xmit_early_reset(char *, mblk_t *, uint32_t, uint32_t,
66721fffe3SKacheong Poon int, ip_recv_attr_t *, ip_stack_t *, conn_t *);
67721fffe3SKacheong Poon static boolean_t tcp_send_rst_chk(tcp_stack_t *);
68721fffe3SKacheong Poon static void tcp_process_shrunk_swnd(tcp_t *, uint32_t);
69c12492cfSSebastien Roy static void tcp_fill_header(tcp_t *, uchar_t *, int);
70721fffe3SKacheong Poon
71721fffe3SKacheong Poon /*
72721fffe3SKacheong Poon * Functions called directly via squeue having a prototype of edesc_t.
73721fffe3SKacheong Poon */
74721fffe3SKacheong Poon static void tcp_wput_nondata(void *, mblk_t *, void *, ip_recv_attr_t *);
75721fffe3SKacheong Poon static void tcp_wput_ioctl(void *, mblk_t *, void *, ip_recv_attr_t *);
76721fffe3SKacheong Poon static void tcp_wput_proto(void *, mblk_t *, void *, ip_recv_attr_t *);
77721fffe3SKacheong Poon
78721fffe3SKacheong Poon /*
79721fffe3SKacheong Poon * This controls how tiny a write must be before we try to copy it
80721fffe3SKacheong Poon * into the mblk on the tail of the transmit queue. Not much
81721fffe3SKacheong Poon * speedup is observed for values larger than sixteen. Zero will
82721fffe3SKacheong Poon * disable the optimisation.
83721fffe3SKacheong Poon */
84721fffe3SKacheong Poon static int tcp_tx_pull_len = 16;
85721fffe3SKacheong Poon
8645a4b79dSSebastien Roy static void
cc_after_idle(tcp_t * tcp)8745a4b79dSSebastien Roy cc_after_idle(tcp_t *tcp)
8845a4b79dSSebastien Roy {
8945a4b79dSSebastien Roy uint32_t old_cwnd = tcp->tcp_cwnd;
9045a4b79dSSebastien Roy
9145a4b79dSSebastien Roy if (CC_ALGO(tcp)->after_idle != NULL)
9245a4b79dSSebastien Roy CC_ALGO(tcp)->after_idle(&tcp->tcp_ccv);
9345a4b79dSSebastien Roy
9445a4b79dSSebastien Roy DTRACE_PROBE3(cwnd__cc__after__idle, tcp_t *, tcp, uint32_t, old_cwnd,
9545a4b79dSSebastien Roy uint32_t, tcp->tcp_cwnd);
9645a4b79dSSebastien Roy }
9745a4b79dSSebastien Roy
988a06b3d6SToomas Soome int
tcp_wput(queue_t * q,mblk_t * mp)99721fffe3SKacheong Poon tcp_wput(queue_t *q, mblk_t *mp)
100721fffe3SKacheong Poon {
101721fffe3SKacheong Poon conn_t *connp = Q_TO_CONN(q);
102721fffe3SKacheong Poon tcp_t *tcp;
103721fffe3SKacheong Poon void (*output_proc)();
104721fffe3SKacheong Poon t_scalar_t type;
105721fffe3SKacheong Poon uchar_t *rptr;
106721fffe3SKacheong Poon struct iocblk *iocp;
107721fffe3SKacheong Poon size_t size;
108721fffe3SKacheong Poon
109721fffe3SKacheong Poon ASSERT(connp->conn_ref >= 2);
110721fffe3SKacheong Poon
111721fffe3SKacheong Poon switch (DB_TYPE(mp)) {
112721fffe3SKacheong Poon case M_DATA:
113721fffe3SKacheong Poon tcp = connp->conn_tcp;
114721fffe3SKacheong Poon ASSERT(tcp != NULL);
115721fffe3SKacheong Poon
116721fffe3SKacheong Poon size = msgdsize(mp);
117721fffe3SKacheong Poon
118721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
119721fffe3SKacheong Poon tcp->tcp_squeue_bytes += size;
120721fffe3SKacheong Poon if (TCP_UNSENT_BYTES(tcp) > connp->conn_sndbuf) {
121721fffe3SKacheong Poon tcp_setqfull(tcp);
122721fffe3SKacheong Poon }
123721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
124721fffe3SKacheong Poon
125721fffe3SKacheong Poon CONN_INC_REF(connp);
126721fffe3SKacheong Poon SQUEUE_ENTER_ONE(connp->conn_sqp, mp, tcp_output, connp,
127721fffe3SKacheong Poon NULL, tcp_squeue_flag, SQTAG_TCP_OUTPUT);
1288a06b3d6SToomas Soome return (0);
129721fffe3SKacheong Poon
130721fffe3SKacheong Poon case M_CMD:
131721fffe3SKacheong Poon tcp_wput_cmdblk(q, mp);
1328a06b3d6SToomas Soome return (0);
133721fffe3SKacheong Poon
134721fffe3SKacheong Poon case M_PROTO:
135721fffe3SKacheong Poon case M_PCPROTO:
136721fffe3SKacheong Poon /*
137721fffe3SKacheong Poon * if it is a snmp message, don't get behind the squeue
138721fffe3SKacheong Poon */
139721fffe3SKacheong Poon tcp = connp->conn_tcp;
140721fffe3SKacheong Poon rptr = mp->b_rptr;
141721fffe3SKacheong Poon if ((mp->b_wptr - rptr) >= sizeof (t_scalar_t)) {
142721fffe3SKacheong Poon type = ((union T_primitives *)rptr)->type;
143721fffe3SKacheong Poon } else {
144721fffe3SKacheong Poon if (connp->conn_debug) {
145721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1,
146721fffe3SKacheong Poon SL_ERROR|SL_TRACE,
147721fffe3SKacheong Poon "tcp_wput_proto, dropping one...");
148721fffe3SKacheong Poon }
149721fffe3SKacheong Poon freemsg(mp);
1508a06b3d6SToomas Soome return (0);
151721fffe3SKacheong Poon }
152721fffe3SKacheong Poon if (type == T_SVR4_OPTMGMT_REQ) {
153721fffe3SKacheong Poon /*
154721fffe3SKacheong Poon * All Solaris components should pass a db_credp
155721fffe3SKacheong Poon * for this TPI message, hence we ASSERT.
156721fffe3SKacheong Poon * But in case there is some other M_PROTO that looks
157721fffe3SKacheong Poon * like a TPI message sent by some other kernel
158721fffe3SKacheong Poon * component, we check and return an error.
159721fffe3SKacheong Poon */
160721fffe3SKacheong Poon cred_t *cr = msg_getcred(mp, NULL);
161721fffe3SKacheong Poon
162721fffe3SKacheong Poon ASSERT(cr != NULL);
163721fffe3SKacheong Poon if (cr == NULL) {
164721fffe3SKacheong Poon tcp_err_ack(tcp, mp, TSYSERR, EINVAL);
1658a06b3d6SToomas Soome return (0);
166721fffe3SKacheong Poon }
167721fffe3SKacheong Poon if (snmpcom_req(q, mp, tcp_snmp_set, ip_snmp_get,
168721fffe3SKacheong Poon cr)) {
169721fffe3SKacheong Poon /*
170721fffe3SKacheong Poon * This was a SNMP request
171721fffe3SKacheong Poon */
1728a06b3d6SToomas Soome return (0);
173721fffe3SKacheong Poon } else {
174721fffe3SKacheong Poon output_proc = tcp_wput_proto;
175721fffe3SKacheong Poon }
176721fffe3SKacheong Poon } else {
177721fffe3SKacheong Poon output_proc = tcp_wput_proto;
178721fffe3SKacheong Poon }
179721fffe3SKacheong Poon break;
180721fffe3SKacheong Poon case M_IOCTL:
181721fffe3SKacheong Poon /*
182721fffe3SKacheong Poon * Most ioctls can be processed right away without going via
183721fffe3SKacheong Poon * squeues - process them right here. Those that do require
184721fffe3SKacheong Poon * squeue (currently _SIOCSOCKFALLBACK)
185721fffe3SKacheong Poon * are processed by tcp_wput_ioctl().
186721fffe3SKacheong Poon */
187721fffe3SKacheong Poon iocp = (struct iocblk *)mp->b_rptr;
188721fffe3SKacheong Poon tcp = connp->conn_tcp;
189721fffe3SKacheong Poon
190721fffe3SKacheong Poon switch (iocp->ioc_cmd) {
191721fffe3SKacheong Poon case TCP_IOC_ABORT_CONN:
192721fffe3SKacheong Poon tcp_ioctl_abort_conn(q, mp);
1938a06b3d6SToomas Soome return (0);
194721fffe3SKacheong Poon case TI_GETPEERNAME:
195721fffe3SKacheong Poon case TI_GETMYNAME:
196721fffe3SKacheong Poon mi_copyin(q, mp, NULL,
197721fffe3SKacheong Poon SIZEOF_STRUCT(strbuf, iocp->ioc_flag));
1988a06b3d6SToomas Soome return (0);
199721fffe3SKacheong Poon
200721fffe3SKacheong Poon default:
201721fffe3SKacheong Poon output_proc = tcp_wput_ioctl;
202721fffe3SKacheong Poon break;
203721fffe3SKacheong Poon }
204721fffe3SKacheong Poon break;
205721fffe3SKacheong Poon default:
206721fffe3SKacheong Poon output_proc = tcp_wput_nondata;
207721fffe3SKacheong Poon break;
208721fffe3SKacheong Poon }
209721fffe3SKacheong Poon
210721fffe3SKacheong Poon CONN_INC_REF(connp);
211721fffe3SKacheong Poon SQUEUE_ENTER_ONE(connp->conn_sqp, mp, output_proc, connp,
212721fffe3SKacheong Poon NULL, tcp_squeue_flag, SQTAG_TCP_WPUT_OTHER);
2138a06b3d6SToomas Soome return (0);
214721fffe3SKacheong Poon }
215721fffe3SKacheong Poon
216721fffe3SKacheong Poon /*
217721fffe3SKacheong Poon * The TCP normal data output path.
218721fffe3SKacheong Poon * NOTE: the logic of the fast path is duplicated from this function.
219721fffe3SKacheong Poon */
220721fffe3SKacheong Poon void
tcp_wput_data(tcp_t * tcp,mblk_t * mp,boolean_t urgent)221721fffe3SKacheong Poon tcp_wput_data(tcp_t *tcp, mblk_t *mp, boolean_t urgent)
222721fffe3SKacheong Poon {
223721fffe3SKacheong Poon int len;
224721fffe3SKacheong Poon mblk_t *local_time;
225721fffe3SKacheong Poon mblk_t *mp1;
226721fffe3SKacheong Poon uint32_t snxt;
227721fffe3SKacheong Poon int tail_unsent;
228721fffe3SKacheong Poon int tcpstate;
229721fffe3SKacheong Poon int usable = 0;
230721fffe3SKacheong Poon mblk_t *xmit_tail;
231721fffe3SKacheong Poon int32_t mss;
232721fffe3SKacheong Poon int32_t num_sack_blk = 0;
233721fffe3SKacheong Poon int32_t total_hdr_len;
234721fffe3SKacheong Poon int32_t tcp_hdr_len;
235721fffe3SKacheong Poon int rc;
236721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
237721fffe3SKacheong Poon clock_t now = LBOLT_FASTPATH;
238721fffe3SKacheong Poon
239721fffe3SKacheong Poon tcpstate = tcp->tcp_state;
240721fffe3SKacheong Poon if (mp == NULL) {
241721fffe3SKacheong Poon /*
242721fffe3SKacheong Poon * tcp_wput_data() with NULL mp should only be called when
243721fffe3SKacheong Poon * there is unsent data.
244721fffe3SKacheong Poon */
245721fffe3SKacheong Poon ASSERT(tcp->tcp_unsent > 0);
246721fffe3SKacheong Poon /* Really tacky... but we need this for detached closes. */
247721fffe3SKacheong Poon len = tcp->tcp_unsent;
248721fffe3SKacheong Poon goto data_null;
249721fffe3SKacheong Poon }
250721fffe3SKacheong Poon
251721fffe3SKacheong Poon ASSERT(mp->b_datap->db_type == M_DATA);
252721fffe3SKacheong Poon /*
253721fffe3SKacheong Poon * Don't allow data after T_ORDREL_REQ or T_DISCON_REQ,
254721fffe3SKacheong Poon * or before a connection attempt has begun.
255721fffe3SKacheong Poon */
256721fffe3SKacheong Poon if (tcpstate < TCPS_SYN_SENT || tcpstate > TCPS_CLOSE_WAIT ||
257721fffe3SKacheong Poon (tcp->tcp_valid_bits & TCP_FSS_VALID) != 0) {
258721fffe3SKacheong Poon if ((tcp->tcp_valid_bits & TCP_FSS_VALID) != 0) {
259721fffe3SKacheong Poon #ifdef DEBUG
260721fffe3SKacheong Poon cmn_err(CE_WARN,
261721fffe3SKacheong Poon "tcp_wput_data: data after ordrel, %s",
262721fffe3SKacheong Poon tcp_display(tcp, NULL,
263721fffe3SKacheong Poon DISP_ADDR_AND_PORT));
264721fffe3SKacheong Poon #else
265721fffe3SKacheong Poon if (connp->conn_debug) {
266721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1,
267721fffe3SKacheong Poon SL_TRACE|SL_ERROR,
268721fffe3SKacheong Poon "tcp_wput_data: data after ordrel, %s\n",
269721fffe3SKacheong Poon tcp_display(tcp, NULL,
270721fffe3SKacheong Poon DISP_ADDR_AND_PORT));
271721fffe3SKacheong Poon }
272721fffe3SKacheong Poon #endif /* DEBUG */
273721fffe3SKacheong Poon }
274721fffe3SKacheong Poon if (tcp->tcp_snd_zcopy_aware &&
275721fffe3SKacheong Poon (mp->b_datap->db_struioflag & STRUIO_ZCNOTIFY))
276721fffe3SKacheong Poon tcp_zcopy_notify(tcp);
277721fffe3SKacheong Poon freemsg(mp);
278721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
279721fffe3SKacheong Poon if (tcp->tcp_flow_stopped &&
280721fffe3SKacheong Poon TCP_UNSENT_BYTES(tcp) <= connp->conn_sndlowat) {
281721fffe3SKacheong Poon tcp_clrqfull(tcp);
282721fffe3SKacheong Poon }
283721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
284721fffe3SKacheong Poon return;
285721fffe3SKacheong Poon }
286721fffe3SKacheong Poon
287721fffe3SKacheong Poon /* Strip empties */
288721fffe3SKacheong Poon for (;;) {
289721fffe3SKacheong Poon ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <=
290721fffe3SKacheong Poon (uintptr_t)INT_MAX);
291721fffe3SKacheong Poon len = (int)(mp->b_wptr - mp->b_rptr);
292721fffe3SKacheong Poon if (len > 0)
293721fffe3SKacheong Poon break;
294721fffe3SKacheong Poon mp1 = mp;
295721fffe3SKacheong Poon mp = mp->b_cont;
296721fffe3SKacheong Poon freeb(mp1);
297721fffe3SKacheong Poon if (mp == NULL) {
298721fffe3SKacheong Poon return;
299721fffe3SKacheong Poon }
300721fffe3SKacheong Poon }
301721fffe3SKacheong Poon
302721fffe3SKacheong Poon /* If we are the first on the list ... */
303721fffe3SKacheong Poon if (tcp->tcp_xmit_head == NULL) {
304721fffe3SKacheong Poon tcp->tcp_xmit_head = mp;
305721fffe3SKacheong Poon tcp->tcp_xmit_tail = mp;
306721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = len;
307721fffe3SKacheong Poon } else {
308721fffe3SKacheong Poon /* If tiny tx and room in txq tail, pullup to save mblks. */
309721fffe3SKacheong Poon struct datab *dp;
310721fffe3SKacheong Poon
311721fffe3SKacheong Poon mp1 = tcp->tcp_xmit_last;
312721fffe3SKacheong Poon if (len < tcp_tx_pull_len &&
313721fffe3SKacheong Poon (dp = mp1->b_datap)->db_ref == 1 &&
314721fffe3SKacheong Poon dp->db_lim - mp1->b_wptr >= len) {
315721fffe3SKacheong Poon ASSERT(len > 0);
316721fffe3SKacheong Poon ASSERT(!mp1->b_cont);
317721fffe3SKacheong Poon if (len == 1) {
318721fffe3SKacheong Poon *mp1->b_wptr++ = *mp->b_rptr;
319721fffe3SKacheong Poon } else {
320721fffe3SKacheong Poon bcopy(mp->b_rptr, mp1->b_wptr, len);
321721fffe3SKacheong Poon mp1->b_wptr += len;
322721fffe3SKacheong Poon }
323721fffe3SKacheong Poon if (mp1 == tcp->tcp_xmit_tail)
324721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent += len;
325721fffe3SKacheong Poon mp1->b_cont = mp->b_cont;
326721fffe3SKacheong Poon if (tcp->tcp_snd_zcopy_aware &&
327721fffe3SKacheong Poon (mp->b_datap->db_struioflag & STRUIO_ZCNOTIFY))
328721fffe3SKacheong Poon mp1->b_datap->db_struioflag |= STRUIO_ZCNOTIFY;
329721fffe3SKacheong Poon freeb(mp);
330721fffe3SKacheong Poon mp = mp1;
331721fffe3SKacheong Poon } else {
332721fffe3SKacheong Poon tcp->tcp_xmit_last->b_cont = mp;
333721fffe3SKacheong Poon }
334721fffe3SKacheong Poon len += tcp->tcp_unsent;
335721fffe3SKacheong Poon }
336721fffe3SKacheong Poon
337721fffe3SKacheong Poon /* Tack on however many more positive length mblks we have */
338721fffe3SKacheong Poon if ((mp1 = mp->b_cont) != NULL) {
339721fffe3SKacheong Poon do {
340721fffe3SKacheong Poon int tlen;
341721fffe3SKacheong Poon ASSERT((uintptr_t)(mp1->b_wptr - mp1->b_rptr) <=
342721fffe3SKacheong Poon (uintptr_t)INT_MAX);
343721fffe3SKacheong Poon tlen = (int)(mp1->b_wptr - mp1->b_rptr);
344721fffe3SKacheong Poon if (tlen <= 0) {
345721fffe3SKacheong Poon mp->b_cont = mp1->b_cont;
346721fffe3SKacheong Poon freeb(mp1);
347721fffe3SKacheong Poon } else {
348721fffe3SKacheong Poon len += tlen;
349721fffe3SKacheong Poon mp = mp1;
350721fffe3SKacheong Poon }
351721fffe3SKacheong Poon } while ((mp1 = mp->b_cont) != NULL);
352721fffe3SKacheong Poon }
353721fffe3SKacheong Poon tcp->tcp_xmit_last = mp;
354721fffe3SKacheong Poon tcp->tcp_unsent = len;
355721fffe3SKacheong Poon
356721fffe3SKacheong Poon if (urgent)
357721fffe3SKacheong Poon usable = 1;
358721fffe3SKacheong Poon
359721fffe3SKacheong Poon data_null:
360721fffe3SKacheong Poon snxt = tcp->tcp_snxt;
361721fffe3SKacheong Poon xmit_tail = tcp->tcp_xmit_tail;
362721fffe3SKacheong Poon tail_unsent = tcp->tcp_xmit_tail_unsent;
363721fffe3SKacheong Poon
364721fffe3SKacheong Poon /*
365721fffe3SKacheong Poon * Note that tcp_mss has been adjusted to take into account the
366721fffe3SKacheong Poon * timestamp option if applicable. Because SACK options do not
367721fffe3SKacheong Poon * appear in every TCP segments and they are of variable lengths,
368721fffe3SKacheong Poon * they cannot be included in tcp_mss. Thus we need to calculate
369721fffe3SKacheong Poon * the actual segment length when we need to send a segment which
370721fffe3SKacheong Poon * includes SACK options.
371721fffe3SKacheong Poon */
372721fffe3SKacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_num_sack_blk > 0) {
373721fffe3SKacheong Poon int32_t opt_len;
374721fffe3SKacheong Poon
375721fffe3SKacheong Poon num_sack_blk = MIN(tcp->tcp_max_sack_blk,
376721fffe3SKacheong Poon tcp->tcp_num_sack_blk);
377721fffe3SKacheong Poon opt_len = num_sack_blk * sizeof (sack_blk_t) + TCPOPT_NOP_LEN *
378721fffe3SKacheong Poon 2 + TCPOPT_HEADER_LEN;
379721fffe3SKacheong Poon mss = tcp->tcp_mss - opt_len;
380721fffe3SKacheong Poon total_hdr_len = connp->conn_ht_iphc_len + opt_len;
381721fffe3SKacheong Poon tcp_hdr_len = connp->conn_ht_ulp_len + opt_len;
382721fffe3SKacheong Poon } else {
383721fffe3SKacheong Poon mss = tcp->tcp_mss;
384721fffe3SKacheong Poon total_hdr_len = connp->conn_ht_iphc_len;
385721fffe3SKacheong Poon tcp_hdr_len = connp->conn_ht_ulp_len;
386721fffe3SKacheong Poon }
387721fffe3SKacheong Poon
388721fffe3SKacheong Poon if ((tcp->tcp_suna == snxt) && !tcp->tcp_localnet &&
389721fffe3SKacheong Poon (TICK_TO_MSEC(now - tcp->tcp_last_recv_time) >= tcp->tcp_rto)) {
39045a4b79dSSebastien Roy cc_after_idle(tcp);
391721fffe3SKacheong Poon }
392721fffe3SKacheong Poon if (tcpstate == TCPS_SYN_RCVD) {
393721fffe3SKacheong Poon /*
394721fffe3SKacheong Poon * The three-way connection establishment handshake is not
395721fffe3SKacheong Poon * complete yet. We want to queue the data for transmission
396721fffe3SKacheong Poon * after entering ESTABLISHED state (RFC793). A jump to
397721fffe3SKacheong Poon * "done" label effectively leaves data on the queue.
398721fffe3SKacheong Poon */
399721fffe3SKacheong Poon goto done;
400721fffe3SKacheong Poon } else {
401721fffe3SKacheong Poon int usable_r;
402721fffe3SKacheong Poon
403721fffe3SKacheong Poon /*
404721fffe3SKacheong Poon * In the special case when cwnd is zero, which can only
405721fffe3SKacheong Poon * happen if the connection is ECN capable, return now.
406721fffe3SKacheong Poon * New segments is sent using tcp_timer(). The timer
407721fffe3SKacheong Poon * is set in tcp_input_data().
408721fffe3SKacheong Poon */
409721fffe3SKacheong Poon if (tcp->tcp_cwnd == 0) {
410721fffe3SKacheong Poon /*
411721fffe3SKacheong Poon * Note that tcp_cwnd is 0 before 3-way handshake is
412721fffe3SKacheong Poon * finished.
413721fffe3SKacheong Poon */
414721fffe3SKacheong Poon ASSERT(tcp->tcp_ecn_ok ||
415721fffe3SKacheong Poon tcp->tcp_state < TCPS_ESTABLISHED);
416721fffe3SKacheong Poon return;
417721fffe3SKacheong Poon }
418721fffe3SKacheong Poon
419721fffe3SKacheong Poon /* NOTE: trouble if xmitting while SYN not acked? */
420721fffe3SKacheong Poon usable_r = snxt - tcp->tcp_suna;
421721fffe3SKacheong Poon usable_r = tcp->tcp_swnd - usable_r;
422721fffe3SKacheong Poon
423721fffe3SKacheong Poon /*
424721fffe3SKacheong Poon * Check if the receiver has shrunk the window. If
425721fffe3SKacheong Poon * tcp_wput_data() with NULL mp is called, tcp_fin_sent
426721fffe3SKacheong Poon * cannot be set as there is unsent data, so FIN cannot
427721fffe3SKacheong Poon * be sent out. Otherwise, we need to take into account
428721fffe3SKacheong Poon * of FIN as it consumes an "invisible" sequence number.
429721fffe3SKacheong Poon */
430721fffe3SKacheong Poon ASSERT(tcp->tcp_fin_sent == 0);
431721fffe3SKacheong Poon if (usable_r < 0) {
432721fffe3SKacheong Poon /*
433721fffe3SKacheong Poon * The receiver has shrunk the window and we have sent
434721fffe3SKacheong Poon * -usable_r date beyond the window, re-adjust.
435721fffe3SKacheong Poon *
436721fffe3SKacheong Poon * If TCP window scaling is enabled, there can be
437721fffe3SKacheong Poon * round down error as the advertised receive window
438721fffe3SKacheong Poon * is actually right shifted n bits. This means that
439721fffe3SKacheong Poon * the lower n bits info is wiped out. It will look
440721fffe3SKacheong Poon * like the window is shrunk. Do a check here to
441721fffe3SKacheong Poon * see if the shrunk amount is actually within the
442721fffe3SKacheong Poon * error in window calculation. If it is, just
443721fffe3SKacheong Poon * return. Note that this check is inside the
444721fffe3SKacheong Poon * shrunk window check. This makes sure that even
445721fffe3SKacheong Poon * though tcp_process_shrunk_swnd() is not called,
446721fffe3SKacheong Poon * we will stop further processing.
447721fffe3SKacheong Poon */
448721fffe3SKacheong Poon if ((-usable_r >> tcp->tcp_snd_ws) > 0) {
449721fffe3SKacheong Poon tcp_process_shrunk_swnd(tcp, -usable_r);
450721fffe3SKacheong Poon }
451721fffe3SKacheong Poon return;
452721fffe3SKacheong Poon }
453721fffe3SKacheong Poon
454721fffe3SKacheong Poon /* usable = MIN(swnd, cwnd) - unacked_bytes */
455721fffe3SKacheong Poon if (tcp->tcp_swnd > tcp->tcp_cwnd)
456721fffe3SKacheong Poon usable_r -= tcp->tcp_swnd - tcp->tcp_cwnd;
457721fffe3SKacheong Poon
458721fffe3SKacheong Poon /* usable = MIN(usable, unsent) */
459721fffe3SKacheong Poon if (usable_r > len)
460721fffe3SKacheong Poon usable_r = len;
461721fffe3SKacheong Poon
462721fffe3SKacheong Poon /* usable = MAX(usable, {1 for urgent, 0 for data}) */
463721fffe3SKacheong Poon if (usable_r > 0) {
464721fffe3SKacheong Poon usable = usable_r;
465721fffe3SKacheong Poon } else {
466721fffe3SKacheong Poon /* Bypass all other unnecessary processing. */
467721fffe3SKacheong Poon goto done;
468721fffe3SKacheong Poon }
469721fffe3SKacheong Poon }
470721fffe3SKacheong Poon
471c12492cfSSebastien Roy local_time = (mblk_t *)(intptr_t)gethrtime();
472721fffe3SKacheong Poon
473721fffe3SKacheong Poon /*
474721fffe3SKacheong Poon * "Our" Nagle Algorithm. This is not the same as in the old
475721fffe3SKacheong Poon * BSD. This is more in line with the true intent of Nagle.
476721fffe3SKacheong Poon *
477721fffe3SKacheong Poon * The conditions are:
478721fffe3SKacheong Poon * 1. The amount of unsent data (or amount of data which can be
479721fffe3SKacheong Poon * sent, whichever is smaller) is less than Nagle limit.
480721fffe3SKacheong Poon * 2. The last sent size is also less than Nagle limit.
481721fffe3SKacheong Poon * 3. There is unack'ed data.
482721fffe3SKacheong Poon * 4. Urgent pointer is not set. Send urgent data ignoring the
483721fffe3SKacheong Poon * Nagle algorithm. This reduces the probability that urgent
484721fffe3SKacheong Poon * bytes get "merged" together.
485721fffe3SKacheong Poon * 5. The app has not closed the connection. This eliminates the
486721fffe3SKacheong Poon * wait time of the receiving side waiting for the last piece of
487721fffe3SKacheong Poon * (small) data.
488721fffe3SKacheong Poon *
489721fffe3SKacheong Poon * If all are satisified, exit without sending anything. Note
490721fffe3SKacheong Poon * that Nagle limit can be smaller than 1 MSS. Nagle limit is
491721fffe3SKacheong Poon * the smaller of 1 MSS and global tcp_naglim_def (default to be
492721fffe3SKacheong Poon * 4095).
493721fffe3SKacheong Poon */
494721fffe3SKacheong Poon if (usable < (int)tcp->tcp_naglim &&
495721fffe3SKacheong Poon tcp->tcp_naglim > tcp->tcp_last_sent_len &&
496721fffe3SKacheong Poon snxt != tcp->tcp_suna &&
497721fffe3SKacheong Poon !(tcp->tcp_valid_bits & TCP_URG_VALID) &&
498721fffe3SKacheong Poon !(tcp->tcp_valid_bits & TCP_FSS_VALID)) {
499721fffe3SKacheong Poon goto done;
500721fffe3SKacheong Poon }
501721fffe3SKacheong Poon
502721fffe3SKacheong Poon /*
503721fffe3SKacheong Poon * If tcp_zero_win_probe is not set and the tcp->tcp_cork option
504721fffe3SKacheong Poon * is set, then we have to force TCP not to send partial segment
505721fffe3SKacheong Poon * (smaller than MSS bytes). We are calculating the usable now
506721fffe3SKacheong Poon * based on full mss and will save the rest of remaining data for
507721fffe3SKacheong Poon * later. When tcp_zero_win_probe is set, TCP needs to send out
508721fffe3SKacheong Poon * something to do zero window probe.
509721fffe3SKacheong Poon */
510721fffe3SKacheong Poon if (tcp->tcp_cork && !tcp->tcp_zero_win_probe) {
511721fffe3SKacheong Poon if (usable < mss)
512721fffe3SKacheong Poon goto done;
513721fffe3SKacheong Poon usable = (usable / mss) * mss;
514721fffe3SKacheong Poon }
515721fffe3SKacheong Poon
516721fffe3SKacheong Poon /* Update the latest receive window size in TCP header. */
517721fffe3SKacheong Poon tcp->tcp_tcpha->tha_win = htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
518721fffe3SKacheong Poon
519721fffe3SKacheong Poon /* Send the packet. */
520721fffe3SKacheong Poon rc = tcp_send(tcp, mss, total_hdr_len, tcp_hdr_len,
521721fffe3SKacheong Poon num_sack_blk, &usable, &snxt, &tail_unsent, &xmit_tail,
522721fffe3SKacheong Poon local_time);
523721fffe3SKacheong Poon
524721fffe3SKacheong Poon /* Pretend that all we were trying to send really got sent */
525721fffe3SKacheong Poon if (rc < 0 && tail_unsent < 0) {
526721fffe3SKacheong Poon do {
527721fffe3SKacheong Poon xmit_tail = xmit_tail->b_cont;
528721fffe3SKacheong Poon xmit_tail->b_prev = local_time;
529721fffe3SKacheong Poon ASSERT((uintptr_t)(xmit_tail->b_wptr -
530721fffe3SKacheong Poon xmit_tail->b_rptr) <= (uintptr_t)INT_MAX);
531721fffe3SKacheong Poon tail_unsent += (int)(xmit_tail->b_wptr -
532721fffe3SKacheong Poon xmit_tail->b_rptr);
533721fffe3SKacheong Poon } while (tail_unsent < 0);
534721fffe3SKacheong Poon }
535721fffe3SKacheong Poon done:;
536721fffe3SKacheong Poon tcp->tcp_xmit_tail = xmit_tail;
537721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = tail_unsent;
538721fffe3SKacheong Poon len = tcp->tcp_snxt - snxt;
539721fffe3SKacheong Poon if (len) {
540721fffe3SKacheong Poon /*
541721fffe3SKacheong Poon * If new data was sent, need to update the notsack
542721fffe3SKacheong Poon * list, which is, afterall, data blocks that have
543721fffe3SKacheong Poon * not been sack'ed by the receiver. New data is
544721fffe3SKacheong Poon * not sack'ed.
545721fffe3SKacheong Poon */
546721fffe3SKacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_notsack_list != NULL) {
547721fffe3SKacheong Poon /* len is a negative value. */
548721fffe3SKacheong Poon tcp->tcp_pipe -= len;
549721fffe3SKacheong Poon tcp_notsack_update(&(tcp->tcp_notsack_list),
550721fffe3SKacheong Poon tcp->tcp_snxt, snxt,
551721fffe3SKacheong Poon &(tcp->tcp_num_notsack_blk),
552721fffe3SKacheong Poon &(tcp->tcp_cnt_notsack_list));
553721fffe3SKacheong Poon }
554721fffe3SKacheong Poon tcp->tcp_snxt = snxt + tcp->tcp_fin_sent;
555721fffe3SKacheong Poon tcp->tcp_rack = tcp->tcp_rnxt;
556721fffe3SKacheong Poon tcp->tcp_rack_cnt = 0;
557721fffe3SKacheong Poon if ((snxt + len) == tcp->tcp_suna) {
558721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
559721fffe3SKacheong Poon }
560721fffe3SKacheong Poon } else if (snxt == tcp->tcp_suna && tcp->tcp_swnd == 0) {
561721fffe3SKacheong Poon /*
562721fffe3SKacheong Poon * Didn't send anything. Make sure the timer is running
563721fffe3SKacheong Poon * so that we will probe a zero window.
564721fffe3SKacheong Poon */
565721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
566721fffe3SKacheong Poon }
567721fffe3SKacheong Poon /* Note that len is the amount we just sent but with a negative sign */
568721fffe3SKacheong Poon tcp->tcp_unsent += len;
569721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
570721fffe3SKacheong Poon if (tcp->tcp_flow_stopped) {
571721fffe3SKacheong Poon if (TCP_UNSENT_BYTES(tcp) <= connp->conn_sndlowat) {
572721fffe3SKacheong Poon tcp_clrqfull(tcp);
573721fffe3SKacheong Poon }
574721fffe3SKacheong Poon } else if (TCP_UNSENT_BYTES(tcp) >= connp->conn_sndbuf) {
575721fffe3SKacheong Poon if (!(tcp->tcp_detached))
576721fffe3SKacheong Poon tcp_setqfull(tcp);
577721fffe3SKacheong Poon }
578721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
579721fffe3SKacheong Poon }
580721fffe3SKacheong Poon
581721fffe3SKacheong Poon /*
582721fffe3SKacheong Poon * Initial STREAMS write side put() procedure for sockets. It tries to
583721fffe3SKacheong Poon * handle the T_CAPABILITY_REQ which sockfs sends down while setting
584721fffe3SKacheong Poon * up the socket without using the squeue. Non T_CAPABILITY_REQ messages
585721fffe3SKacheong Poon * are handled by tcp_wput() as usual.
586721fffe3SKacheong Poon *
587721fffe3SKacheong Poon * All further messages will also be handled by tcp_wput() because we cannot
588721fffe3SKacheong Poon * be sure that the above short cut is safe later.
589721fffe3SKacheong Poon */
5908a06b3d6SToomas Soome int
tcp_wput_sock(queue_t * wq,mblk_t * mp)591721fffe3SKacheong Poon tcp_wput_sock(queue_t *wq, mblk_t *mp)
592721fffe3SKacheong Poon {
593721fffe3SKacheong Poon conn_t *connp = Q_TO_CONN(wq);
594721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
595721fffe3SKacheong Poon struct T_capability_req *car = (struct T_capability_req *)mp->b_rptr;
596721fffe3SKacheong Poon
597721fffe3SKacheong Poon ASSERT(wq->q_qinfo == &tcp_sock_winit);
598721fffe3SKacheong Poon wq->q_qinfo = &tcp_winit;
599721fffe3SKacheong Poon
600721fffe3SKacheong Poon ASSERT(IPCL_IS_TCP(connp));
601721fffe3SKacheong Poon ASSERT(TCP_IS_SOCKET(tcp));
602721fffe3SKacheong Poon
603721fffe3SKacheong Poon if (DB_TYPE(mp) == M_PCPROTO &&
604721fffe3SKacheong Poon MBLKL(mp) == sizeof (struct T_capability_req) &&
605721fffe3SKacheong Poon car->PRIM_type == T_CAPABILITY_REQ) {
606721fffe3SKacheong Poon tcp_capability_req(tcp, mp);
6078a06b3d6SToomas Soome return (0);
608721fffe3SKacheong Poon }
609721fffe3SKacheong Poon
610721fffe3SKacheong Poon tcp_wput(wq, mp);
6118a06b3d6SToomas Soome return (0);
612721fffe3SKacheong Poon }
613721fffe3SKacheong Poon
614721fffe3SKacheong Poon /* ARGSUSED */
6158a06b3d6SToomas Soome int
tcp_wput_fallback(queue_t * wq,mblk_t * mp)616721fffe3SKacheong Poon tcp_wput_fallback(queue_t *wq, mblk_t *mp)
617721fffe3SKacheong Poon {
618721fffe3SKacheong Poon #ifdef DEBUG
619721fffe3SKacheong Poon cmn_err(CE_CONT, "tcp_wput_fallback: Message during fallback \n");
620721fffe3SKacheong Poon #endif
621721fffe3SKacheong Poon freemsg(mp);
6228a06b3d6SToomas Soome return (0);
623721fffe3SKacheong Poon }
624721fffe3SKacheong Poon
625721fffe3SKacheong Poon /*
626721fffe3SKacheong Poon * Call by tcp_wput() to handle misc non M_DATA messages.
627721fffe3SKacheong Poon */
628721fffe3SKacheong Poon /* ARGSUSED */
629721fffe3SKacheong Poon static void
tcp_wput_nondata(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)630721fffe3SKacheong Poon tcp_wput_nondata(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
631721fffe3SKacheong Poon {
632721fffe3SKacheong Poon conn_t *connp = (conn_t *)arg;
633721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
634721fffe3SKacheong Poon
635721fffe3SKacheong Poon ASSERT(DB_TYPE(mp) != M_IOCTL);
636721fffe3SKacheong Poon /*
637721fffe3SKacheong Poon * TCP is D_MP and qprocsoff() is done towards the end of the tcp_close.
638721fffe3SKacheong Poon * Once the close starts, streamhead and sockfs will not let any data
639721fffe3SKacheong Poon * packets come down (close ensures that there are no threads using the
640721fffe3SKacheong Poon * queue and no new threads will come down) but since qprocsoff()
641721fffe3SKacheong Poon * hasn't happened yet, a M_FLUSH or some non data message might
642721fffe3SKacheong Poon * get reflected back (in response to our own FLUSHRW) and get
643721fffe3SKacheong Poon * processed after tcp_close() is done. The conn would still be valid
644721fffe3SKacheong Poon * because a ref would have added but we need to check the state
645721fffe3SKacheong Poon * before actually processing the packet.
646721fffe3SKacheong Poon */
647721fffe3SKacheong Poon if (TCP_IS_DETACHED(tcp) || (tcp->tcp_state == TCPS_CLOSED)) {
648721fffe3SKacheong Poon freemsg(mp);
649721fffe3SKacheong Poon return;
650721fffe3SKacheong Poon }
651721fffe3SKacheong Poon
652721fffe3SKacheong Poon switch (DB_TYPE(mp)) {
653721fffe3SKacheong Poon case M_IOCDATA:
654721fffe3SKacheong Poon tcp_wput_iocdata(tcp, mp);
655721fffe3SKacheong Poon break;
656721fffe3SKacheong Poon case M_FLUSH:
657721fffe3SKacheong Poon tcp_wput_flush(tcp, mp);
658721fffe3SKacheong Poon break;
659721fffe3SKacheong Poon default:
660721fffe3SKacheong Poon ip_wput_nondata(connp->conn_wq, mp);
661721fffe3SKacheong Poon break;
662721fffe3SKacheong Poon }
663721fffe3SKacheong Poon }
664721fffe3SKacheong Poon
665721fffe3SKacheong Poon /* tcp_wput_flush is called by tcp_wput_nondata to handle M_FLUSH messages. */
666721fffe3SKacheong Poon static void
tcp_wput_flush(tcp_t * tcp,mblk_t * mp)667721fffe3SKacheong Poon tcp_wput_flush(tcp_t *tcp, mblk_t *mp)
668721fffe3SKacheong Poon {
669721fffe3SKacheong Poon uchar_t fval = *mp->b_rptr;
670721fffe3SKacheong Poon mblk_t *tail;
671721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
672721fffe3SKacheong Poon queue_t *q = connp->conn_wq;
673721fffe3SKacheong Poon
674721fffe3SKacheong Poon /* TODO: How should flush interact with urgent data? */
675721fffe3SKacheong Poon if ((fval & FLUSHW) && tcp->tcp_xmit_head != NULL &&
676721fffe3SKacheong Poon !(tcp->tcp_valid_bits & TCP_URG_VALID)) {
677721fffe3SKacheong Poon /*
678721fffe3SKacheong Poon * Flush only data that has not yet been put on the wire. If
679721fffe3SKacheong Poon * we flush data that we have already transmitted, life, as we
680721fffe3SKacheong Poon * know it, may come to an end.
681721fffe3SKacheong Poon */
682721fffe3SKacheong Poon tail = tcp->tcp_xmit_tail;
683721fffe3SKacheong Poon tail->b_wptr -= tcp->tcp_xmit_tail_unsent;
684721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = 0;
685721fffe3SKacheong Poon tcp->tcp_unsent = 0;
686721fffe3SKacheong Poon if (tail->b_wptr != tail->b_rptr)
687721fffe3SKacheong Poon tail = tail->b_cont;
688721fffe3SKacheong Poon if (tail) {
689721fffe3SKacheong Poon mblk_t **excess = &tcp->tcp_xmit_head;
690721fffe3SKacheong Poon for (;;) {
691721fffe3SKacheong Poon mblk_t *mp1 = *excess;
692721fffe3SKacheong Poon if (mp1 == tail)
693721fffe3SKacheong Poon break;
694721fffe3SKacheong Poon tcp->tcp_xmit_tail = mp1;
695721fffe3SKacheong Poon tcp->tcp_xmit_last = mp1;
696721fffe3SKacheong Poon excess = &mp1->b_cont;
697721fffe3SKacheong Poon }
698721fffe3SKacheong Poon *excess = NULL;
699721fffe3SKacheong Poon tcp_close_mpp(&tail);
700721fffe3SKacheong Poon if (tcp->tcp_snd_zcopy_aware)
701721fffe3SKacheong Poon tcp_zcopy_notify(tcp);
702721fffe3SKacheong Poon }
703721fffe3SKacheong Poon /*
704721fffe3SKacheong Poon * We have no unsent data, so unsent must be less than
705721fffe3SKacheong Poon * conn_sndlowat, so re-enable flow.
706721fffe3SKacheong Poon */
707721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
708721fffe3SKacheong Poon if (tcp->tcp_flow_stopped) {
709721fffe3SKacheong Poon tcp_clrqfull(tcp);
710721fffe3SKacheong Poon }
711721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
712721fffe3SKacheong Poon }
713721fffe3SKacheong Poon /*
714721fffe3SKacheong Poon * TODO: you can't just flush these, you have to increase rwnd for one
715721fffe3SKacheong Poon * thing. For another, how should urgent data interact?
716721fffe3SKacheong Poon */
717721fffe3SKacheong Poon if (fval & FLUSHR) {
718721fffe3SKacheong Poon *mp->b_rptr = fval & ~FLUSHW;
719721fffe3SKacheong Poon /* XXX */
720721fffe3SKacheong Poon qreply(q, mp);
721721fffe3SKacheong Poon return;
722721fffe3SKacheong Poon }
723721fffe3SKacheong Poon freemsg(mp);
724721fffe3SKacheong Poon }
725721fffe3SKacheong Poon
726721fffe3SKacheong Poon /*
727721fffe3SKacheong Poon * tcp_wput_iocdata is called by tcp_wput_nondata to handle all M_IOCDATA
728721fffe3SKacheong Poon * messages.
729721fffe3SKacheong Poon */
730721fffe3SKacheong Poon static void
tcp_wput_iocdata(tcp_t * tcp,mblk_t * mp)731721fffe3SKacheong Poon tcp_wput_iocdata(tcp_t *tcp, mblk_t *mp)
732721fffe3SKacheong Poon {
733721fffe3SKacheong Poon mblk_t *mp1;
734721fffe3SKacheong Poon struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
735721fffe3SKacheong Poon STRUCT_HANDLE(strbuf, sb);
736721fffe3SKacheong Poon uint_t addrlen;
737721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
7388a06b3d6SToomas Soome queue_t *q = connp->conn_wq;
739721fffe3SKacheong Poon
740721fffe3SKacheong Poon /* Make sure it is one of ours. */
741721fffe3SKacheong Poon switch (iocp->ioc_cmd) {
742721fffe3SKacheong Poon case TI_GETMYNAME:
743721fffe3SKacheong Poon case TI_GETPEERNAME:
744721fffe3SKacheong Poon break;
745721fffe3SKacheong Poon default:
746721fffe3SKacheong Poon /*
747721fffe3SKacheong Poon * If the conn is closing, then error the ioctl here. Otherwise
748721fffe3SKacheong Poon * use the CONN_IOCTLREF_* macros to hold off tcp_close until
749721fffe3SKacheong Poon * we're done here.
750721fffe3SKacheong Poon */
751721fffe3SKacheong Poon mutex_enter(&connp->conn_lock);
752721fffe3SKacheong Poon if (connp->conn_state_flags & CONN_CLOSING) {
753721fffe3SKacheong Poon mutex_exit(&connp->conn_lock);
754721fffe3SKacheong Poon iocp->ioc_error = EINVAL;
755721fffe3SKacheong Poon mp->b_datap->db_type = M_IOCNAK;
756721fffe3SKacheong Poon iocp->ioc_count = 0;
757721fffe3SKacheong Poon qreply(q, mp);
758721fffe3SKacheong Poon return;
759721fffe3SKacheong Poon }
760721fffe3SKacheong Poon
761721fffe3SKacheong Poon CONN_INC_IOCTLREF_LOCKED(connp);
762721fffe3SKacheong Poon ip_wput_nondata(q, mp);
763721fffe3SKacheong Poon CONN_DEC_IOCTLREF(connp);
764721fffe3SKacheong Poon return;
765721fffe3SKacheong Poon }
766721fffe3SKacheong Poon switch (mi_copy_state(q, mp, &mp1)) {
767721fffe3SKacheong Poon case -1:
768721fffe3SKacheong Poon return;
769721fffe3SKacheong Poon case MI_COPY_CASE(MI_COPY_IN, 1):
770721fffe3SKacheong Poon break;
771721fffe3SKacheong Poon case MI_COPY_CASE(MI_COPY_OUT, 1):
772721fffe3SKacheong Poon /* Copy out the strbuf. */
773721fffe3SKacheong Poon mi_copyout(q, mp);
774721fffe3SKacheong Poon return;
775721fffe3SKacheong Poon case MI_COPY_CASE(MI_COPY_OUT, 2):
776721fffe3SKacheong Poon /* All done. */
777721fffe3SKacheong Poon mi_copy_done(q, mp, 0);
778721fffe3SKacheong Poon return;
779721fffe3SKacheong Poon default:
780721fffe3SKacheong Poon mi_copy_done(q, mp, EPROTO);
781721fffe3SKacheong Poon return;
782721fffe3SKacheong Poon }
783721fffe3SKacheong Poon /* Check alignment of the strbuf */
784721fffe3SKacheong Poon if (!OK_32PTR(mp1->b_rptr)) {
785721fffe3SKacheong Poon mi_copy_done(q, mp, EINVAL);
786721fffe3SKacheong Poon return;
787721fffe3SKacheong Poon }
788721fffe3SKacheong Poon
789721fffe3SKacheong Poon STRUCT_SET_HANDLE(sb, iocp->ioc_flag, (void *)mp1->b_rptr);
790721fffe3SKacheong Poon
791721fffe3SKacheong Poon if (connp->conn_family == AF_INET)
792721fffe3SKacheong Poon addrlen = sizeof (sin_t);
793721fffe3SKacheong Poon else
794721fffe3SKacheong Poon addrlen = sizeof (sin6_t);
795721fffe3SKacheong Poon
796721fffe3SKacheong Poon if (STRUCT_FGET(sb, maxlen) < addrlen) {
797721fffe3SKacheong Poon mi_copy_done(q, mp, EINVAL);
798721fffe3SKacheong Poon return;
799721fffe3SKacheong Poon }
800721fffe3SKacheong Poon
801721fffe3SKacheong Poon switch (iocp->ioc_cmd) {
802721fffe3SKacheong Poon case TI_GETMYNAME:
803721fffe3SKacheong Poon break;
804721fffe3SKacheong Poon case TI_GETPEERNAME:
805721fffe3SKacheong Poon if (tcp->tcp_state < TCPS_SYN_RCVD) {
806721fffe3SKacheong Poon mi_copy_done(q, mp, ENOTCONN);
807721fffe3SKacheong Poon return;
808721fffe3SKacheong Poon }
809721fffe3SKacheong Poon break;
810721fffe3SKacheong Poon }
811721fffe3SKacheong Poon mp1 = mi_copyout_alloc(q, mp, STRUCT_FGETP(sb, buf), addrlen, B_TRUE);
812721fffe3SKacheong Poon if (!mp1)
813721fffe3SKacheong Poon return;
814721fffe3SKacheong Poon
815721fffe3SKacheong Poon STRUCT_FSET(sb, len, addrlen);
816721fffe3SKacheong Poon switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) {
817721fffe3SKacheong Poon case TI_GETMYNAME:
818721fffe3SKacheong Poon (void) conn_getsockname(connp, (struct sockaddr *)mp1->b_wptr,
819721fffe3SKacheong Poon &addrlen);
820721fffe3SKacheong Poon break;
821721fffe3SKacheong Poon case TI_GETPEERNAME:
822721fffe3SKacheong Poon (void) conn_getpeername(connp, (struct sockaddr *)mp1->b_wptr,
823721fffe3SKacheong Poon &addrlen);
824721fffe3SKacheong Poon break;
825721fffe3SKacheong Poon }
826721fffe3SKacheong Poon mp1->b_wptr += addrlen;
827721fffe3SKacheong Poon /* Copy out the address */
828721fffe3SKacheong Poon mi_copyout(q, mp);
829721fffe3SKacheong Poon }
830721fffe3SKacheong Poon
831721fffe3SKacheong Poon /*
832721fffe3SKacheong Poon * tcp_wput_ioctl is called by tcp_wput_nondata() to handle all M_IOCTL
833721fffe3SKacheong Poon * messages.
834721fffe3SKacheong Poon */
835721fffe3SKacheong Poon /* ARGSUSED */
836721fffe3SKacheong Poon static void
tcp_wput_ioctl(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)837721fffe3SKacheong Poon tcp_wput_ioctl(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
838721fffe3SKacheong Poon {
8398a06b3d6SToomas Soome conn_t *connp = (conn_t *)arg;
840721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
841721fffe3SKacheong Poon queue_t *q = connp->conn_wq;
842721fffe3SKacheong Poon struct iocblk *iocp;
843721fffe3SKacheong Poon
844721fffe3SKacheong Poon ASSERT(DB_TYPE(mp) == M_IOCTL);
845721fffe3SKacheong Poon /*
846721fffe3SKacheong Poon * Try and ASSERT the minimum possible references on the
847721fffe3SKacheong Poon * conn early enough. Since we are executing on write side,
848721fffe3SKacheong Poon * the connection is obviously not detached and that means
849721fffe3SKacheong Poon * there is a ref each for TCP and IP. Since we are behind
850721fffe3SKacheong Poon * the squeue, the minimum references needed are 3. If the
851721fffe3SKacheong Poon * conn is in classifier hash list, there should be an
852721fffe3SKacheong Poon * extra ref for that (we check both the possibilities).
853721fffe3SKacheong Poon */
854721fffe3SKacheong Poon ASSERT((connp->conn_fanout != NULL && connp->conn_ref >= 4) ||
855721fffe3SKacheong Poon (connp->conn_fanout == NULL && connp->conn_ref >= 3));
856721fffe3SKacheong Poon
857721fffe3SKacheong Poon iocp = (struct iocblk *)mp->b_rptr;
858721fffe3SKacheong Poon switch (iocp->ioc_cmd) {
859721fffe3SKacheong Poon case _SIOCSOCKFALLBACK:
860721fffe3SKacheong Poon /*
861721fffe3SKacheong Poon * Either sockmod is about to be popped and the socket
862721fffe3SKacheong Poon * would now be treated as a plain stream, or a module
863721fffe3SKacheong Poon * is about to be pushed so we could no longer use read-
864721fffe3SKacheong Poon * side synchronous streams for fused loopback tcp.
865721fffe3SKacheong Poon * Drain any queued data and disable direct sockfs
866721fffe3SKacheong Poon * interface from now on.
867721fffe3SKacheong Poon */
868721fffe3SKacheong Poon if (!tcp->tcp_issocket) {
869721fffe3SKacheong Poon DB_TYPE(mp) = M_IOCNAK;
870721fffe3SKacheong Poon iocp->ioc_error = EINVAL;
871721fffe3SKacheong Poon } else {
872721fffe3SKacheong Poon tcp_use_pure_tpi(tcp);
873721fffe3SKacheong Poon DB_TYPE(mp) = M_IOCACK;
874721fffe3SKacheong Poon iocp->ioc_error = 0;
875721fffe3SKacheong Poon }
876721fffe3SKacheong Poon iocp->ioc_count = 0;
877721fffe3SKacheong Poon iocp->ioc_rval = 0;
878721fffe3SKacheong Poon qreply(q, mp);
879721fffe3SKacheong Poon return;
880721fffe3SKacheong Poon }
881721fffe3SKacheong Poon
882721fffe3SKacheong Poon /*
883721fffe3SKacheong Poon * If the conn is closing, then error the ioctl here. Otherwise bump the
884721fffe3SKacheong Poon * conn_ioctlref to hold off tcp_close until we're done here.
885721fffe3SKacheong Poon */
886721fffe3SKacheong Poon mutex_enter(&(connp)->conn_lock);
887721fffe3SKacheong Poon if ((connp)->conn_state_flags & CONN_CLOSING) {
888721fffe3SKacheong Poon mutex_exit(&(connp)->conn_lock);
889721fffe3SKacheong Poon iocp->ioc_error = EINVAL;
890721fffe3SKacheong Poon mp->b_datap->db_type = M_IOCNAK;
891721fffe3SKacheong Poon iocp->ioc_count = 0;
892721fffe3SKacheong Poon qreply(q, mp);
893721fffe3SKacheong Poon return;
894721fffe3SKacheong Poon }
895721fffe3SKacheong Poon
896721fffe3SKacheong Poon CONN_INC_IOCTLREF_LOCKED(connp);
897721fffe3SKacheong Poon ip_wput_nondata(q, mp);
898721fffe3SKacheong Poon CONN_DEC_IOCTLREF(connp);
899721fffe3SKacheong Poon }
900721fffe3SKacheong Poon
901721fffe3SKacheong Poon /*
902721fffe3SKacheong Poon * This routine is called by tcp_wput() to handle all TPI requests.
903721fffe3SKacheong Poon */
904721fffe3SKacheong Poon /* ARGSUSED */
905721fffe3SKacheong Poon static void
tcp_wput_proto(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)906721fffe3SKacheong Poon tcp_wput_proto(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
907721fffe3SKacheong Poon {
908721fffe3SKacheong Poon conn_t *connp = (conn_t *)arg;
909721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
910721fffe3SKacheong Poon union T_primitives *tprim = (union T_primitives *)mp->b_rptr;
911721fffe3SKacheong Poon uchar_t *rptr;
912721fffe3SKacheong Poon t_scalar_t type;
913721fffe3SKacheong Poon cred_t *cr;
914721fffe3SKacheong Poon
915721fffe3SKacheong Poon /*
916721fffe3SKacheong Poon * Try and ASSERT the minimum possible references on the
917721fffe3SKacheong Poon * conn early enough. Since we are executing on write side,
918721fffe3SKacheong Poon * the connection is obviously not detached and that means
919721fffe3SKacheong Poon * there is a ref each for TCP and IP. Since we are behind
920721fffe3SKacheong Poon * the squeue, the minimum references needed are 3. If the
921721fffe3SKacheong Poon * conn is in classifier hash list, there should be an
922721fffe3SKacheong Poon * extra ref for that (we check both the possibilities).
923721fffe3SKacheong Poon */
924721fffe3SKacheong Poon ASSERT((connp->conn_fanout != NULL && connp->conn_ref >= 4) ||
925721fffe3SKacheong Poon (connp->conn_fanout == NULL && connp->conn_ref >= 3));
926721fffe3SKacheong Poon
927721fffe3SKacheong Poon rptr = mp->b_rptr;
928721fffe3SKacheong Poon ASSERT((uintptr_t)(mp->b_wptr - rptr) <= (uintptr_t)INT_MAX);
929721fffe3SKacheong Poon if ((mp->b_wptr - rptr) >= sizeof (t_scalar_t)) {
930721fffe3SKacheong Poon type = ((union T_primitives *)rptr)->type;
931721fffe3SKacheong Poon if (type == T_EXDATA_REQ) {
932721fffe3SKacheong Poon tcp_output_urgent(connp, mp, arg2, NULL);
933721fffe3SKacheong Poon } else if (type != T_DATA_REQ) {
934721fffe3SKacheong Poon goto non_urgent_data;
935721fffe3SKacheong Poon } else {
936721fffe3SKacheong Poon /* TODO: options, flags, ... from user */
937721fffe3SKacheong Poon /* Set length to zero for reclamation below */
938721fffe3SKacheong Poon tcp_wput_data(tcp, mp->b_cont, B_TRUE);
939721fffe3SKacheong Poon freeb(mp);
940721fffe3SKacheong Poon }
941721fffe3SKacheong Poon return;
942721fffe3SKacheong Poon } else {
943721fffe3SKacheong Poon if (connp->conn_debug) {
944721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1, SL_ERROR|SL_TRACE,
945721fffe3SKacheong Poon "tcp_wput_proto, dropping one...");
946721fffe3SKacheong Poon }
947721fffe3SKacheong Poon freemsg(mp);
948721fffe3SKacheong Poon return;
949721fffe3SKacheong Poon }
950721fffe3SKacheong Poon
951721fffe3SKacheong Poon non_urgent_data:
952721fffe3SKacheong Poon
953721fffe3SKacheong Poon switch ((int)tprim->type) {
954721fffe3SKacheong Poon case O_T_BIND_REQ: /* bind request */
955721fffe3SKacheong Poon case T_BIND_REQ: /* new semantics bind request */
956721fffe3SKacheong Poon tcp_tpi_bind(tcp, mp);
957721fffe3SKacheong Poon break;
958721fffe3SKacheong Poon case T_UNBIND_REQ: /* unbind request */
959721fffe3SKacheong Poon tcp_tpi_unbind(tcp, mp);
960721fffe3SKacheong Poon break;
961721fffe3SKacheong Poon case O_T_CONN_RES: /* old connection response XXX */
962721fffe3SKacheong Poon case T_CONN_RES: /* connection response */
963721fffe3SKacheong Poon tcp_tli_accept(tcp, mp);
964721fffe3SKacheong Poon break;
965721fffe3SKacheong Poon case T_CONN_REQ: /* connection request */
966721fffe3SKacheong Poon tcp_tpi_connect(tcp, mp);
967721fffe3SKacheong Poon break;
968721fffe3SKacheong Poon case T_DISCON_REQ: /* disconnect request */
969721fffe3SKacheong Poon tcp_disconnect(tcp, mp);
970721fffe3SKacheong Poon break;
971721fffe3SKacheong Poon case T_CAPABILITY_REQ:
972721fffe3SKacheong Poon tcp_capability_req(tcp, mp); /* capability request */
973721fffe3SKacheong Poon break;
974721fffe3SKacheong Poon case T_INFO_REQ: /* information request */
975721fffe3SKacheong Poon tcp_info_req(tcp, mp);
976721fffe3SKacheong Poon break;
977721fffe3SKacheong Poon case T_SVR4_OPTMGMT_REQ: /* manage options req */
978721fffe3SKacheong Poon case T_OPTMGMT_REQ:
979721fffe3SKacheong Poon /*
980721fffe3SKacheong Poon * Note: no support for snmpcom_req() through new
981721fffe3SKacheong Poon * T_OPTMGMT_REQ. See comments in ip.c
982721fffe3SKacheong Poon */
983721fffe3SKacheong Poon
984721fffe3SKacheong Poon /*
985721fffe3SKacheong Poon * All Solaris components should pass a db_credp
986721fffe3SKacheong Poon * for this TPI message, hence we ASSERT.
987721fffe3SKacheong Poon * But in case there is some other M_PROTO that looks
988721fffe3SKacheong Poon * like a TPI message sent by some other kernel
989721fffe3SKacheong Poon * component, we check and return an error.
990721fffe3SKacheong Poon */
991721fffe3SKacheong Poon cr = msg_getcred(mp, NULL);
992721fffe3SKacheong Poon ASSERT(cr != NULL);
993721fffe3SKacheong Poon if (cr == NULL) {
994721fffe3SKacheong Poon tcp_err_ack(tcp, mp, TSYSERR, EINVAL);
995721fffe3SKacheong Poon return;
996721fffe3SKacheong Poon }
997721fffe3SKacheong Poon /*
998721fffe3SKacheong Poon * If EINPROGRESS is returned, the request has been queued
999721fffe3SKacheong Poon * for subsequent processing by ip_restart_optmgmt(), which
1000721fffe3SKacheong Poon * will do the CONN_DEC_REF().
1001721fffe3SKacheong Poon */
1002721fffe3SKacheong Poon if ((int)tprim->type == T_SVR4_OPTMGMT_REQ) {
1003721fffe3SKacheong Poon svr4_optcom_req(connp->conn_wq, mp, cr, &tcp_opt_obj);
1004721fffe3SKacheong Poon } else {
1005721fffe3SKacheong Poon tpi_optcom_req(connp->conn_wq, mp, cr, &tcp_opt_obj);
1006721fffe3SKacheong Poon }
1007721fffe3SKacheong Poon break;
1008721fffe3SKacheong Poon
1009721fffe3SKacheong Poon case T_UNITDATA_REQ: /* unitdata request */
1010721fffe3SKacheong Poon tcp_err_ack(tcp, mp, TNOTSUPPORT, 0);
1011721fffe3SKacheong Poon break;
1012721fffe3SKacheong Poon case T_ORDREL_REQ: /* orderly release req */
1013721fffe3SKacheong Poon freemsg(mp);
1014721fffe3SKacheong Poon
1015721fffe3SKacheong Poon if (tcp->tcp_fused)
1016721fffe3SKacheong Poon tcp_unfuse(tcp);
1017721fffe3SKacheong Poon
1018721fffe3SKacheong Poon if (tcp_xmit_end(tcp) != 0) {
1019721fffe3SKacheong Poon /*
1020721fffe3SKacheong Poon * We were crossing FINs and got a reset from
1021721fffe3SKacheong Poon * the other side. Just ignore it.
1022721fffe3SKacheong Poon */
1023721fffe3SKacheong Poon if (connp->conn_debug) {
1024721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1,
1025721fffe3SKacheong Poon SL_ERROR|SL_TRACE,
1026721fffe3SKacheong Poon "tcp_wput_proto, T_ORDREL_REQ out of "
1027721fffe3SKacheong Poon "state %s",
1028721fffe3SKacheong Poon tcp_display(tcp, NULL,
1029721fffe3SKacheong Poon DISP_ADDR_AND_PORT));
1030721fffe3SKacheong Poon }
1031721fffe3SKacheong Poon }
1032721fffe3SKacheong Poon break;
1033721fffe3SKacheong Poon case T_ADDR_REQ:
1034721fffe3SKacheong Poon tcp_addr_req(tcp, mp);
1035721fffe3SKacheong Poon break;
1036721fffe3SKacheong Poon default:
1037721fffe3SKacheong Poon if (connp->conn_debug) {
1038721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1, SL_ERROR|SL_TRACE,
1039721fffe3SKacheong Poon "tcp_wput_proto, bogus TPI msg, type %d",
1040721fffe3SKacheong Poon tprim->type);
1041721fffe3SKacheong Poon }
1042721fffe3SKacheong Poon /*
1043721fffe3SKacheong Poon * We used to M_ERROR. Sending TNOTSUPPORT gives the user
1044721fffe3SKacheong Poon * to recover.
1045721fffe3SKacheong Poon */
1046721fffe3SKacheong Poon tcp_err_ack(tcp, mp, TNOTSUPPORT, 0);
1047721fffe3SKacheong Poon break;
1048721fffe3SKacheong Poon }
1049721fffe3SKacheong Poon }
1050721fffe3SKacheong Poon
1051721fffe3SKacheong Poon /*
1052721fffe3SKacheong Poon * Handle special out-of-band ioctl requests (see PSARC/2008/265).
1053721fffe3SKacheong Poon */
1054721fffe3SKacheong Poon static void
tcp_wput_cmdblk(queue_t * q,mblk_t * mp)1055721fffe3SKacheong Poon tcp_wput_cmdblk(queue_t *q, mblk_t *mp)
1056721fffe3SKacheong Poon {
1057721fffe3SKacheong Poon void *data;
1058721fffe3SKacheong Poon mblk_t *datamp = mp->b_cont;
1059721fffe3SKacheong Poon conn_t *connp = Q_TO_CONN(q);
1060721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
1061721fffe3SKacheong Poon cmdblk_t *cmdp = (cmdblk_t *)mp->b_rptr;
1062721fffe3SKacheong Poon
1063721fffe3SKacheong Poon if (datamp == NULL || MBLKL(datamp) < cmdp->cb_len) {
1064721fffe3SKacheong Poon cmdp->cb_error = EPROTO;
1065721fffe3SKacheong Poon qreply(q, mp);
1066721fffe3SKacheong Poon return;
1067721fffe3SKacheong Poon }
1068721fffe3SKacheong Poon
1069721fffe3SKacheong Poon data = datamp->b_rptr;
1070721fffe3SKacheong Poon
1071721fffe3SKacheong Poon switch (cmdp->cb_cmd) {
1072721fffe3SKacheong Poon case TI_GETPEERNAME:
1073721fffe3SKacheong Poon if (tcp->tcp_state < TCPS_SYN_RCVD)
1074721fffe3SKacheong Poon cmdp->cb_error = ENOTCONN;
1075721fffe3SKacheong Poon else
1076721fffe3SKacheong Poon cmdp->cb_error = conn_getpeername(connp, data,
1077721fffe3SKacheong Poon &cmdp->cb_len);
1078721fffe3SKacheong Poon break;
1079721fffe3SKacheong Poon case TI_GETMYNAME:
1080721fffe3SKacheong Poon cmdp->cb_error = conn_getsockname(connp, data, &cmdp->cb_len);
1081721fffe3SKacheong Poon break;
1082721fffe3SKacheong Poon default:
1083721fffe3SKacheong Poon cmdp->cb_error = EINVAL;
1084721fffe3SKacheong Poon break;
1085721fffe3SKacheong Poon }
1086721fffe3SKacheong Poon
1087721fffe3SKacheong Poon qreply(q, mp);
1088721fffe3SKacheong Poon }
1089721fffe3SKacheong Poon
1090721fffe3SKacheong Poon /*
1091721fffe3SKacheong Poon * The TCP fast path write put procedure.
1092721fffe3SKacheong Poon * NOTE: the logic of the fast path is duplicated from tcp_wput_data()
1093721fffe3SKacheong Poon */
1094721fffe3SKacheong Poon /* ARGSUSED */
1095721fffe3SKacheong Poon void
tcp_output(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)1096721fffe3SKacheong Poon tcp_output(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
1097721fffe3SKacheong Poon {
1098721fffe3SKacheong Poon int len;
1099721fffe3SKacheong Poon int hdrlen;
1100721fffe3SKacheong Poon int plen;
1101721fffe3SKacheong Poon mblk_t *mp1;
1102721fffe3SKacheong Poon uchar_t *rptr;
1103721fffe3SKacheong Poon uint32_t snxt;
1104721fffe3SKacheong Poon tcpha_t *tcpha;
1105721fffe3SKacheong Poon struct datab *db;
1106721fffe3SKacheong Poon uint32_t suna;
1107721fffe3SKacheong Poon uint32_t mss;
1108721fffe3SKacheong Poon ipaddr_t *dst;
1109721fffe3SKacheong Poon ipaddr_t *src;
1110721fffe3SKacheong Poon uint32_t sum;
1111721fffe3SKacheong Poon int usable;
1112721fffe3SKacheong Poon conn_t *connp = (conn_t *)arg;
1113721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
1114721fffe3SKacheong Poon uint32_t msize;
1115721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
1116721fffe3SKacheong Poon ip_xmit_attr_t *ixa;
1117721fffe3SKacheong Poon clock_t now;
1118721fffe3SKacheong Poon
1119721fffe3SKacheong Poon /*
1120721fffe3SKacheong Poon * Try and ASSERT the minimum possible references on the
1121721fffe3SKacheong Poon * conn early enough. Since we are executing on write side,
1122721fffe3SKacheong Poon * the connection is obviously not detached and that means
1123721fffe3SKacheong Poon * there is a ref each for TCP and IP. Since we are behind
1124721fffe3SKacheong Poon * the squeue, the minimum references needed are 3. If the
1125721fffe3SKacheong Poon * conn is in classifier hash list, there should be an
1126721fffe3SKacheong Poon * extra ref for that (we check both the possibilities).
1127721fffe3SKacheong Poon */
1128721fffe3SKacheong Poon ASSERT((connp->conn_fanout != NULL && connp->conn_ref >= 4) ||
1129721fffe3SKacheong Poon (connp->conn_fanout == NULL && connp->conn_ref >= 3));
1130721fffe3SKacheong Poon
1131721fffe3SKacheong Poon ASSERT(DB_TYPE(mp) == M_DATA);
1132721fffe3SKacheong Poon msize = (mp->b_cont == NULL) ? MBLKL(mp) : msgdsize(mp);
1133721fffe3SKacheong Poon
1134721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
1135721fffe3SKacheong Poon tcp->tcp_squeue_bytes -= msize;
1136721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
1137721fffe3SKacheong Poon
1138721fffe3SKacheong Poon /* Bypass tcp protocol for fused tcp loopback */
1139721fffe3SKacheong Poon if (tcp->tcp_fused && tcp_fuse_output(tcp, mp, msize))
1140721fffe3SKacheong Poon return;
1141721fffe3SKacheong Poon
1142721fffe3SKacheong Poon mss = tcp->tcp_mss;
1143721fffe3SKacheong Poon /*
1144721fffe3SKacheong Poon * If ZEROCOPY has turned off, try not to send any zero-copy message
1145721fffe3SKacheong Poon * down. Do backoff, now.
1146721fffe3SKacheong Poon */
1147721fffe3SKacheong Poon if (tcp->tcp_snd_zcopy_aware && !tcp->tcp_snd_zcopy_on)
1148721fffe3SKacheong Poon mp = tcp_zcopy_backoff(tcp, mp, B_FALSE);
1149721fffe3SKacheong Poon
1150721fffe3SKacheong Poon
1151721fffe3SKacheong Poon ASSERT((uintptr_t)(mp->b_wptr - mp->b_rptr) <= (uintptr_t)INT_MAX);
1152721fffe3SKacheong Poon len = (int)(mp->b_wptr - mp->b_rptr);
1153721fffe3SKacheong Poon
1154721fffe3SKacheong Poon /*
1155721fffe3SKacheong Poon * Criteria for fast path:
1156721fffe3SKacheong Poon *
1157721fffe3SKacheong Poon * 1. no unsent data
1158721fffe3SKacheong Poon * 2. single mblk in request
1159721fffe3SKacheong Poon * 3. connection established
1160721fffe3SKacheong Poon * 4. data in mblk
1161721fffe3SKacheong Poon * 5. len <= mss
1162721fffe3SKacheong Poon * 6. no tcp_valid bits
1163*1edba515SAndy Fiddaman * 7. no MD5 signature option
1164721fffe3SKacheong Poon */
1165*1edba515SAndy Fiddaman if (tcp->tcp_unsent != 0 ||
1166*1edba515SAndy Fiddaman tcp->tcp_cork ||
1167*1edba515SAndy Fiddaman tcp->tcp_md5sig ||
1168*1edba515SAndy Fiddaman mp->b_cont != NULL ||
1169*1edba515SAndy Fiddaman tcp->tcp_state != TCPS_ESTABLISHED ||
1170*1edba515SAndy Fiddaman len == 0 ||
1171*1edba515SAndy Fiddaman len > mss ||
1172*1edba515SAndy Fiddaman tcp->tcp_valid_bits != 0) {
1173721fffe3SKacheong Poon tcp_wput_data(tcp, mp, B_FALSE);
1174721fffe3SKacheong Poon return;
1175721fffe3SKacheong Poon }
1176721fffe3SKacheong Poon
1177721fffe3SKacheong Poon ASSERT(tcp->tcp_xmit_tail_unsent == 0);
1178721fffe3SKacheong Poon ASSERT(tcp->tcp_fin_sent == 0);
1179721fffe3SKacheong Poon
1180721fffe3SKacheong Poon /* queue new packet onto retransmission queue */
1181721fffe3SKacheong Poon if (tcp->tcp_xmit_head == NULL) {
1182721fffe3SKacheong Poon tcp->tcp_xmit_head = mp;
1183721fffe3SKacheong Poon } else {
1184721fffe3SKacheong Poon tcp->tcp_xmit_last->b_cont = mp;
1185721fffe3SKacheong Poon }
1186721fffe3SKacheong Poon tcp->tcp_xmit_last = mp;
1187721fffe3SKacheong Poon tcp->tcp_xmit_tail = mp;
1188721fffe3SKacheong Poon
1189721fffe3SKacheong Poon /* find out how much we can send */
1190721fffe3SKacheong Poon /* BEGIN CSTYLED */
1191721fffe3SKacheong Poon /*
1192721fffe3SKacheong Poon * un-acked usable
1193721fffe3SKacheong Poon * |--------------|-----------------|
1194721fffe3SKacheong Poon * tcp_suna tcp_snxt tcp_suna+tcp_swnd
1195721fffe3SKacheong Poon */
1196721fffe3SKacheong Poon /* END CSTYLED */
1197721fffe3SKacheong Poon
1198721fffe3SKacheong Poon /* start sending from tcp_snxt */
1199721fffe3SKacheong Poon snxt = tcp->tcp_snxt;
1200721fffe3SKacheong Poon
1201721fffe3SKacheong Poon /*
1202c12492cfSSebastien Roy * Check to see if this connection has been idle for some time and no
1203c12492cfSSebastien Roy * ACK is expected. If so, then the congestion window size is no longer
1204c12492cfSSebastien Roy * meaningfully tied to current network conditions.
1205721fffe3SKacheong Poon *
1206c12492cfSSebastien Roy * We reinitialize tcp_cwnd, and slow start again to get back the
1207c12492cfSSebastien Roy * connection's "self-clock" as described in Van Jacobson's 1988 paper
1208c12492cfSSebastien Roy * "Congestion avoidance and control".
1209721fffe3SKacheong Poon */
1210721fffe3SKacheong Poon now = LBOLT_FASTPATH;
1211721fffe3SKacheong Poon if ((tcp->tcp_suna == snxt) && !tcp->tcp_localnet &&
1212721fffe3SKacheong Poon (TICK_TO_MSEC(now - tcp->tcp_last_recv_time) >= tcp->tcp_rto)) {
121345a4b79dSSebastien Roy cc_after_idle(tcp);
1214721fffe3SKacheong Poon }
1215721fffe3SKacheong Poon
1216721fffe3SKacheong Poon usable = tcp->tcp_swnd; /* tcp window size */
1217721fffe3SKacheong Poon if (usable > tcp->tcp_cwnd)
1218721fffe3SKacheong Poon usable = tcp->tcp_cwnd; /* congestion window smaller */
1219721fffe3SKacheong Poon usable -= snxt; /* subtract stuff already sent */
1220721fffe3SKacheong Poon suna = tcp->tcp_suna;
1221721fffe3SKacheong Poon usable += suna;
1222721fffe3SKacheong Poon /* usable can be < 0 if the congestion window is smaller */
1223721fffe3SKacheong Poon if (len > usable) {
1224721fffe3SKacheong Poon /* Can't send complete M_DATA in one shot */
1225721fffe3SKacheong Poon goto slow;
1226721fffe3SKacheong Poon }
1227721fffe3SKacheong Poon
1228721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
1229721fffe3SKacheong Poon if (tcp->tcp_flow_stopped &&
1230721fffe3SKacheong Poon TCP_UNSENT_BYTES(tcp) <= connp->conn_sndlowat) {
1231721fffe3SKacheong Poon tcp_clrqfull(tcp);
1232721fffe3SKacheong Poon }
1233721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
1234721fffe3SKacheong Poon
1235721fffe3SKacheong Poon /*
1236721fffe3SKacheong Poon * determine if anything to send (Nagle).
1237721fffe3SKacheong Poon *
1238721fffe3SKacheong Poon * 1. len < tcp_mss (i.e. small)
1239721fffe3SKacheong Poon * 2. unacknowledged data present
1240721fffe3SKacheong Poon * 3. len < nagle limit
1241721fffe3SKacheong Poon * 4. last packet sent < nagle limit (previous packet sent)
1242721fffe3SKacheong Poon */
1243721fffe3SKacheong Poon if ((len < mss) && (snxt != suna) &&
1244721fffe3SKacheong Poon (len < (int)tcp->tcp_naglim) &&
1245721fffe3SKacheong Poon (tcp->tcp_last_sent_len < tcp->tcp_naglim)) {
1246721fffe3SKacheong Poon /*
1247721fffe3SKacheong Poon * This was the first unsent packet and normally
1248721fffe3SKacheong Poon * mss < xmit_hiwater so there is no need to worry
1249721fffe3SKacheong Poon * about flow control. The next packet will go
1250721fffe3SKacheong Poon * through the flow control check in tcp_wput_data().
1251721fffe3SKacheong Poon */
1252721fffe3SKacheong Poon /* leftover work from above */
1253721fffe3SKacheong Poon tcp->tcp_unsent = len;
1254721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = len;
1255721fffe3SKacheong Poon
1256721fffe3SKacheong Poon return;
1257721fffe3SKacheong Poon }
1258721fffe3SKacheong Poon
1259721fffe3SKacheong Poon /*
1260721fffe3SKacheong Poon * len <= tcp->tcp_mss && len == unsent so no sender silly window. Can
1261721fffe3SKacheong Poon * send now.
1262721fffe3SKacheong Poon */
1263721fffe3SKacheong Poon
1264721fffe3SKacheong Poon if (snxt == suna) {
1265721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
1266721fffe3SKacheong Poon }
1267721fffe3SKacheong Poon
1268721fffe3SKacheong Poon /* we have always sent something */
1269721fffe3SKacheong Poon tcp->tcp_rack_cnt = 0;
1270721fffe3SKacheong Poon
1271721fffe3SKacheong Poon tcp->tcp_snxt = snxt + len;
1272721fffe3SKacheong Poon tcp->tcp_rack = tcp->tcp_rnxt;
1273721fffe3SKacheong Poon
1274721fffe3SKacheong Poon if ((mp1 = dupb(mp)) == 0)
1275721fffe3SKacheong Poon goto no_memory;
1276c12492cfSSebastien Roy mp->b_prev = (mblk_t *)(intptr_t)gethrtime();
1277721fffe3SKacheong Poon mp->b_next = (mblk_t *)(uintptr_t)snxt;
1278721fffe3SKacheong Poon
1279721fffe3SKacheong Poon /* adjust tcp header information */
1280721fffe3SKacheong Poon tcpha = tcp->tcp_tcpha;
1281721fffe3SKacheong Poon tcpha->tha_flags = (TH_ACK|TH_PUSH);
1282721fffe3SKacheong Poon
1283721fffe3SKacheong Poon sum = len + connp->conn_ht_ulp_len + connp->conn_sum;
1284721fffe3SKacheong Poon sum = (sum >> 16) + (sum & 0xFFFF);
1285721fffe3SKacheong Poon tcpha->tha_sum = htons(sum);
1286721fffe3SKacheong Poon
1287721fffe3SKacheong Poon tcpha->tha_seq = htonl(snxt);
1288721fffe3SKacheong Poon
1289721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutDataSegs);
1290721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpOutDataBytes, len);
1291a2f04351SSebastien Roy TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
1292a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_segs++;
1293a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_bytes += len;
1294721fffe3SKacheong Poon
1295721fffe3SKacheong Poon /* Update the latest receive window size in TCP header. */
1296721fffe3SKacheong Poon tcpha->tha_win = htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
1297721fffe3SKacheong Poon
1298721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)len;
1299721fffe3SKacheong Poon
1300721fffe3SKacheong Poon plen = len + connp->conn_ht_iphc_len;
1301721fffe3SKacheong Poon
1302721fffe3SKacheong Poon ixa = connp->conn_ixa;
1303721fffe3SKacheong Poon ixa->ixa_pktlen = plen;
1304721fffe3SKacheong Poon
1305721fffe3SKacheong Poon if (ixa->ixa_flags & IXAF_IS_IPV4) {
1306721fffe3SKacheong Poon tcp->tcp_ipha->ipha_length = htons(plen);
1307721fffe3SKacheong Poon } else {
1308721fffe3SKacheong Poon tcp->tcp_ip6h->ip6_plen = htons(plen - IPV6_HDR_LEN);
1309721fffe3SKacheong Poon }
1310721fffe3SKacheong Poon
1311721fffe3SKacheong Poon /* see if we need to allocate a mblk for the headers */
1312721fffe3SKacheong Poon hdrlen = connp->conn_ht_iphc_len;
1313721fffe3SKacheong Poon rptr = mp1->b_rptr - hdrlen;
1314721fffe3SKacheong Poon db = mp1->b_datap;
1315721fffe3SKacheong Poon if ((db->db_ref != 2) || rptr < db->db_base ||
1316721fffe3SKacheong Poon (!OK_32PTR(rptr))) {
1317721fffe3SKacheong Poon /* NOTE: we assume allocb returns an OK_32PTR */
1318721fffe3SKacheong Poon mp = allocb(hdrlen + tcps->tcps_wroff_xtra, BPRI_MED);
1319721fffe3SKacheong Poon if (!mp) {
1320721fffe3SKacheong Poon freemsg(mp1);
1321721fffe3SKacheong Poon goto no_memory;
1322721fffe3SKacheong Poon }
1323721fffe3SKacheong Poon mp->b_cont = mp1;
1324721fffe3SKacheong Poon mp1 = mp;
1325721fffe3SKacheong Poon /* Leave room for Link Level header */
1326721fffe3SKacheong Poon rptr = &mp1->b_rptr[tcps->tcps_wroff_xtra];
1327721fffe3SKacheong Poon mp1->b_wptr = &rptr[hdrlen];
1328721fffe3SKacheong Poon }
1329721fffe3SKacheong Poon mp1->b_rptr = rptr;
1330721fffe3SKacheong Poon
1331721fffe3SKacheong Poon /* Fill in the timestamp option. */
1332721fffe3SKacheong Poon if (tcp->tcp_snd_ts_ok) {
1333c12492cfSSebastien Roy U32_TO_BE32(now,
1334c12492cfSSebastien Roy (char *)tcpha + TCP_MIN_HEADER_LENGTH + 4);
1335721fffe3SKacheong Poon U32_TO_BE32(tcp->tcp_ts_recent,
1336c12492cfSSebastien Roy (char *)tcpha + TCP_MIN_HEADER_LENGTH + 8);
1337721fffe3SKacheong Poon } else {
1338721fffe3SKacheong Poon ASSERT(connp->conn_ht_ulp_len == TCP_MIN_HEADER_LENGTH);
1339721fffe3SKacheong Poon }
1340721fffe3SKacheong Poon
1341721fffe3SKacheong Poon /* copy header into outgoing packet */
1342721fffe3SKacheong Poon dst = (ipaddr_t *)rptr;
1343721fffe3SKacheong Poon src = (ipaddr_t *)connp->conn_ht_iphc;
1344721fffe3SKacheong Poon dst[0] = src[0];
1345721fffe3SKacheong Poon dst[1] = src[1];
1346721fffe3SKacheong Poon dst[2] = src[2];
1347721fffe3SKacheong Poon dst[3] = src[3];
1348721fffe3SKacheong Poon dst[4] = src[4];
1349721fffe3SKacheong Poon dst[5] = src[5];
1350721fffe3SKacheong Poon dst[6] = src[6];
1351721fffe3SKacheong Poon dst[7] = src[7];
1352721fffe3SKacheong Poon dst[8] = src[8];
1353721fffe3SKacheong Poon dst[9] = src[9];
1354721fffe3SKacheong Poon if (hdrlen -= 40) {
1355721fffe3SKacheong Poon hdrlen >>= 2;
1356721fffe3SKacheong Poon dst += 10;
1357721fffe3SKacheong Poon src += 10;
1358721fffe3SKacheong Poon do {
1359721fffe3SKacheong Poon *dst++ = *src++;
1360721fffe3SKacheong Poon } while (--hdrlen);
1361721fffe3SKacheong Poon }
1362721fffe3SKacheong Poon
1363721fffe3SKacheong Poon /*
1364721fffe3SKacheong Poon * Set the ECN info in the TCP header. Note that this
1365721fffe3SKacheong Poon * is not the template header.
1366721fffe3SKacheong Poon */
1367721fffe3SKacheong Poon if (tcp->tcp_ecn_ok) {
1368721fffe3SKacheong Poon TCP_SET_ECT(tcp, rptr);
1369721fffe3SKacheong Poon
1370721fffe3SKacheong Poon tcpha = (tcpha_t *)(rptr + ixa->ixa_ip_hdr_length);
1371721fffe3SKacheong Poon if (tcp->tcp_ecn_echo_on)
1372721fffe3SKacheong Poon tcpha->tha_flags |= TH_ECE;
1373721fffe3SKacheong Poon if (tcp->tcp_cwr && !tcp->tcp_ecn_cwr_sent) {
1374721fffe3SKacheong Poon tcpha->tha_flags |= TH_CWR;
1375721fffe3SKacheong Poon tcp->tcp_ecn_cwr_sent = B_TRUE;
1376721fffe3SKacheong Poon }
1377721fffe3SKacheong Poon }
1378721fffe3SKacheong Poon
1379721fffe3SKacheong Poon if (tcp->tcp_ip_forward_progress) {
1380721fffe3SKacheong Poon tcp->tcp_ip_forward_progress = B_FALSE;
1381721fffe3SKacheong Poon connp->conn_ixa->ixa_flags |= IXAF_REACH_CONF;
1382721fffe3SKacheong Poon } else {
1383721fffe3SKacheong Poon connp->conn_ixa->ixa_flags &= ~IXAF_REACH_CONF;
1384721fffe3SKacheong Poon }
1385721fffe3SKacheong Poon tcp_send_data(tcp, mp1);
1386721fffe3SKacheong Poon return;
1387721fffe3SKacheong Poon
1388721fffe3SKacheong Poon /*
1389721fffe3SKacheong Poon * If we ran out of memory, we pretend to have sent the packet
1390721fffe3SKacheong Poon * and that it was lost on the wire.
1391721fffe3SKacheong Poon */
1392721fffe3SKacheong Poon no_memory:
1393721fffe3SKacheong Poon return;
1394721fffe3SKacheong Poon
1395721fffe3SKacheong Poon slow:
1396721fffe3SKacheong Poon /* leftover work from above */
1397721fffe3SKacheong Poon tcp->tcp_unsent = len;
1398721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = len;
1399721fffe3SKacheong Poon tcp_wput_data(tcp, NULL, B_FALSE);
1400721fffe3SKacheong Poon }
1401721fffe3SKacheong Poon
1402721fffe3SKacheong Poon /* ARGSUSED2 */
1403721fffe3SKacheong Poon void
tcp_output_urgent(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)1404721fffe3SKacheong Poon tcp_output_urgent(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
1405721fffe3SKacheong Poon {
1406721fffe3SKacheong Poon int len;
1407721fffe3SKacheong Poon uint32_t msize;
1408721fffe3SKacheong Poon conn_t *connp = (conn_t *)arg;
1409721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
1410721fffe3SKacheong Poon
1411721fffe3SKacheong Poon msize = msgdsize(mp);
1412721fffe3SKacheong Poon
1413721fffe3SKacheong Poon len = msize - 1;
1414721fffe3SKacheong Poon if (len < 0) {
1415721fffe3SKacheong Poon freemsg(mp);
1416721fffe3SKacheong Poon return;
1417721fffe3SKacheong Poon }
1418721fffe3SKacheong Poon
1419721fffe3SKacheong Poon /*
1420721fffe3SKacheong Poon * Try to force urgent data out on the wire. Even if we have unsent
1421721fffe3SKacheong Poon * data this will at least send the urgent flag.
1422721fffe3SKacheong Poon * XXX does not handle more flag correctly.
1423721fffe3SKacheong Poon */
1424721fffe3SKacheong Poon len += tcp->tcp_unsent;
1425721fffe3SKacheong Poon len += tcp->tcp_snxt;
1426721fffe3SKacheong Poon tcp->tcp_urg = len;
1427721fffe3SKacheong Poon tcp->tcp_valid_bits |= TCP_URG_VALID;
1428721fffe3SKacheong Poon
1429721fffe3SKacheong Poon /* Bypass tcp protocol for fused tcp loopback */
1430721fffe3SKacheong Poon if (tcp->tcp_fused && tcp_fuse_output(tcp, mp, msize))
1431721fffe3SKacheong Poon return;
1432721fffe3SKacheong Poon
1433721fffe3SKacheong Poon /* Strip off the T_EXDATA_REQ if the data is from TPI */
1434721fffe3SKacheong Poon if (DB_TYPE(mp) != M_DATA) {
1435721fffe3SKacheong Poon mblk_t *mp1 = mp;
1436721fffe3SKacheong Poon ASSERT(!IPCL_IS_NONSTR(connp));
1437721fffe3SKacheong Poon mp = mp->b_cont;
1438721fffe3SKacheong Poon freeb(mp1);
1439721fffe3SKacheong Poon }
1440721fffe3SKacheong Poon tcp_wput_data(tcp, mp, B_TRUE);
1441721fffe3SKacheong Poon }
1442721fffe3SKacheong Poon
1443721fffe3SKacheong Poon /*
144448bbca81SDaniel Hoffman * Called by streams close routine via squeues when our client blows off its
1445721fffe3SKacheong Poon * descriptor, we take this to mean: "close the stream state NOW, close the tcp
1446721fffe3SKacheong Poon * connection politely" When SO_LINGER is set (with a non-zero linger time and
1447721fffe3SKacheong Poon * it is not a nonblocking socket) then this routine sleeps until the FIN is
1448721fffe3SKacheong Poon * acked.
1449721fffe3SKacheong Poon *
1450721fffe3SKacheong Poon * NOTE: tcp_close potentially returns error when lingering.
1451721fffe3SKacheong Poon * However, the stream head currently does not pass these errors
1452721fffe3SKacheong Poon * to the application. 4.4BSD only returns EINTR and EWOULDBLOCK
1453721fffe3SKacheong Poon * errors to the application (from tsleep()) and not errors
1454721fffe3SKacheong Poon * like ECONNRESET caused by receiving a reset packet.
1455721fffe3SKacheong Poon */
1456721fffe3SKacheong Poon
1457721fffe3SKacheong Poon /* ARGSUSED */
1458721fffe3SKacheong Poon void
tcp_close_output(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)1459721fffe3SKacheong Poon tcp_close_output(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
1460721fffe3SKacheong Poon {
1461721fffe3SKacheong Poon char *msg;
1462721fffe3SKacheong Poon conn_t *connp = (conn_t *)arg;
1463721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
1464721fffe3SKacheong Poon clock_t delta = 0;
1465721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
1466721fffe3SKacheong Poon
14673e95bd4aSAnders Persson /*
14683e95bd4aSAnders Persson * When a non-STREAMS socket is being closed, it does not always
14693e95bd4aSAnders Persson * stick around waiting for tcp_close_output to run and can therefore
14703e95bd4aSAnders Persson * have dropped a reference already. So adjust the asserts accordingly.
14713e95bd4aSAnders Persson */
14723e95bd4aSAnders Persson ASSERT((connp->conn_fanout != NULL &&
14733e95bd4aSAnders Persson connp->conn_ref >= (IPCL_IS_NONSTR(connp) ? 3 : 4)) ||
14743e95bd4aSAnders Persson (connp->conn_fanout == NULL &&
14753e95bd4aSAnders Persson connp->conn_ref >= (IPCL_IS_NONSTR(connp) ? 2 : 3)));
1476721fffe3SKacheong Poon
1477721fffe3SKacheong Poon mutex_enter(&tcp->tcp_eager_lock);
1478721fffe3SKacheong Poon if (tcp->tcp_conn_req_cnt_q0 != 0 || tcp->tcp_conn_req_cnt_q != 0) {
14793e95bd4aSAnders Persson /*
14803e95bd4aSAnders Persson * Cleanup for listener. For non-STREAM sockets sockfs will
14813e95bd4aSAnders Persson * close all the eagers on 'q', so in that case only deal
14823e95bd4aSAnders Persson * with 'q0'.
14833e95bd4aSAnders Persson */
14843e95bd4aSAnders Persson tcp_eager_cleanup(tcp, IPCL_IS_NONSTR(connp) ? 1 : 0);
1485721fffe3SKacheong Poon tcp->tcp_wait_for_eagers = 1;
1486721fffe3SKacheong Poon }
1487721fffe3SKacheong Poon mutex_exit(&tcp->tcp_eager_lock);
1488721fffe3SKacheong Poon
1489721fffe3SKacheong Poon tcp->tcp_lso = B_FALSE;
1490721fffe3SKacheong Poon
1491721fffe3SKacheong Poon msg = NULL;
1492721fffe3SKacheong Poon switch (tcp->tcp_state) {
1493721fffe3SKacheong Poon case TCPS_CLOSED:
1494721fffe3SKacheong Poon case TCPS_IDLE:
1495b1cd7879SAnders Persson break;
1496721fffe3SKacheong Poon case TCPS_BOUND:
1497b1cd7879SAnders Persson if (tcp->tcp_listener != NULL) {
1498b1cd7879SAnders Persson ASSERT(IPCL_IS_NONSTR(connp));
1499b1cd7879SAnders Persson /*
1500b1cd7879SAnders Persson * Unlink from the listener and drop the reference
1501b1cd7879SAnders Persson * put on it by the eager. tcp_closei_local will not
1502b1cd7879SAnders Persson * do it because tcp_tconnind_started is TRUE.
1503b1cd7879SAnders Persson */
1504b1cd7879SAnders Persson mutex_enter(&tcp->tcp_saved_listener->tcp_eager_lock);
1505b1cd7879SAnders Persson tcp_eager_unlink(tcp);
1506b1cd7879SAnders Persson mutex_exit(&tcp->tcp_saved_listener->tcp_eager_lock);
1507b1cd7879SAnders Persson CONN_DEC_REF(tcp->tcp_saved_listener->tcp_connp);
1508b1cd7879SAnders Persson }
1509b1cd7879SAnders Persson break;
1510721fffe3SKacheong Poon case TCPS_LISTEN:
1511721fffe3SKacheong Poon break;
1512721fffe3SKacheong Poon case TCPS_SYN_SENT:
1513721fffe3SKacheong Poon msg = "tcp_close, during connect";
1514721fffe3SKacheong Poon break;
1515721fffe3SKacheong Poon case TCPS_SYN_RCVD:
1516721fffe3SKacheong Poon /*
1517721fffe3SKacheong Poon * Close during the connect 3-way handshake
1518721fffe3SKacheong Poon * but here there may or may not be pending data
1519721fffe3SKacheong Poon * already on queue. Process almost same as in
1520721fffe3SKacheong Poon * the ESTABLISHED state.
1521721fffe3SKacheong Poon */
1522721fffe3SKacheong Poon /* FALLTHRU */
1523721fffe3SKacheong Poon default:
1524721fffe3SKacheong Poon if (tcp->tcp_fused)
1525721fffe3SKacheong Poon tcp_unfuse(tcp);
1526721fffe3SKacheong Poon
1527721fffe3SKacheong Poon /*
1528721fffe3SKacheong Poon * If SO_LINGER has set a zero linger time, abort the
1529721fffe3SKacheong Poon * connection with a reset.
1530721fffe3SKacheong Poon */
1531721fffe3SKacheong Poon if (connp->conn_linger && connp->conn_lingertime == 0) {
1532721fffe3SKacheong Poon msg = "tcp_close, zero lingertime";
1533721fffe3SKacheong Poon break;
1534721fffe3SKacheong Poon }
1535721fffe3SKacheong Poon
1536721fffe3SKacheong Poon /*
1537721fffe3SKacheong Poon * Abort connection if there is unread data queued.
1538721fffe3SKacheong Poon */
1539721fffe3SKacheong Poon if (tcp->tcp_rcv_list || tcp->tcp_reass_head) {
1540721fffe3SKacheong Poon msg = "tcp_close, unread data";
1541721fffe3SKacheong Poon break;
1542721fffe3SKacheong Poon }
15433e95bd4aSAnders Persson
1544721fffe3SKacheong Poon /*
15453e95bd4aSAnders Persson * Abort connection if it is being closed without first
15463e95bd4aSAnders Persson * being accepted. This can happen if a listening non-STREAM
15473e95bd4aSAnders Persson * socket wants to get rid of the socket, for example, if the
15483e95bd4aSAnders Persson * listener is closing.
1549721fffe3SKacheong Poon */
15503e95bd4aSAnders Persson if (tcp->tcp_listener != NULL) {
15513e95bd4aSAnders Persson ASSERT(IPCL_IS_NONSTR(connp));
15523e95bd4aSAnders Persson msg = "tcp_close, close before accept";
15533e95bd4aSAnders Persson
15543e95bd4aSAnders Persson /*
15553e95bd4aSAnders Persson * Unlink from the listener and drop the reference
15563e95bd4aSAnders Persson * put on it by the eager. tcp_closei_local will not
15573e95bd4aSAnders Persson * do it because tcp_tconnind_started is TRUE.
15583e95bd4aSAnders Persson */
15593e95bd4aSAnders Persson mutex_enter(&tcp->tcp_saved_listener->tcp_eager_lock);
15603e95bd4aSAnders Persson tcp_eager_unlink(tcp);
15613e95bd4aSAnders Persson mutex_exit(&tcp->tcp_saved_listener->tcp_eager_lock);
15623e95bd4aSAnders Persson CONN_DEC_REF(tcp->tcp_saved_listener->tcp_connp);
1563721fffe3SKacheong Poon break;
15643e95bd4aSAnders Persson }
1565721fffe3SKacheong Poon
1566721fffe3SKacheong Poon /*
1567721fffe3SKacheong Poon * Transmit the FIN before detaching the tcp_t.
1568721fffe3SKacheong Poon * After tcp_detach returns this queue/perimeter
1569721fffe3SKacheong Poon * no longer owns the tcp_t thus others can modify it.
1570721fffe3SKacheong Poon */
1571721fffe3SKacheong Poon (void) tcp_xmit_end(tcp);
1572721fffe3SKacheong Poon
1573721fffe3SKacheong Poon /*
1574721fffe3SKacheong Poon * If lingering on close then wait until the fin is acked,
1575721fffe3SKacheong Poon * the SO_LINGER time passes, or a reset is sent/received.
1576721fffe3SKacheong Poon */
1577721fffe3SKacheong Poon if (connp->conn_linger && connp->conn_lingertime > 0 &&
1578721fffe3SKacheong Poon !(tcp->tcp_fin_acked) &&
1579721fffe3SKacheong Poon tcp->tcp_state >= TCPS_ESTABLISHED) {
1580721fffe3SKacheong Poon if (tcp->tcp_closeflags & (FNDELAY|FNONBLOCK)) {
1581721fffe3SKacheong Poon tcp->tcp_client_errno = EWOULDBLOCK;
1582721fffe3SKacheong Poon } else if (tcp->tcp_client_errno == 0) {
1583721fffe3SKacheong Poon
1584721fffe3SKacheong Poon ASSERT(tcp->tcp_linger_tid == 0);
1585721fffe3SKacheong Poon
158666cd0f60SKacheong Poon /* conn_lingertime is in sec. */
1587721fffe3SKacheong Poon tcp->tcp_linger_tid = TCP_TIMER(tcp,
1588721fffe3SKacheong Poon tcp_close_linger_timeout,
158966cd0f60SKacheong Poon connp->conn_lingertime * MILLISEC);
1590721fffe3SKacheong Poon
1591721fffe3SKacheong Poon /* tcp_close_linger_timeout will finish close */
1592721fffe3SKacheong Poon if (tcp->tcp_linger_tid == 0)
1593721fffe3SKacheong Poon tcp->tcp_client_errno = ENOSR;
1594721fffe3SKacheong Poon else
1595721fffe3SKacheong Poon return;
1596721fffe3SKacheong Poon }
1597721fffe3SKacheong Poon
1598721fffe3SKacheong Poon /*
1599721fffe3SKacheong Poon * Check if we need to detach or just close
1600721fffe3SKacheong Poon * the instance.
1601721fffe3SKacheong Poon */
1602721fffe3SKacheong Poon if (tcp->tcp_state <= TCPS_LISTEN)
1603721fffe3SKacheong Poon break;
1604721fffe3SKacheong Poon }
1605721fffe3SKacheong Poon
1606721fffe3SKacheong Poon /*
1607721fffe3SKacheong Poon * Make sure that no other thread will access the conn_rq of
1608721fffe3SKacheong Poon * this instance (through lookups etc.) as conn_rq will go
1609721fffe3SKacheong Poon * away shortly.
1610721fffe3SKacheong Poon */
1611721fffe3SKacheong Poon tcp_acceptor_hash_remove(tcp);
1612721fffe3SKacheong Poon
1613721fffe3SKacheong Poon mutex_enter(&tcp->tcp_non_sq_lock);
1614721fffe3SKacheong Poon if (tcp->tcp_flow_stopped) {
1615721fffe3SKacheong Poon tcp_clrqfull(tcp);
1616721fffe3SKacheong Poon }
1617721fffe3SKacheong Poon mutex_exit(&tcp->tcp_non_sq_lock);
1618721fffe3SKacheong Poon
1619721fffe3SKacheong Poon if (tcp->tcp_timer_tid != 0) {
1620721fffe3SKacheong Poon delta = TCP_TIMER_CANCEL(tcp, tcp->tcp_timer_tid);
1621721fffe3SKacheong Poon tcp->tcp_timer_tid = 0;
1622721fffe3SKacheong Poon }
1623721fffe3SKacheong Poon /*
1624721fffe3SKacheong Poon * Need to cancel those timers which will not be used when
1625721fffe3SKacheong Poon * TCP is detached. This has to be done before the conn_wq
1626721fffe3SKacheong Poon * is set to NULL.
1627721fffe3SKacheong Poon */
1628721fffe3SKacheong Poon tcp_timers_stop(tcp);
1629721fffe3SKacheong Poon
1630721fffe3SKacheong Poon tcp->tcp_detached = B_TRUE;
1631721fffe3SKacheong Poon if (tcp->tcp_state == TCPS_TIME_WAIT) {
1632721fffe3SKacheong Poon tcp_time_wait_append(tcp);
1633721fffe3SKacheong Poon TCP_DBGSTAT(tcps, tcp_detach_time_wait);
16343e95bd4aSAnders Persson ASSERT(connp->conn_ref >=
16353e95bd4aSAnders Persson (IPCL_IS_NONSTR(connp) ? 2 : 3));
1636721fffe3SKacheong Poon goto finish;
1637721fffe3SKacheong Poon }
1638721fffe3SKacheong Poon
1639721fffe3SKacheong Poon /*
1640721fffe3SKacheong Poon * If delta is zero the timer event wasn't executed and was
1641721fffe3SKacheong Poon * successfully canceled. In this case we need to restart it
1642721fffe3SKacheong Poon * with the minimal delta possible.
1643721fffe3SKacheong Poon */
1644721fffe3SKacheong Poon if (delta >= 0)
1645721fffe3SKacheong Poon tcp->tcp_timer_tid = TCP_TIMER(tcp, tcp_timer,
1646721fffe3SKacheong Poon delta ? delta : 1);
1647721fffe3SKacheong Poon
16483e95bd4aSAnders Persson ASSERT(connp->conn_ref >= (IPCL_IS_NONSTR(connp) ? 2 : 3));
1649721fffe3SKacheong Poon goto finish;
1650721fffe3SKacheong Poon }
1651721fffe3SKacheong Poon
1652721fffe3SKacheong Poon /* Detach did not complete. Still need to remove q from stream. */
1653721fffe3SKacheong Poon if (msg) {
1654721fffe3SKacheong Poon if (tcp->tcp_state == TCPS_ESTABLISHED ||
1655721fffe3SKacheong Poon tcp->tcp_state == TCPS_CLOSE_WAIT)
1656721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpEstabResets);
1657721fffe3SKacheong Poon if (tcp->tcp_state == TCPS_SYN_SENT ||
1658721fffe3SKacheong Poon tcp->tcp_state == TCPS_SYN_RCVD)
1659721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpAttemptFails);
1660721fffe3SKacheong Poon tcp_xmit_ctl(msg, tcp, tcp->tcp_snxt, 0, TH_RST);
1661721fffe3SKacheong Poon }
1662721fffe3SKacheong Poon
1663721fffe3SKacheong Poon tcp_closei_local(tcp);
1664721fffe3SKacheong Poon CONN_DEC_REF(connp);
16653e95bd4aSAnders Persson ASSERT(connp->conn_ref >= (IPCL_IS_NONSTR(connp) ? 1 : 2));
1666721fffe3SKacheong Poon
1667721fffe3SKacheong Poon finish:
1668721fffe3SKacheong Poon /*
1669721fffe3SKacheong Poon * Don't change the queues in the case of a listener that has
1670721fffe3SKacheong Poon * eagers in its q or q0. It could surprise the eagers.
1671721fffe3SKacheong Poon * Instead wait for the eagers outside the squeue.
16723e95bd4aSAnders Persson *
16733e95bd4aSAnders Persson * For non-STREAMS sockets tcp_wait_for_eagers implies that
16743e95bd4aSAnders Persson * we should delay the su_closed upcall until all eagers have
16753e95bd4aSAnders Persson * dropped their references.
1676721fffe3SKacheong Poon */
1677721fffe3SKacheong Poon if (!tcp->tcp_wait_for_eagers) {
1678721fffe3SKacheong Poon tcp->tcp_detached = B_TRUE;
1679721fffe3SKacheong Poon connp->conn_rq = NULL;
1680721fffe3SKacheong Poon connp->conn_wq = NULL;
16813e95bd4aSAnders Persson
16823e95bd4aSAnders Persson /* non-STREAM socket, release the upper handle */
16833e95bd4aSAnders Persson if (IPCL_IS_NONSTR(connp)) {
16842ad53042SDan McDonald sock_upcalls_t *upcalls = connp->conn_upcalls;
16852ad53042SDan McDonald sock_upper_handle_t handle = connp->conn_upper_handle;
16862ad53042SDan McDonald
16872ad53042SDan McDonald ASSERT(upcalls != NULL);
16882ad53042SDan McDonald ASSERT(upcalls->su_closed != NULL);
16892ad53042SDan McDonald ASSERT(handle != NULL);
16902ad53042SDan McDonald /*
16912ad53042SDan McDonald * Set these to NULL first because closed() will free
16922ad53042SDan McDonald * upper structures. Acquire conn_lock because an
16932ad53042SDan McDonald * external caller like conn_get_socket_info() will
16942ad53042SDan McDonald * upcall if these are non-NULL.
16952ad53042SDan McDonald */
16962ad53042SDan McDonald mutex_enter(&connp->conn_lock);
16973e95bd4aSAnders Persson connp->conn_upper_handle = NULL;
16983e95bd4aSAnders Persson connp->conn_upcalls = NULL;
16992ad53042SDan McDonald mutex_exit(&connp->conn_lock);
17002ad53042SDan McDonald upcalls->su_closed(handle);
17013e95bd4aSAnders Persson }
1702721fffe3SKacheong Poon }
1703721fffe3SKacheong Poon
1704721fffe3SKacheong Poon /* Signal tcp_close() to finish closing. */
17053e95bd4aSAnders Persson mutex_enter(&tcp->tcp_closelock);
1706721fffe3SKacheong Poon tcp->tcp_closed = 1;
1707721fffe3SKacheong Poon cv_signal(&tcp->tcp_closecv);
1708721fffe3SKacheong Poon mutex_exit(&tcp->tcp_closelock);
1709721fffe3SKacheong Poon }
1710721fffe3SKacheong Poon
1711721fffe3SKacheong Poon /* ARGSUSED */
1712721fffe3SKacheong Poon void
tcp_shutdown_output(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)1713721fffe3SKacheong Poon tcp_shutdown_output(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
1714721fffe3SKacheong Poon {
17158a06b3d6SToomas Soome conn_t *connp = (conn_t *)arg;
1716721fffe3SKacheong Poon tcp_t *tcp = connp->conn_tcp;
1717721fffe3SKacheong Poon
1718721fffe3SKacheong Poon freemsg(mp);
1719721fffe3SKacheong Poon
1720721fffe3SKacheong Poon if (tcp->tcp_fused)
1721721fffe3SKacheong Poon tcp_unfuse(tcp);
1722721fffe3SKacheong Poon
1723721fffe3SKacheong Poon if (tcp_xmit_end(tcp) != 0) {
1724721fffe3SKacheong Poon /*
1725721fffe3SKacheong Poon * We were crossing FINs and got a reset from
1726721fffe3SKacheong Poon * the other side. Just ignore it.
1727721fffe3SKacheong Poon */
1728721fffe3SKacheong Poon if (connp->conn_debug) {
1729721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1,
1730721fffe3SKacheong Poon SL_ERROR|SL_TRACE,
1731721fffe3SKacheong Poon "tcp_shutdown_output() out of state %s",
1732721fffe3SKacheong Poon tcp_display(tcp, NULL, DISP_ADDR_AND_PORT));
1733721fffe3SKacheong Poon }
1734721fffe3SKacheong Poon }
1735721fffe3SKacheong Poon }
1736721fffe3SKacheong Poon
1737721fffe3SKacheong Poon #pragma inline(tcp_send_data)
1738721fffe3SKacheong Poon
1739721fffe3SKacheong Poon void
tcp_send_data(tcp_t * tcp,mblk_t * mp)1740721fffe3SKacheong Poon tcp_send_data(tcp_t *tcp, mblk_t *mp)
1741721fffe3SKacheong Poon {
1742721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
1743721fffe3SKacheong Poon
1744721fffe3SKacheong Poon /*
1745721fffe3SKacheong Poon * Check here to avoid sending zero-copy message down to IP when
1746721fffe3SKacheong Poon * ZEROCOPY capability has turned off. We only need to deal with
1747721fffe3SKacheong Poon * the race condition between sockfs and the notification here.
1748721fffe3SKacheong Poon * Since we have tried to backoff the tcp_xmit_head when turning
1749721fffe3SKacheong Poon * zero-copy off and new messages in tcp_output(), we simply drop
1750721fffe3SKacheong Poon * the dup'ed packet here and let tcp retransmit, if tcp_xmit_zc_clean
1751721fffe3SKacheong Poon * is not true.
1752721fffe3SKacheong Poon */
1753721fffe3SKacheong Poon if (tcp->tcp_snd_zcopy_aware && !tcp->tcp_snd_zcopy_on &&
1754721fffe3SKacheong Poon !tcp->tcp_xmit_zc_clean) {
1755721fffe3SKacheong Poon ip_drop_output("TCP ZC was disabled but not clean", mp, NULL);
1756721fffe3SKacheong Poon freemsg(mp);
1757721fffe3SKacheong Poon return;
1758721fffe3SKacheong Poon }
1759721fffe3SKacheong Poon
17609cd928feSAlan Maguire DTRACE_TCP5(send, mblk_t *, NULL, ip_xmit_attr_t *, connp->conn_ixa,
17619cd928feSAlan Maguire __dtrace_tcp_void_ip_t *, mp->b_rptr, tcp_t *, tcp,
17629cd928feSAlan Maguire __dtrace_tcp_tcph_t *,
17639cd928feSAlan Maguire &mp->b_rptr[connp->conn_ixa->ixa_ip_hdr_length]);
17649cd928feSAlan Maguire
1765721fffe3SKacheong Poon ASSERT(connp->conn_ixa->ixa_notify_cookie == connp->conn_tcp);
1766721fffe3SKacheong Poon (void) conn_ip_output(mp, connp->conn_ixa);
1767721fffe3SKacheong Poon }
1768721fffe3SKacheong Poon
1769721fffe3SKacheong Poon /* ARGSUSED2 */
1770721fffe3SKacheong Poon void
tcp_send_synack(void * arg,mblk_t * mp,void * arg2,ip_recv_attr_t * dummy)1771721fffe3SKacheong Poon tcp_send_synack(void *arg, mblk_t *mp, void *arg2, ip_recv_attr_t *dummy)
1772721fffe3SKacheong Poon {
1773721fffe3SKacheong Poon conn_t *econnp = (conn_t *)arg;
1774721fffe3SKacheong Poon tcp_t *tcp = econnp->conn_tcp;
1775e5e7971fSErik Nordmark ip_xmit_attr_t *ixa = econnp->conn_ixa;
1776721fffe3SKacheong Poon
1777721fffe3SKacheong Poon /* Guard against a RST having blown it away while on the squeue */
1778721fffe3SKacheong Poon if (tcp->tcp_state == TCPS_CLOSED) {
1779721fffe3SKacheong Poon freemsg(mp);
1780721fffe3SKacheong Poon return;
1781721fffe3SKacheong Poon }
1782721fffe3SKacheong Poon
1783e5e7971fSErik Nordmark /*
1784e5e7971fSErik Nordmark * In the off-chance that the eager received and responded to
1785e5e7971fSErik Nordmark * some other packet while the SYN|ACK was queued, we recalculate
1786e5e7971fSErik Nordmark * the ixa_pktlen. It would be better to fix the SYN/accept
1787e5e7971fSErik Nordmark * multithreading scheme to avoid this complexity.
1788e5e7971fSErik Nordmark */
1789e5e7971fSErik Nordmark ixa->ixa_pktlen = msgdsize(mp);
1790e5e7971fSErik Nordmark (void) conn_ip_output(mp, ixa);
1791721fffe3SKacheong Poon }
1792721fffe3SKacheong Poon
1793721fffe3SKacheong Poon /*
1794721fffe3SKacheong Poon * tcp_send() is called by tcp_wput_data() and returns one of the following:
1795721fffe3SKacheong Poon *
1796721fffe3SKacheong Poon * -1 = failed allocation.
1797633fc3a6SSebastien Roy * 0 = We've either successfully sent data, or our usable send window is too
1798633fc3a6SSebastien Roy * small and we'd rather wait until later before sending again.
1799721fffe3SKacheong Poon */
1800721fffe3SKacheong Poon static int
tcp_send(tcp_t * tcp,const int mss,const int total_hdr_len,const int tcp_hdr_len,const int num_sack_blk,int * usable,uint32_t * snxt,int * tail_unsent,mblk_t ** xmit_tail,mblk_t * local_time)1801721fffe3SKacheong Poon tcp_send(tcp_t *tcp, const int mss, const int total_hdr_len,
1802721fffe3SKacheong Poon const int tcp_hdr_len, const int num_sack_blk, int *usable,
1803c12492cfSSebastien Roy uint32_t *snxt, int *tail_unsent, mblk_t **xmit_tail, mblk_t *local_time)
1804721fffe3SKacheong Poon {
1805721fffe3SKacheong Poon int num_lso_seg = 1;
1806ab82c29bSToomas Soome uint_t lso_usable = 0;
1807721fffe3SKacheong Poon boolean_t do_lso_send = B_FALSE;
1808721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
1809721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
1810721fffe3SKacheong Poon ip_xmit_attr_t *ixa = connp->conn_ixa;
1811721fffe3SKacheong Poon
1812721fffe3SKacheong Poon /*
1813721fffe3SKacheong Poon * Check LSO possibility. The value of tcp->tcp_lso indicates whether
1814721fffe3SKacheong Poon * the underlying connection is LSO capable. Will check whether having
1815721fffe3SKacheong Poon * enough available data to initiate LSO transmission in the for(){}
1816721fffe3SKacheong Poon * loops.
1817721fffe3SKacheong Poon */
1818721fffe3SKacheong Poon if (tcp->tcp_lso && (tcp->tcp_valid_bits & ~TCP_FSS_VALID) == 0)
1819721fffe3SKacheong Poon do_lso_send = B_TRUE;
1820721fffe3SKacheong Poon
1821721fffe3SKacheong Poon for (;;) {
1822721fffe3SKacheong Poon struct datab *db;
1823721fffe3SKacheong Poon tcpha_t *tcpha;
1824721fffe3SKacheong Poon uint32_t sum;
1825721fffe3SKacheong Poon mblk_t *mp, *mp1;
1826721fffe3SKacheong Poon uchar_t *rptr;
1827721fffe3SKacheong Poon int len;
1828721fffe3SKacheong Poon
1829721fffe3SKacheong Poon /*
1830721fffe3SKacheong Poon * Calculate the maximum payload length we can send at one
1831721fffe3SKacheong Poon * time.
1832721fffe3SKacheong Poon */
1833721fffe3SKacheong Poon if (do_lso_send) {
1834721fffe3SKacheong Poon /*
1835633fc3a6SSebastien Roy * Determine whether or not it's possible to do LSO,
1836633fc3a6SSebastien Roy * and if so, how much data we can send.
1837721fffe3SKacheong Poon */
1838633fc3a6SSebastien Roy if ((*usable - 1) / mss >= 1) {
1839721fffe3SKacheong Poon lso_usable = MIN(tcp->tcp_lso_max, *usable);
1840721fffe3SKacheong Poon num_lso_seg = lso_usable / mss;
1841721fffe3SKacheong Poon if (lso_usable % mss) {
1842721fffe3SKacheong Poon num_lso_seg++;
1843721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)
1844721fffe3SKacheong Poon (lso_usable % mss);
1845721fffe3SKacheong Poon } else {
1846721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)mss;
1847721fffe3SKacheong Poon }
1848721fffe3SKacheong Poon } else {
1849721fffe3SKacheong Poon do_lso_send = B_FALSE;
1850721fffe3SKacheong Poon num_lso_seg = 1;
1851721fffe3SKacheong Poon lso_usable = mss;
1852721fffe3SKacheong Poon }
1853721fffe3SKacheong Poon }
1854721fffe3SKacheong Poon
1855721fffe3SKacheong Poon ASSERT(num_lso_seg <= IP_MAXPACKET / mss + 1);
1856721fffe3SKacheong Poon
1857721fffe3SKacheong Poon len = mss;
1858721fffe3SKacheong Poon if (len > *usable) {
1859721fffe3SKacheong Poon ASSERT(do_lso_send == B_FALSE);
1860721fffe3SKacheong Poon
1861721fffe3SKacheong Poon len = *usable;
1862721fffe3SKacheong Poon if (len <= 0) {
1863721fffe3SKacheong Poon /* Terminate the loop */
1864721fffe3SKacheong Poon break; /* success; too small */
1865721fffe3SKacheong Poon }
1866721fffe3SKacheong Poon /*
1867721fffe3SKacheong Poon * Sender silly-window avoidance.
1868721fffe3SKacheong Poon * Ignore this if we are going to send a
1869721fffe3SKacheong Poon * zero window probe out.
1870721fffe3SKacheong Poon *
1871721fffe3SKacheong Poon * TODO: force data into microscopic window?
1872721fffe3SKacheong Poon * ==> (!pushed || (unsent > usable))
1873721fffe3SKacheong Poon */
1874721fffe3SKacheong Poon if (len < (tcp->tcp_max_swnd >> 1) &&
1875721fffe3SKacheong Poon (tcp->tcp_unsent - (*snxt - tcp->tcp_snxt)) > len &&
1876721fffe3SKacheong Poon !((tcp->tcp_valid_bits & TCP_URG_VALID) &&
1877721fffe3SKacheong Poon len == 1) && (! tcp->tcp_zero_win_probe)) {
1878721fffe3SKacheong Poon /*
1879721fffe3SKacheong Poon * If the retransmit timer is not running
1880721fffe3SKacheong Poon * we start it so that we will retransmit
1881721fffe3SKacheong Poon * in the case when the receiver has
1882721fffe3SKacheong Poon * decremented the window.
1883721fffe3SKacheong Poon */
1884721fffe3SKacheong Poon if (*snxt == tcp->tcp_snxt &&
1885721fffe3SKacheong Poon *snxt == tcp->tcp_suna) {
1886721fffe3SKacheong Poon /*
1887721fffe3SKacheong Poon * We are not supposed to send
1888721fffe3SKacheong Poon * anything. So let's wait a little
1889721fffe3SKacheong Poon * bit longer before breaking SWS
1890721fffe3SKacheong Poon * avoidance.
1891721fffe3SKacheong Poon *
1892721fffe3SKacheong Poon * What should the value be?
1893721fffe3SKacheong Poon * Suggestion: MAX(init rexmit time,
1894721fffe3SKacheong Poon * tcp->tcp_rto)
1895721fffe3SKacheong Poon */
1896721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
1897721fffe3SKacheong Poon }
1898721fffe3SKacheong Poon break; /* success; too small */
1899721fffe3SKacheong Poon }
1900721fffe3SKacheong Poon }
1901721fffe3SKacheong Poon
1902721fffe3SKacheong Poon tcpha = tcp->tcp_tcpha;
1903721fffe3SKacheong Poon
1904721fffe3SKacheong Poon /*
1905721fffe3SKacheong Poon * The reason to adjust len here is that we need to set flags
1906721fffe3SKacheong Poon * and calculate checksum.
1907721fffe3SKacheong Poon */
1908721fffe3SKacheong Poon if (do_lso_send)
1909721fffe3SKacheong Poon len = lso_usable;
1910721fffe3SKacheong Poon
1911721fffe3SKacheong Poon *usable -= len; /* Approximate - can be adjusted later */
1912721fffe3SKacheong Poon if (*usable > 0)
1913721fffe3SKacheong Poon tcpha->tha_flags = TH_ACK;
1914721fffe3SKacheong Poon else
1915721fffe3SKacheong Poon tcpha->tha_flags = (TH_ACK | TH_PUSH);
1916721fffe3SKacheong Poon
1917721fffe3SKacheong Poon /*
1918721fffe3SKacheong Poon * Prime pump for IP's checksumming on our behalf.
1919721fffe3SKacheong Poon * Include the adjustment for a source route if any.
1920721fffe3SKacheong Poon * In case of LSO, the partial pseudo-header checksum should
1921721fffe3SKacheong Poon * exclusive TCP length, so zero tha_sum before IP calculate
1922721fffe3SKacheong Poon * pseudo-header checksum for partial checksum offload.
1923721fffe3SKacheong Poon */
1924721fffe3SKacheong Poon if (do_lso_send) {
1925721fffe3SKacheong Poon sum = 0;
1926721fffe3SKacheong Poon } else {
1927721fffe3SKacheong Poon sum = len + tcp_hdr_len + connp->conn_sum;
1928721fffe3SKacheong Poon sum = (sum >> 16) + (sum & 0xFFFF);
1929721fffe3SKacheong Poon }
1930721fffe3SKacheong Poon tcpha->tha_sum = htons(sum);
1931721fffe3SKacheong Poon tcpha->tha_seq = htonl(*snxt);
1932721fffe3SKacheong Poon
1933721fffe3SKacheong Poon /*
1934721fffe3SKacheong Poon * Branch off to tcp_xmit_mp() if any of the VALID bits is
1935*1edba515SAndy Fiddaman * set or if we have to add an MD5 signature option. For the
1936*1edba515SAndy Fiddaman * case when TCP_FSS_VALID is the only valid bit (normal active
1937*1edba515SAndy Fiddaman * close), branch off only when we think that the FIN flag
1938*1edba515SAndy Fiddaman * needs to be set. Note for this case, that (snxt + len) may
1939*1edba515SAndy Fiddaman * not reflect the actual seg_len, as len may be further
1940*1edba515SAndy Fiddaman * reduced in tcp_xmit_mp(). If len gets modified, we will end
1941*1edba515SAndy Fiddaman * up here again.
1942721fffe3SKacheong Poon */
1943*1edba515SAndy Fiddaman if (tcp->tcp_md5sig || (tcp->tcp_valid_bits != 0 &&
1944721fffe3SKacheong Poon (tcp->tcp_valid_bits != TCP_FSS_VALID ||
1945*1edba515SAndy Fiddaman *snxt + len == tcp->tcp_fss))) {
1946721fffe3SKacheong Poon uchar_t *prev_rptr;
1947721fffe3SKacheong Poon uint32_t prev_snxt = tcp->tcp_snxt;
1948721fffe3SKacheong Poon
1949721fffe3SKacheong Poon if (*tail_unsent == 0) {
1950721fffe3SKacheong Poon ASSERT((*xmit_tail)->b_cont != NULL);
1951721fffe3SKacheong Poon *xmit_tail = (*xmit_tail)->b_cont;
1952721fffe3SKacheong Poon prev_rptr = (*xmit_tail)->b_rptr;
1953721fffe3SKacheong Poon *tail_unsent = (int)((*xmit_tail)->b_wptr -
1954721fffe3SKacheong Poon (*xmit_tail)->b_rptr);
1955721fffe3SKacheong Poon } else {
1956721fffe3SKacheong Poon prev_rptr = (*xmit_tail)->b_rptr;
1957721fffe3SKacheong Poon (*xmit_tail)->b_rptr = (*xmit_tail)->b_wptr -
1958721fffe3SKacheong Poon *tail_unsent;
1959721fffe3SKacheong Poon }
1960721fffe3SKacheong Poon mp = tcp_xmit_mp(tcp, *xmit_tail, len, NULL, NULL,
1961721fffe3SKacheong Poon *snxt, B_FALSE, (uint32_t *)&len, B_FALSE);
1962721fffe3SKacheong Poon /* Restore tcp_snxt so we get amount sent right. */
1963721fffe3SKacheong Poon tcp->tcp_snxt = prev_snxt;
1964721fffe3SKacheong Poon if (prev_rptr == (*xmit_tail)->b_rptr) {
1965721fffe3SKacheong Poon /*
1966721fffe3SKacheong Poon * If the previous timestamp is still in use,
1967721fffe3SKacheong Poon * don't stomp on it.
1968721fffe3SKacheong Poon */
1969721fffe3SKacheong Poon if ((*xmit_tail)->b_next == NULL) {
1970721fffe3SKacheong Poon (*xmit_tail)->b_prev = local_time;
1971721fffe3SKacheong Poon (*xmit_tail)->b_next =
1972721fffe3SKacheong Poon (mblk_t *)(uintptr_t)(*snxt);
1973721fffe3SKacheong Poon }
1974721fffe3SKacheong Poon } else
1975721fffe3SKacheong Poon (*xmit_tail)->b_rptr = prev_rptr;
1976721fffe3SKacheong Poon
1977721fffe3SKacheong Poon if (mp == NULL) {
1978721fffe3SKacheong Poon return (-1);
1979721fffe3SKacheong Poon }
1980721fffe3SKacheong Poon mp1 = mp->b_cont;
1981721fffe3SKacheong Poon
1982721fffe3SKacheong Poon if (len <= mss) /* LSO is unusable (!do_lso_send) */
1983721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)len;
1984721fffe3SKacheong Poon while (mp1->b_cont) {
1985721fffe3SKacheong Poon *xmit_tail = (*xmit_tail)->b_cont;
1986721fffe3SKacheong Poon (*xmit_tail)->b_prev = local_time;
1987721fffe3SKacheong Poon (*xmit_tail)->b_next =
1988721fffe3SKacheong Poon (mblk_t *)(uintptr_t)(*snxt);
1989721fffe3SKacheong Poon mp1 = mp1->b_cont;
1990721fffe3SKacheong Poon }
1991721fffe3SKacheong Poon *snxt += len;
1992721fffe3SKacheong Poon *tail_unsent = (*xmit_tail)->b_wptr - mp1->b_wptr;
1993a2f04351SSebastien Roy TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
1994721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutDataSegs);
1995721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpOutDataBytes, len);
1996a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_segs++;
1997a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_bytes += len;
1998721fffe3SKacheong Poon tcp_send_data(tcp, mp);
1999721fffe3SKacheong Poon continue;
2000721fffe3SKacheong Poon }
2001721fffe3SKacheong Poon
2002721fffe3SKacheong Poon *snxt += len; /* Adjust later if we don't send all of len */
2003a2f04351SSebastien Roy TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
2004721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutDataSegs);
2005721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpOutDataBytes, len);
2006a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_segs++;
2007a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_bytes += len;
2008721fffe3SKacheong Poon
2009721fffe3SKacheong Poon if (*tail_unsent) {
2010721fffe3SKacheong Poon /* Are the bytes above us in flight? */
2011721fffe3SKacheong Poon rptr = (*xmit_tail)->b_wptr - *tail_unsent;
2012721fffe3SKacheong Poon if (rptr != (*xmit_tail)->b_rptr) {
2013721fffe3SKacheong Poon *tail_unsent -= len;
2014721fffe3SKacheong Poon if (len <= mss) /* LSO is unusable */
2015721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)len;
2016721fffe3SKacheong Poon len += total_hdr_len;
2017721fffe3SKacheong Poon ixa->ixa_pktlen = len;
2018721fffe3SKacheong Poon
2019721fffe3SKacheong Poon if (ixa->ixa_flags & IXAF_IS_IPV4) {
2020721fffe3SKacheong Poon tcp->tcp_ipha->ipha_length = htons(len);
2021721fffe3SKacheong Poon } else {
2022721fffe3SKacheong Poon tcp->tcp_ip6h->ip6_plen =
2023721fffe3SKacheong Poon htons(len - IPV6_HDR_LEN);
2024721fffe3SKacheong Poon }
2025721fffe3SKacheong Poon
2026721fffe3SKacheong Poon mp = dupb(*xmit_tail);
2027721fffe3SKacheong Poon if (mp == NULL) {
2028721fffe3SKacheong Poon return (-1); /* out_of_mem */
2029721fffe3SKacheong Poon }
2030721fffe3SKacheong Poon mp->b_rptr = rptr;
2031721fffe3SKacheong Poon /*
2032721fffe3SKacheong Poon * If the old timestamp is no longer in use,
2033721fffe3SKacheong Poon * sample a new timestamp now.
2034721fffe3SKacheong Poon */
2035721fffe3SKacheong Poon if ((*xmit_tail)->b_next == NULL) {
2036721fffe3SKacheong Poon (*xmit_tail)->b_prev = local_time;
2037721fffe3SKacheong Poon (*xmit_tail)->b_next =
2038721fffe3SKacheong Poon (mblk_t *)(uintptr_t)(*snxt-len);
2039721fffe3SKacheong Poon }
2040721fffe3SKacheong Poon goto must_alloc;
2041721fffe3SKacheong Poon }
2042721fffe3SKacheong Poon } else {
2043721fffe3SKacheong Poon *xmit_tail = (*xmit_tail)->b_cont;
2044721fffe3SKacheong Poon ASSERT((uintptr_t)((*xmit_tail)->b_wptr -
2045721fffe3SKacheong Poon (*xmit_tail)->b_rptr) <= (uintptr_t)INT_MAX);
2046721fffe3SKacheong Poon *tail_unsent = (int)((*xmit_tail)->b_wptr -
2047721fffe3SKacheong Poon (*xmit_tail)->b_rptr);
2048721fffe3SKacheong Poon }
2049721fffe3SKacheong Poon
2050721fffe3SKacheong Poon (*xmit_tail)->b_prev = local_time;
2051721fffe3SKacheong Poon (*xmit_tail)->b_next = (mblk_t *)(uintptr_t)(*snxt - len);
2052721fffe3SKacheong Poon
2053721fffe3SKacheong Poon *tail_unsent -= len;
2054721fffe3SKacheong Poon if (len <= mss) /* LSO is unusable (!do_lso_send) */
2055721fffe3SKacheong Poon tcp->tcp_last_sent_len = (ushort_t)len;
2056721fffe3SKacheong Poon
2057721fffe3SKacheong Poon len += total_hdr_len;
2058721fffe3SKacheong Poon ixa->ixa_pktlen = len;
2059721fffe3SKacheong Poon
2060721fffe3SKacheong Poon if (ixa->ixa_flags & IXAF_IS_IPV4) {
2061721fffe3SKacheong Poon tcp->tcp_ipha->ipha_length = htons(len);
2062721fffe3SKacheong Poon } else {
2063721fffe3SKacheong Poon tcp->tcp_ip6h->ip6_plen = htons(len - IPV6_HDR_LEN);
2064721fffe3SKacheong Poon }
2065721fffe3SKacheong Poon
2066721fffe3SKacheong Poon mp = dupb(*xmit_tail);
2067721fffe3SKacheong Poon if (mp == NULL) {
2068721fffe3SKacheong Poon return (-1); /* out_of_mem */
2069721fffe3SKacheong Poon }
2070721fffe3SKacheong Poon
2071721fffe3SKacheong Poon len = total_hdr_len;
2072721fffe3SKacheong Poon /*
2073721fffe3SKacheong Poon * There are four reasons to allocate a new hdr mblk:
2074721fffe3SKacheong Poon * 1) The bytes above us are in use by another packet
2075721fffe3SKacheong Poon * 2) We don't have good alignment
2076721fffe3SKacheong Poon * 3) The mblk is being shared
2077721fffe3SKacheong Poon * 4) We don't have enough room for a header
2078721fffe3SKacheong Poon */
2079721fffe3SKacheong Poon rptr = mp->b_rptr - len;
2080721fffe3SKacheong Poon if (!OK_32PTR(rptr) ||
2081721fffe3SKacheong Poon ((db = mp->b_datap), db->db_ref != 2) ||
2082721fffe3SKacheong Poon rptr < db->db_base) {
2083721fffe3SKacheong Poon /* NOTE: we assume allocb returns an OK_32PTR */
2084721fffe3SKacheong Poon
2085721fffe3SKacheong Poon must_alloc:;
2086721fffe3SKacheong Poon mp1 = allocb(connp->conn_ht_iphc_allocated +
2087721fffe3SKacheong Poon tcps->tcps_wroff_xtra, BPRI_MED);
2088721fffe3SKacheong Poon if (mp1 == NULL) {
2089721fffe3SKacheong Poon freemsg(mp);
2090721fffe3SKacheong Poon return (-1); /* out_of_mem */
2091721fffe3SKacheong Poon }
2092721fffe3SKacheong Poon mp1->b_cont = mp;
2093721fffe3SKacheong Poon mp = mp1;
2094721fffe3SKacheong Poon /* Leave room for Link Level header */
2095721fffe3SKacheong Poon len = total_hdr_len;
2096721fffe3SKacheong Poon rptr = &mp->b_rptr[tcps->tcps_wroff_xtra];
2097721fffe3SKacheong Poon mp->b_wptr = &rptr[len];
2098721fffe3SKacheong Poon }
2099721fffe3SKacheong Poon
2100721fffe3SKacheong Poon /*
2101721fffe3SKacheong Poon * Fill in the header using the template header, and add
2102721fffe3SKacheong Poon * options such as time-stamp, ECN and/or SACK, as needed.
2103721fffe3SKacheong Poon */
2104c12492cfSSebastien Roy tcp_fill_header(tcp, rptr, num_sack_blk);
2105721fffe3SKacheong Poon
2106721fffe3SKacheong Poon mp->b_rptr = rptr;
2107721fffe3SKacheong Poon
2108721fffe3SKacheong Poon if (*tail_unsent) {
2109721fffe3SKacheong Poon int spill = *tail_unsent;
2110721fffe3SKacheong Poon
2111721fffe3SKacheong Poon mp1 = mp->b_cont;
2112721fffe3SKacheong Poon if (mp1 == NULL)
2113721fffe3SKacheong Poon mp1 = mp;
2114721fffe3SKacheong Poon
2115721fffe3SKacheong Poon /*
2116721fffe3SKacheong Poon * If we're a little short, tack on more mblks until
2117721fffe3SKacheong Poon * there is no more spillover.
2118721fffe3SKacheong Poon */
2119721fffe3SKacheong Poon while (spill < 0) {
2120721fffe3SKacheong Poon mblk_t *nmp;
2121721fffe3SKacheong Poon int nmpsz;
2122721fffe3SKacheong Poon
2123721fffe3SKacheong Poon nmp = (*xmit_tail)->b_cont;
2124721fffe3SKacheong Poon nmpsz = MBLKL(nmp);
2125721fffe3SKacheong Poon
2126721fffe3SKacheong Poon /*
2127721fffe3SKacheong Poon * Excess data in mblk; can we split it?
2128721fffe3SKacheong Poon * If LSO is enabled for the connection,
2129721fffe3SKacheong Poon * keep on splitting as this is a transient
2130721fffe3SKacheong Poon * send path.
2131721fffe3SKacheong Poon */
2132721fffe3SKacheong Poon if (!do_lso_send && (spill + nmpsz > 0)) {
2133721fffe3SKacheong Poon /*
2134721fffe3SKacheong Poon * Don't split if stream head was
2135721fffe3SKacheong Poon * told to break up larger writes
2136721fffe3SKacheong Poon * into smaller ones.
2137721fffe3SKacheong Poon */
2138721fffe3SKacheong Poon if (tcp->tcp_maxpsz_multiplier > 0)
2139721fffe3SKacheong Poon break;
2140721fffe3SKacheong Poon
2141721fffe3SKacheong Poon /*
2142721fffe3SKacheong Poon * Next mblk is less than SMSS/2
2143721fffe3SKacheong Poon * rounded up to nearest 64-byte;
2144721fffe3SKacheong Poon * let it get sent as part of the
2145721fffe3SKacheong Poon * next segment.
2146721fffe3SKacheong Poon */
2147721fffe3SKacheong Poon if (tcp->tcp_localnet &&
2148721fffe3SKacheong Poon !tcp->tcp_cork &&
2149721fffe3SKacheong Poon (nmpsz < roundup((mss >> 1), 64)))
2150721fffe3SKacheong Poon break;
2151721fffe3SKacheong Poon }
2152721fffe3SKacheong Poon
2153721fffe3SKacheong Poon *xmit_tail = nmp;
2154721fffe3SKacheong Poon ASSERT((uintptr_t)nmpsz <= (uintptr_t)INT_MAX);
2155721fffe3SKacheong Poon /* Stash for rtt use later */
2156721fffe3SKacheong Poon (*xmit_tail)->b_prev = local_time;
2157721fffe3SKacheong Poon (*xmit_tail)->b_next =
2158721fffe3SKacheong Poon (mblk_t *)(uintptr_t)(*snxt - len);
2159721fffe3SKacheong Poon mp1->b_cont = dupb(*xmit_tail);
2160721fffe3SKacheong Poon mp1 = mp1->b_cont;
2161721fffe3SKacheong Poon
2162721fffe3SKacheong Poon spill += nmpsz;
2163721fffe3SKacheong Poon if (mp1 == NULL) {
2164721fffe3SKacheong Poon *tail_unsent = spill;
2165721fffe3SKacheong Poon freemsg(mp);
2166721fffe3SKacheong Poon return (-1); /* out_of_mem */
2167721fffe3SKacheong Poon }
2168721fffe3SKacheong Poon }
2169721fffe3SKacheong Poon
2170721fffe3SKacheong Poon /* Trim back any surplus on the last mblk */
2171721fffe3SKacheong Poon if (spill >= 0) {
2172721fffe3SKacheong Poon mp1->b_wptr -= spill;
2173721fffe3SKacheong Poon *tail_unsent = spill;
2174721fffe3SKacheong Poon } else {
2175721fffe3SKacheong Poon /*
2176721fffe3SKacheong Poon * We did not send everything we could in
2177721fffe3SKacheong Poon * order to remain within the b_cont limit.
2178721fffe3SKacheong Poon */
2179721fffe3SKacheong Poon *usable -= spill;
2180721fffe3SKacheong Poon *snxt += spill;
2181721fffe3SKacheong Poon tcp->tcp_last_sent_len += spill;
2182721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpOutDataBytes, spill);
2183a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_data_bytes += spill;
2184721fffe3SKacheong Poon /*
2185721fffe3SKacheong Poon * Adjust the checksum
2186721fffe3SKacheong Poon */
2187721fffe3SKacheong Poon tcpha = (tcpha_t *)(rptr +
2188721fffe3SKacheong Poon ixa->ixa_ip_hdr_length);
2189721fffe3SKacheong Poon sum += spill;
2190721fffe3SKacheong Poon sum = (sum >> 16) + (sum & 0xFFFF);
2191721fffe3SKacheong Poon tcpha->tha_sum = htons(sum);
2192721fffe3SKacheong Poon if (connp->conn_ipversion == IPV4_VERSION) {
2193721fffe3SKacheong Poon sum = ntohs(
2194721fffe3SKacheong Poon ((ipha_t *)rptr)->ipha_length) +
2195721fffe3SKacheong Poon spill;
2196721fffe3SKacheong Poon ((ipha_t *)rptr)->ipha_length =
2197721fffe3SKacheong Poon htons(sum);
2198721fffe3SKacheong Poon } else {
2199721fffe3SKacheong Poon sum = ntohs(
2200721fffe3SKacheong Poon ((ip6_t *)rptr)->ip6_plen) +
2201721fffe3SKacheong Poon spill;
2202721fffe3SKacheong Poon ((ip6_t *)rptr)->ip6_plen =
2203721fffe3SKacheong Poon htons(sum);
2204721fffe3SKacheong Poon }
2205721fffe3SKacheong Poon ixa->ixa_pktlen += spill;
2206721fffe3SKacheong Poon *tail_unsent = 0;
2207721fffe3SKacheong Poon }
2208721fffe3SKacheong Poon }
2209721fffe3SKacheong Poon if (tcp->tcp_ip_forward_progress) {
2210721fffe3SKacheong Poon tcp->tcp_ip_forward_progress = B_FALSE;
2211721fffe3SKacheong Poon ixa->ixa_flags |= IXAF_REACH_CONF;
2212721fffe3SKacheong Poon } else {
2213721fffe3SKacheong Poon ixa->ixa_flags &= ~IXAF_REACH_CONF;
2214721fffe3SKacheong Poon }
2215721fffe3SKacheong Poon
2216721fffe3SKacheong Poon if (do_lso_send) {
2217721fffe3SKacheong Poon /* Append LSO information to the mp. */
2218721fffe3SKacheong Poon lso_info_set(mp, mss, HW_LSO);
2219721fffe3SKacheong Poon ixa->ixa_fragsize = IP_MAXPACKET;
2220721fffe3SKacheong Poon ixa->ixa_extra_ident = num_lso_seg - 1;
2221721fffe3SKacheong Poon
2222721fffe3SKacheong Poon DTRACE_PROBE2(tcp_send_lso, int, num_lso_seg,
2223721fffe3SKacheong Poon boolean_t, B_TRUE);
2224721fffe3SKacheong Poon
2225721fffe3SKacheong Poon tcp_send_data(tcp, mp);
2226721fffe3SKacheong Poon
2227721fffe3SKacheong Poon /*
2228721fffe3SKacheong Poon * Restore values of ixa_fragsize and ixa_extra_ident.
2229721fffe3SKacheong Poon */
2230721fffe3SKacheong Poon ixa->ixa_fragsize = ixa->ixa_pmtu;
2231721fffe3SKacheong Poon ixa->ixa_extra_ident = 0;
2232a2f04351SSebastien Roy TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
2233721fffe3SKacheong Poon TCP_STAT(tcps, tcp_lso_times);
2234721fffe3SKacheong Poon TCP_STAT_UPDATE(tcps, tcp_lso_pkt_out, num_lso_seg);
2235721fffe3SKacheong Poon } else {
2236721fffe3SKacheong Poon /*
2237721fffe3SKacheong Poon * Make sure to clean up LSO information. Wherever a
2238721fffe3SKacheong Poon * new mp uses the prepended header room after dupb(),
2239721fffe3SKacheong Poon * lso_info_cleanup() should be called.
2240721fffe3SKacheong Poon */
2241721fffe3SKacheong Poon lso_info_cleanup(mp);
2242721fffe3SKacheong Poon tcp_send_data(tcp, mp);
2243a2f04351SSebastien Roy TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
2244721fffe3SKacheong Poon }
2245721fffe3SKacheong Poon }
2246721fffe3SKacheong Poon
2247721fffe3SKacheong Poon return (0);
2248721fffe3SKacheong Poon }
2249721fffe3SKacheong Poon
2250721fffe3SKacheong Poon /*
2251721fffe3SKacheong Poon * Initiate closedown sequence on an active connection. (May be called as
2252721fffe3SKacheong Poon * writer.) Return value zero for OK return, non-zero for error return.
2253721fffe3SKacheong Poon */
2254721fffe3SKacheong Poon static int
tcp_xmit_end(tcp_t * tcp)2255721fffe3SKacheong Poon tcp_xmit_end(tcp_t *tcp)
2256721fffe3SKacheong Poon {
2257721fffe3SKacheong Poon mblk_t *mp;
2258721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
2259721fffe3SKacheong Poon iulp_t uinfo;
2260721fffe3SKacheong Poon ip_stack_t *ipst = tcps->tcps_netstack->netstack_ip;
2261721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
2262721fffe3SKacheong Poon
2263721fffe3SKacheong Poon if (tcp->tcp_state < TCPS_SYN_RCVD ||
2264721fffe3SKacheong Poon tcp->tcp_state > TCPS_CLOSE_WAIT) {
2265721fffe3SKacheong Poon /*
2266721fffe3SKacheong Poon * Invalid state, only states TCPS_SYN_RCVD,
2267721fffe3SKacheong Poon * TCPS_ESTABLISHED and TCPS_CLOSE_WAIT are valid
2268721fffe3SKacheong Poon */
2269721fffe3SKacheong Poon return (-1);
2270721fffe3SKacheong Poon }
2271721fffe3SKacheong Poon
2272721fffe3SKacheong Poon tcp->tcp_fss = tcp->tcp_snxt + tcp->tcp_unsent;
2273721fffe3SKacheong Poon tcp->tcp_valid_bits |= TCP_FSS_VALID;
2274721fffe3SKacheong Poon /*
2275721fffe3SKacheong Poon * If there is nothing more unsent, send the FIN now.
2276721fffe3SKacheong Poon * Otherwise, it will go out with the last segment.
2277721fffe3SKacheong Poon */
2278721fffe3SKacheong Poon if (tcp->tcp_unsent == 0) {
2279721fffe3SKacheong Poon mp = tcp_xmit_mp(tcp, NULL, 0, NULL, NULL,
2280721fffe3SKacheong Poon tcp->tcp_fss, B_FALSE, NULL, B_FALSE);
2281721fffe3SKacheong Poon
2282721fffe3SKacheong Poon if (mp) {
2283721fffe3SKacheong Poon tcp_send_data(tcp, mp);
2284721fffe3SKacheong Poon } else {
2285721fffe3SKacheong Poon /*
2286721fffe3SKacheong Poon * Couldn't allocate msg. Pretend we got it out.
2287721fffe3SKacheong Poon * Wait for rexmit timeout.
2288721fffe3SKacheong Poon */
2289721fffe3SKacheong Poon tcp->tcp_snxt = tcp->tcp_fss + 1;
2290721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
2291721fffe3SKacheong Poon }
2292721fffe3SKacheong Poon
2293721fffe3SKacheong Poon /*
2294721fffe3SKacheong Poon * If needed, update tcp_rexmit_snxt as tcp_snxt is
2295721fffe3SKacheong Poon * changed.
2296721fffe3SKacheong Poon */
2297721fffe3SKacheong Poon if (tcp->tcp_rexmit && tcp->tcp_rexmit_nxt == tcp->tcp_fss) {
2298721fffe3SKacheong Poon tcp->tcp_rexmit_nxt = tcp->tcp_snxt;
2299721fffe3SKacheong Poon }
2300721fffe3SKacheong Poon } else {
2301721fffe3SKacheong Poon /*
2302721fffe3SKacheong Poon * If tcp->tcp_cork is set, then the data will not get sent,
2303721fffe3SKacheong Poon * so we have to check that and unset it first.
2304721fffe3SKacheong Poon */
2305721fffe3SKacheong Poon if (tcp->tcp_cork)
2306721fffe3SKacheong Poon tcp->tcp_cork = B_FALSE;
2307721fffe3SKacheong Poon tcp_wput_data(tcp, NULL, B_FALSE);
2308721fffe3SKacheong Poon }
2309721fffe3SKacheong Poon
2310721fffe3SKacheong Poon /*
2311721fffe3SKacheong Poon * If TCP does not get enough samples of RTT or tcp_rtt_updates
2312721fffe3SKacheong Poon * is 0, don't update the cache.
2313721fffe3SKacheong Poon */
2314721fffe3SKacheong Poon if (tcps->tcps_rtt_updates == 0 ||
2315721fffe3SKacheong Poon tcp->tcp_rtt_update < tcps->tcps_rtt_updates)
2316721fffe3SKacheong Poon return (0);
2317721fffe3SKacheong Poon
2318721fffe3SKacheong Poon /*
2319721fffe3SKacheong Poon * We do not have a good algorithm to update ssthresh at this time.
2320721fffe3SKacheong Poon * So don't do any update.
2321721fffe3SKacheong Poon */
2322721fffe3SKacheong Poon bzero(&uinfo, sizeof (uinfo));
2323c12492cfSSebastien Roy uinfo.iulp_rtt = NSEC2MSEC(tcp->tcp_rtt_sa);
2324c12492cfSSebastien Roy uinfo.iulp_rtt_sd = NSEC2MSEC(tcp->tcp_rtt_sd);
2325721fffe3SKacheong Poon
2326721fffe3SKacheong Poon /*
2327721fffe3SKacheong Poon * Note that uinfo is kept for conn_faddr in the DCE. Could update even
2328721fffe3SKacheong Poon * if source routed but we don't.
2329721fffe3SKacheong Poon */
2330721fffe3SKacheong Poon if (connp->conn_ipversion == IPV4_VERSION) {
2331721fffe3SKacheong Poon if (connp->conn_faddr_v4 != tcp->tcp_ipha->ipha_dst) {
2332721fffe3SKacheong Poon return (0);
2333721fffe3SKacheong Poon }
2334721fffe3SKacheong Poon (void) dce_update_uinfo_v4(connp->conn_faddr_v4, &uinfo, ipst);
2335721fffe3SKacheong Poon } else {
2336721fffe3SKacheong Poon uint_t ifindex;
2337721fffe3SKacheong Poon
2338721fffe3SKacheong Poon if (!(IN6_ARE_ADDR_EQUAL(&connp->conn_faddr_v6,
2339721fffe3SKacheong Poon &tcp->tcp_ip6h->ip6_dst))) {
2340721fffe3SKacheong Poon return (0);
2341721fffe3SKacheong Poon }
2342721fffe3SKacheong Poon ifindex = 0;
2343721fffe3SKacheong Poon if (IN6_IS_ADDR_LINKSCOPE(&connp->conn_faddr_v6)) {
2344721fffe3SKacheong Poon ip_xmit_attr_t *ixa = connp->conn_ixa;
2345721fffe3SKacheong Poon
2346721fffe3SKacheong Poon /*
2347721fffe3SKacheong Poon * If we are going to create a DCE we'd better have
2348721fffe3SKacheong Poon * an ifindex
2349721fffe3SKacheong Poon */
2350721fffe3SKacheong Poon if (ixa->ixa_nce != NULL) {
2351721fffe3SKacheong Poon ifindex = ixa->ixa_nce->nce_common->ncec_ill->
2352721fffe3SKacheong Poon ill_phyint->phyint_ifindex;
2353721fffe3SKacheong Poon } else {
2354721fffe3SKacheong Poon return (0);
2355721fffe3SKacheong Poon }
2356721fffe3SKacheong Poon }
2357721fffe3SKacheong Poon
2358721fffe3SKacheong Poon (void) dce_update_uinfo(&connp->conn_faddr_v6, ifindex, &uinfo,
2359721fffe3SKacheong Poon ipst);
2360721fffe3SKacheong Poon }
2361721fffe3SKacheong Poon return (0);
2362721fffe3SKacheong Poon }
2363721fffe3SKacheong Poon
2364721fffe3SKacheong Poon /*
2365721fffe3SKacheong Poon * Send out a control packet on the tcp connection specified. This routine
2366721fffe3SKacheong Poon * is typically called where we need a simple ACK or RST generated.
2367721fffe3SKacheong Poon */
2368721fffe3SKacheong Poon void
tcp_xmit_ctl(char * str,tcp_t * tcp,uint32_t seq,uint32_t ack,int ctl)2369721fffe3SKacheong Poon tcp_xmit_ctl(char *str, tcp_t *tcp, uint32_t seq, uint32_t ack, int ctl)
2370721fffe3SKacheong Poon {
2371721fffe3SKacheong Poon uchar_t *rptr;
2372721fffe3SKacheong Poon tcpha_t *tcpha;
2373721fffe3SKacheong Poon ipha_t *ipha = NULL;
2374721fffe3SKacheong Poon ip6_t *ip6h = NULL;
2375721fffe3SKacheong Poon uint32_t sum;
2376721fffe3SKacheong Poon int total_hdr_len;
2377721fffe3SKacheong Poon int ip_hdr_len;
2378721fffe3SKacheong Poon mblk_t *mp;
2379721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
2380721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
2381721fffe3SKacheong Poon ip_xmit_attr_t *ixa = connp->conn_ixa;
2382721fffe3SKacheong Poon
2383721fffe3SKacheong Poon /*
2384721fffe3SKacheong Poon * Save sum for use in source route later.
2385721fffe3SKacheong Poon */
2386721fffe3SKacheong Poon sum = connp->conn_ht_ulp_len + connp->conn_sum;
2387721fffe3SKacheong Poon total_hdr_len = connp->conn_ht_iphc_len;
2388721fffe3SKacheong Poon ip_hdr_len = ixa->ixa_ip_hdr_length;
2389721fffe3SKacheong Poon
2390721fffe3SKacheong Poon /* If a text string is passed in with the request, pass it to strlog. */
2391721fffe3SKacheong Poon if (str != NULL && connp->conn_debug) {
2392721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1, SL_TRACE,
2393721fffe3SKacheong Poon "tcp_xmit_ctl: '%s', seq 0x%x, ack 0x%x, ctl 0x%x",
2394721fffe3SKacheong Poon str, seq, ack, ctl);
2395721fffe3SKacheong Poon }
2396721fffe3SKacheong Poon mp = allocb(connp->conn_ht_iphc_allocated + tcps->tcps_wroff_xtra,
2397721fffe3SKacheong Poon BPRI_MED);
2398721fffe3SKacheong Poon if (mp == NULL) {
2399721fffe3SKacheong Poon return;
2400721fffe3SKacheong Poon }
2401721fffe3SKacheong Poon rptr = &mp->b_rptr[tcps->tcps_wroff_xtra];
2402721fffe3SKacheong Poon mp->b_rptr = rptr;
2403721fffe3SKacheong Poon mp->b_wptr = &rptr[total_hdr_len];
2404721fffe3SKacheong Poon bcopy(connp->conn_ht_iphc, rptr, total_hdr_len);
2405721fffe3SKacheong Poon
2406721fffe3SKacheong Poon ixa->ixa_pktlen = total_hdr_len;
2407721fffe3SKacheong Poon
2408721fffe3SKacheong Poon if (ixa->ixa_flags & IXAF_IS_IPV4) {
2409721fffe3SKacheong Poon ipha = (ipha_t *)rptr;
2410721fffe3SKacheong Poon ipha->ipha_length = htons(total_hdr_len);
2411721fffe3SKacheong Poon } else {
2412721fffe3SKacheong Poon ip6h = (ip6_t *)rptr;
2413721fffe3SKacheong Poon ip6h->ip6_plen = htons(total_hdr_len - IPV6_HDR_LEN);
2414721fffe3SKacheong Poon }
2415721fffe3SKacheong Poon tcpha = (tcpha_t *)&rptr[ip_hdr_len];
2416721fffe3SKacheong Poon tcpha->tha_flags = (uint8_t)ctl;
2417721fffe3SKacheong Poon if (ctl & TH_RST) {
2418721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutRsts);
2419721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutControl);
2420721fffe3SKacheong Poon /*
2421721fffe3SKacheong Poon * Don't send TSopt w/ TH_RST packets per RFC 1323.
2422721fffe3SKacheong Poon */
2423721fffe3SKacheong Poon if (tcp->tcp_snd_ts_ok &&
2424721fffe3SKacheong Poon tcp->tcp_state > TCPS_SYN_SENT) {
2425721fffe3SKacheong Poon mp->b_wptr = &rptr[total_hdr_len - TCPOPT_REAL_TS_LEN];
2426721fffe3SKacheong Poon *(mp->b_wptr) = TCPOPT_EOL;
2427721fffe3SKacheong Poon
2428721fffe3SKacheong Poon ixa->ixa_pktlen = total_hdr_len - TCPOPT_REAL_TS_LEN;
2429721fffe3SKacheong Poon
2430721fffe3SKacheong Poon if (connp->conn_ipversion == IPV4_VERSION) {
2431721fffe3SKacheong Poon ipha->ipha_length = htons(total_hdr_len -
2432721fffe3SKacheong Poon TCPOPT_REAL_TS_LEN);
2433721fffe3SKacheong Poon } else {
2434721fffe3SKacheong Poon ip6h->ip6_plen = htons(total_hdr_len -
2435721fffe3SKacheong Poon IPV6_HDR_LEN - TCPOPT_REAL_TS_LEN);
2436721fffe3SKacheong Poon }
2437721fffe3SKacheong Poon tcpha->tha_offset_and_reserved -= (3 << 4);
2438721fffe3SKacheong Poon sum -= TCPOPT_REAL_TS_LEN;
2439721fffe3SKacheong Poon }
2440721fffe3SKacheong Poon }
2441721fffe3SKacheong Poon if (ctl & TH_ACK) {
2442721fffe3SKacheong Poon if (tcp->tcp_snd_ts_ok) {
2443721fffe3SKacheong Poon uint32_t llbolt = (uint32_t)LBOLT_FASTPATH;
2444721fffe3SKacheong Poon
2445721fffe3SKacheong Poon U32_TO_BE32(llbolt,
2446721fffe3SKacheong Poon (char *)tcpha + TCP_MIN_HEADER_LENGTH+4);
2447721fffe3SKacheong Poon U32_TO_BE32(tcp->tcp_ts_recent,
2448721fffe3SKacheong Poon (char *)tcpha + TCP_MIN_HEADER_LENGTH+8);
2449721fffe3SKacheong Poon }
2450721fffe3SKacheong Poon
2451721fffe3SKacheong Poon /* Update the latest receive window size in TCP header. */
2452721fffe3SKacheong Poon tcpha->tha_win = htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
2453721fffe3SKacheong Poon /* Track what we sent to the peer */
2454721fffe3SKacheong Poon tcp->tcp_tcpha->tha_win = tcpha->tha_win;
2455721fffe3SKacheong Poon tcp->tcp_rack = ack;
2456721fffe3SKacheong Poon tcp->tcp_rack_cnt = 0;
2457721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutAck);
2458721fffe3SKacheong Poon }
2459*1edba515SAndy Fiddaman
2460721fffe3SKacheong Poon tcpha->tha_seq = htonl(seq);
2461721fffe3SKacheong Poon tcpha->tha_ack = htonl(ack);
2462*1edba515SAndy Fiddaman
2463*1edba515SAndy Fiddaman if (tcp->tcp_md5sig) {
2464*1edba515SAndy Fiddaman uint8_t digest[MD5_DIGEST_LENGTH];
2465*1edba515SAndy Fiddaman int tcplen = (int)(mp->b_wptr - rptr) +
2466*1edba515SAndy Fiddaman TCPOPT_REAL_MD5_LEN - ip_hdr_len;
2467*1edba515SAndy Fiddaman
2468*1edba515SAndy Fiddaman if (tcpsig_signature(mp->b_cont, tcp, tcpha, tcplen, digest,
2469*1edba515SAndy Fiddaman false)) {
2470*1edba515SAndy Fiddaman uint8_t *wptr = mp->b_wptr;
2471*1edba515SAndy Fiddaman
2472*1edba515SAndy Fiddaman wptr[0] = TCPOPT_NOP;
2473*1edba515SAndy Fiddaman wptr[1] = TCPOPT_NOP;
2474*1edba515SAndy Fiddaman wptr[2] = TCPOPT_MD5;
2475*1edba515SAndy Fiddaman wptr[3] = TCPOPT_MD5_LEN;
2476*1edba515SAndy Fiddaman bcopy(digest, &wptr[4], sizeof (digest));
2477*1edba515SAndy Fiddaman
2478*1edba515SAndy Fiddaman tcpha->tha_offset_and_reserved += (5 << 4);
2479*1edba515SAndy Fiddaman mp->b_wptr += TCPOPT_REAL_MD5_LEN;
2480*1edba515SAndy Fiddaman ixa->ixa_pktlen += TCPOPT_REAL_MD5_LEN;
2481*1edba515SAndy Fiddaman if (ixa->ixa_flags & IXAF_IS_IPV4) {
2482*1edba515SAndy Fiddaman ipha->ipha_length = htons(ntohs(
2483*1edba515SAndy Fiddaman ipha->ipha_length) + TCPOPT_REAL_MD5_LEN);
2484*1edba515SAndy Fiddaman } else {
2485*1edba515SAndy Fiddaman ip6h->ip6_plen = htons(ntohs(ip6h->ip6_plen) +
2486*1edba515SAndy Fiddaman TCPOPT_REAL_MD5_LEN);
2487*1edba515SAndy Fiddaman }
2488*1edba515SAndy Fiddaman } else {
2489*1edba515SAndy Fiddaman /* Silently drop the packet */
2490*1edba515SAndy Fiddaman freemsg(mp);
2491*1edba515SAndy Fiddaman return;
2492*1edba515SAndy Fiddaman }
2493*1edba515SAndy Fiddaman }
2494*1edba515SAndy Fiddaman
2495*1edba515SAndy Fiddaman TCPS_BUMP_MIB(tcps, tcpHCOutSegs);
2496721fffe3SKacheong Poon /*
2497721fffe3SKacheong Poon * Include the adjustment for a source route if any.
2498721fffe3SKacheong Poon */
2499721fffe3SKacheong Poon sum = (sum >> 16) + (sum & 0xFFFF);
2500721fffe3SKacheong Poon tcpha->tha_sum = htons(sum);
2501721fffe3SKacheong Poon tcp_send_data(tcp, mp);
2502721fffe3SKacheong Poon }
2503721fffe3SKacheong Poon
2504721fffe3SKacheong Poon /*
2505721fffe3SKacheong Poon * Generate a reset based on an inbound packet, connp is set by caller
2506721fffe3SKacheong Poon * when RST is in response to an unexpected inbound packet for which
2507721fffe3SKacheong Poon * there is active tcp state in the system.
2508721fffe3SKacheong Poon *
2509721fffe3SKacheong Poon * IPSEC NOTE : Try to send the reply with the same protection as it came
2510721fffe3SKacheong Poon * in. We have the ip_recv_attr_t which is reversed to form the ip_xmit_attr_t.
2511721fffe3SKacheong Poon * That way the packet will go out at the same level of protection as it
2512721fffe3SKacheong Poon * came in with.
2513721fffe3SKacheong Poon */
2514721fffe3SKacheong Poon static void
tcp_xmit_early_reset(char * str,mblk_t * mp,uint32_t seq,uint32_t ack,int ctl,ip_recv_attr_t * ira,ip_stack_t * ipst,conn_t * connp)2515721fffe3SKacheong Poon tcp_xmit_early_reset(char *str, mblk_t *mp, uint32_t seq, uint32_t ack, int ctl,
2516721fffe3SKacheong Poon ip_recv_attr_t *ira, ip_stack_t *ipst, conn_t *connp)
2517721fffe3SKacheong Poon {
2518721fffe3SKacheong Poon ipha_t *ipha = NULL;
2519721fffe3SKacheong Poon ip6_t *ip6h = NULL;
2520721fffe3SKacheong Poon ushort_t len;
2521721fffe3SKacheong Poon tcpha_t *tcpha;
2522721fffe3SKacheong Poon int i;
2523721fffe3SKacheong Poon ipaddr_t v4addr;
2524721fffe3SKacheong Poon in6_addr_t v6addr;
2525721fffe3SKacheong Poon netstack_t *ns = ipst->ips_netstack;
2526721fffe3SKacheong Poon tcp_stack_t *tcps = ns->netstack_tcp;
2527721fffe3SKacheong Poon ip_xmit_attr_t ixas, *ixa;
2528721fffe3SKacheong Poon uint_t ip_hdr_len = ira->ira_ip_hdr_length;
2529721fffe3SKacheong Poon boolean_t need_refrele = B_FALSE; /* ixa_refrele(ixa) */
2530721fffe3SKacheong Poon ushort_t port;
2531721fffe3SKacheong Poon
2532721fffe3SKacheong Poon if (!tcp_send_rst_chk(tcps)) {
2533721fffe3SKacheong Poon TCP_STAT(tcps, tcp_rst_unsent);
2534721fffe3SKacheong Poon freemsg(mp);
2535721fffe3SKacheong Poon return;
2536721fffe3SKacheong Poon }
2537721fffe3SKacheong Poon
2538721fffe3SKacheong Poon /*
2539721fffe3SKacheong Poon * If connp != NULL we use conn_ixa to keep IP_NEXTHOP and other
2540721fffe3SKacheong Poon * options from the listener. In that case the caller must ensure that
2541721fffe3SKacheong Poon * we are running on the listener = connp squeue.
2542721fffe3SKacheong Poon *
2543721fffe3SKacheong Poon * We get a safe copy of conn_ixa so we don't need to restore anything
2544721fffe3SKacheong Poon * we or ip_output_simple might change in the ixa.
2545721fffe3SKacheong Poon */
2546721fffe3SKacheong Poon if (connp != NULL) {
2547721fffe3SKacheong Poon ASSERT(connp->conn_on_sqp);
2548721fffe3SKacheong Poon
2549721fffe3SKacheong Poon ixa = conn_get_ixa_exclusive(connp);
2550721fffe3SKacheong Poon if (ixa == NULL) {
2551721fffe3SKacheong Poon TCP_STAT(tcps, tcp_rst_unsent);
2552721fffe3SKacheong Poon freemsg(mp);
2553721fffe3SKacheong Poon return;
2554721fffe3SKacheong Poon }
2555721fffe3SKacheong Poon need_refrele = B_TRUE;
2556721fffe3SKacheong Poon } else {
2557721fffe3SKacheong Poon bzero(&ixas, sizeof (ixas));
2558721fffe3SKacheong Poon ixa = &ixas;
2559721fffe3SKacheong Poon /*
2560721fffe3SKacheong Poon * IXAF_VERIFY_SOURCE is overkill since we know the
2561721fffe3SKacheong Poon * packet was for us.
2562721fffe3SKacheong Poon */
2563721fffe3SKacheong Poon ixa->ixa_flags |= IXAF_SET_ULP_CKSUM | IXAF_VERIFY_SOURCE;
2564721fffe3SKacheong Poon ixa->ixa_protocol = IPPROTO_TCP;
2565721fffe3SKacheong Poon ixa->ixa_zoneid = ira->ira_zoneid;
2566721fffe3SKacheong Poon ixa->ixa_ifindex = 0;
2567721fffe3SKacheong Poon ixa->ixa_ipst = ipst;
2568721fffe3SKacheong Poon ixa->ixa_cred = kcred;
2569721fffe3SKacheong Poon ixa->ixa_cpid = NOPID;
2570721fffe3SKacheong Poon }
2571721fffe3SKacheong Poon
2572721fffe3SKacheong Poon if (str && tcps->tcps_dbg) {
2573721fffe3SKacheong Poon (void) strlog(TCP_MOD_ID, 0, 1, SL_TRACE,
2574721fffe3SKacheong Poon "tcp_xmit_early_reset: '%s', seq 0x%x, ack 0x%x, "
2575721fffe3SKacheong Poon "flags 0x%x",
2576721fffe3SKacheong Poon str, seq, ack, ctl);
2577721fffe3SKacheong Poon }
2578721fffe3SKacheong Poon if (mp->b_datap->db_ref != 1) {
2579721fffe3SKacheong Poon mblk_t *mp1 = copyb(mp);
2580721fffe3SKacheong Poon freemsg(mp);
2581721fffe3SKacheong Poon mp = mp1;
2582721fffe3SKacheong Poon if (mp == NULL)
2583721fffe3SKacheong Poon goto done;
2584721fffe3SKacheong Poon } else if (mp->b_cont) {
2585721fffe3SKacheong Poon freemsg(mp->b_cont);
2586721fffe3SKacheong Poon mp->b_cont = NULL;
2587721fffe3SKacheong Poon DB_CKSUMFLAGS(mp) = 0;
2588721fffe3SKacheong Poon }
2589721fffe3SKacheong Poon /*
2590721fffe3SKacheong Poon * We skip reversing source route here.
2591721fffe3SKacheong Poon * (for now we replace all IP options with EOL)
2592721fffe3SKacheong Poon */
2593721fffe3SKacheong Poon if (IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION) {
2594721fffe3SKacheong Poon ipha = (ipha_t *)mp->b_rptr;
2595721fffe3SKacheong Poon for (i = IP_SIMPLE_HDR_LENGTH; i < (int)ip_hdr_len; i++)
2596721fffe3SKacheong Poon mp->b_rptr[i] = IPOPT_EOL;
2597721fffe3SKacheong Poon /*
2598721fffe3SKacheong Poon * Make sure that src address isn't flagrantly invalid.
2599721fffe3SKacheong Poon * Not all broadcast address checking for the src address
2600721fffe3SKacheong Poon * is possible, since we don't know the netmask of the src
2601721fffe3SKacheong Poon * addr. No check for destination address is done, since
2602721fffe3SKacheong Poon * IP will not pass up a packet with a broadcast dest
2603721fffe3SKacheong Poon * address to TCP. Similar checks are done below for IPv6.
2604721fffe3SKacheong Poon */
2605721fffe3SKacheong Poon if (ipha->ipha_src == 0 || ipha->ipha_src == INADDR_BROADCAST ||
2606721fffe3SKacheong Poon CLASSD(ipha->ipha_src)) {
2607721fffe3SKacheong Poon BUMP_MIB(&ipst->ips_ip_mib, ipIfStatsInDiscards);
2608721fffe3SKacheong Poon ip_drop_input("ipIfStatsInDiscards", mp, NULL);
2609721fffe3SKacheong Poon freemsg(mp);
2610721fffe3SKacheong Poon goto done;
2611721fffe3SKacheong Poon }
2612721fffe3SKacheong Poon } else {
2613721fffe3SKacheong Poon ip6h = (ip6_t *)mp->b_rptr;
2614721fffe3SKacheong Poon
2615721fffe3SKacheong Poon if (IN6_IS_ADDR_UNSPECIFIED(&ip6h->ip6_src) ||
2616721fffe3SKacheong Poon IN6_IS_ADDR_MULTICAST(&ip6h->ip6_src)) {
2617721fffe3SKacheong Poon BUMP_MIB(&ipst->ips_ip6_mib, ipIfStatsInDiscards);
2618721fffe3SKacheong Poon ip_drop_input("ipIfStatsInDiscards", mp, NULL);
2619721fffe3SKacheong Poon freemsg(mp);
2620721fffe3SKacheong Poon goto done;
2621721fffe3SKacheong Poon }
2622721fffe3SKacheong Poon
2623721fffe3SKacheong Poon /* Remove any extension headers assuming partial overlay */
2624721fffe3SKacheong Poon if (ip_hdr_len > IPV6_HDR_LEN) {
2625721fffe3SKacheong Poon uint8_t *to;
2626721fffe3SKacheong Poon
2627721fffe3SKacheong Poon to = mp->b_rptr + ip_hdr_len - IPV6_HDR_LEN;
2628721fffe3SKacheong Poon ovbcopy(ip6h, to, IPV6_HDR_LEN);
2629721fffe3SKacheong Poon mp->b_rptr += ip_hdr_len - IPV6_HDR_LEN;
2630721fffe3SKacheong Poon ip_hdr_len = IPV6_HDR_LEN;
2631721fffe3SKacheong Poon ip6h = (ip6_t *)mp->b_rptr;
2632721fffe3SKacheong Poon ip6h->ip6_nxt = IPPROTO_TCP;
2633721fffe3SKacheong Poon }
2634721fffe3SKacheong Poon }
2635721fffe3SKacheong Poon tcpha = (tcpha_t *)&mp->b_rptr[ip_hdr_len];
2636721fffe3SKacheong Poon if (tcpha->tha_flags & TH_RST) {
2637721fffe3SKacheong Poon freemsg(mp);
2638721fffe3SKacheong Poon goto done;
2639721fffe3SKacheong Poon }
2640721fffe3SKacheong Poon tcpha->tha_offset_and_reserved = (5 << 4);
2641721fffe3SKacheong Poon len = ip_hdr_len + sizeof (tcpha_t);
2642721fffe3SKacheong Poon mp->b_wptr = &mp->b_rptr[len];
2643721fffe3SKacheong Poon if (IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION) {
2644721fffe3SKacheong Poon ipha->ipha_length = htons(len);
2645721fffe3SKacheong Poon /* Swap addresses */
2646721fffe3SKacheong Poon v4addr = ipha->ipha_src;
2647721fffe3SKacheong Poon ipha->ipha_src = ipha->ipha_dst;
2648721fffe3SKacheong Poon ipha->ipha_dst = v4addr;
2649721fffe3SKacheong Poon ipha->ipha_ident = 0;
2650721fffe3SKacheong Poon ipha->ipha_ttl = (uchar_t)tcps->tcps_ipv4_ttl;
2651721fffe3SKacheong Poon ixa->ixa_flags |= IXAF_IS_IPV4;
2652721fffe3SKacheong Poon ixa->ixa_ip_hdr_length = ip_hdr_len;
2653721fffe3SKacheong Poon } else {
2654721fffe3SKacheong Poon ip6h->ip6_plen = htons(len - IPV6_HDR_LEN);
2655721fffe3SKacheong Poon /* Swap addresses */
2656721fffe3SKacheong Poon v6addr = ip6h->ip6_src;
2657721fffe3SKacheong Poon ip6h->ip6_src = ip6h->ip6_dst;
2658721fffe3SKacheong Poon ip6h->ip6_dst = v6addr;
2659721fffe3SKacheong Poon ip6h->ip6_hops = (uchar_t)tcps->tcps_ipv6_hoplimit;
2660721fffe3SKacheong Poon ixa->ixa_flags &= ~IXAF_IS_IPV4;
2661721fffe3SKacheong Poon
2662721fffe3SKacheong Poon if (IN6_IS_ADDR_LINKSCOPE(&ip6h->ip6_dst)) {
2663721fffe3SKacheong Poon ixa->ixa_flags |= IXAF_SCOPEID_SET;
2664721fffe3SKacheong Poon ixa->ixa_scopeid = ira->ira_ruifindex;
2665721fffe3SKacheong Poon }
2666721fffe3SKacheong Poon ixa->ixa_ip_hdr_length = IPV6_HDR_LEN;
2667721fffe3SKacheong Poon }
2668721fffe3SKacheong Poon ixa->ixa_pktlen = len;
2669721fffe3SKacheong Poon
2670721fffe3SKacheong Poon /* Swap the ports */
2671721fffe3SKacheong Poon port = tcpha->tha_fport;
2672721fffe3SKacheong Poon tcpha->tha_fport = tcpha->tha_lport;
2673721fffe3SKacheong Poon tcpha->tha_lport = port;
2674721fffe3SKacheong Poon
2675721fffe3SKacheong Poon tcpha->tha_ack = htonl(ack);
2676721fffe3SKacheong Poon tcpha->tha_seq = htonl(seq);
2677721fffe3SKacheong Poon tcpha->tha_win = 0;
2678721fffe3SKacheong Poon tcpha->tha_sum = htons(sizeof (tcpha_t));
2679721fffe3SKacheong Poon tcpha->tha_flags = (uint8_t)ctl;
2680721fffe3SKacheong Poon if (ctl & TH_RST) {
26819cd928feSAlan Maguire if (ctl & TH_ACK) {
26829cd928feSAlan Maguire /*
26839cd928feSAlan Maguire * Probe connection rejection here.
26849cd928feSAlan Maguire * tcp_xmit_listeners_reset() drops non-SYN segments
26859cd928feSAlan Maguire * that do not specify TH_ACK in their flags without
26869cd928feSAlan Maguire * calling this function. As a consequence, if this
26879cd928feSAlan Maguire * function is called with a TH_RST|TH_ACK ctl argument,
26889cd928feSAlan Maguire * it is being called in response to a SYN segment
26899cd928feSAlan Maguire * and thus the tcp:::accept-refused probe point
26909cd928feSAlan Maguire * is valid here.
26919cd928feSAlan Maguire */
26929cd928feSAlan Maguire DTRACE_TCP5(accept__refused, mblk_t *, NULL,
26939cd928feSAlan Maguire void, NULL, void_ip_t *, mp->b_rptr, tcp_t *, NULL,
26949cd928feSAlan Maguire tcph_t *, tcpha);
26959cd928feSAlan Maguire }
2696721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutRsts);
2697721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutControl);
2698721fffe3SKacheong Poon }
2699721fffe3SKacheong Poon
2700721fffe3SKacheong Poon /* Discard any old label */
2701721fffe3SKacheong Poon if (ixa->ixa_free_flags & IXA_FREE_TSL) {
2702721fffe3SKacheong Poon ASSERT(ixa->ixa_tsl != NULL);
2703721fffe3SKacheong Poon label_rele(ixa->ixa_tsl);
2704721fffe3SKacheong Poon ixa->ixa_free_flags &= ~IXA_FREE_TSL;
2705721fffe3SKacheong Poon }
2706721fffe3SKacheong Poon ixa->ixa_tsl = ira->ira_tsl; /* Behave as a multi-level responder */
2707721fffe3SKacheong Poon
2708721fffe3SKacheong Poon if (ira->ira_flags & IRAF_IPSEC_SECURE) {
2709721fffe3SKacheong Poon /*
2710721fffe3SKacheong Poon * Apply IPsec based on how IPsec was applied to
2711721fffe3SKacheong Poon * the packet that caused the RST.
2712721fffe3SKacheong Poon */
2713721fffe3SKacheong Poon if (!ipsec_in_to_out(ira, ixa, mp, ipha, ip6h)) {
2714721fffe3SKacheong Poon BUMP_MIB(&ipst->ips_ip_mib, ipIfStatsOutDiscards);
2715721fffe3SKacheong Poon /* Note: mp already consumed and ip_drop_packet done */
2716721fffe3SKacheong Poon goto done;
2717721fffe3SKacheong Poon }
2718721fffe3SKacheong Poon } else {
2719721fffe3SKacheong Poon /*
2720721fffe3SKacheong Poon * This is in clear. The RST message we are building
2721721fffe3SKacheong Poon * here should go out in clear, independent of our policy.
2722721fffe3SKacheong Poon */
2723721fffe3SKacheong Poon ixa->ixa_flags |= IXAF_NO_IPSEC;
2724721fffe3SKacheong Poon }
2725721fffe3SKacheong Poon
27269cd928feSAlan Maguire DTRACE_TCP5(send, mblk_t *, NULL, ip_xmit_attr_t *, ixa,
27279cd928feSAlan Maguire __dtrace_tcp_void_ip_t *, mp->b_rptr, tcp_t *, NULL,
27289cd928feSAlan Maguire __dtrace_tcp_tcph_t *, tcpha);
27299cd928feSAlan Maguire
2730721fffe3SKacheong Poon /*
2731721fffe3SKacheong Poon * NOTE: one might consider tracing a TCP packet here, but
2732721fffe3SKacheong Poon * this function has no active TCP state and no tcp structure
2733721fffe3SKacheong Poon * that has a trace buffer. If we traced here, we would have
2734721fffe3SKacheong Poon * to keep a local trace buffer in tcp_record_trace().
2735721fffe3SKacheong Poon */
2736721fffe3SKacheong Poon
2737721fffe3SKacheong Poon (void) ip_output_simple(mp, ixa);
2738721fffe3SKacheong Poon done:
2739721fffe3SKacheong Poon ixa_cleanup(ixa);
2740721fffe3SKacheong Poon if (need_refrele) {
2741721fffe3SKacheong Poon ASSERT(ixa != &ixas);
2742721fffe3SKacheong Poon ixa_refrele(ixa);
2743721fffe3SKacheong Poon }
2744721fffe3SKacheong Poon }
2745721fffe3SKacheong Poon
2746721fffe3SKacheong Poon /*
2747721fffe3SKacheong Poon * Generate a "no listener here" RST in response to an "unknown" segment.
2748721fffe3SKacheong Poon * connp is set by caller when RST is in response to an unexpected
2749721fffe3SKacheong Poon * inbound packet for which there is active tcp state in the system.
2750721fffe3SKacheong Poon * Note that we are reusing the incoming mp to construct the outgoing RST.
2751721fffe3SKacheong Poon */
2752721fffe3SKacheong Poon void
tcp_xmit_listeners_reset(mblk_t * mp,ip_recv_attr_t * ira,ip_stack_t * ipst,conn_t * connp)2753721fffe3SKacheong Poon tcp_xmit_listeners_reset(mblk_t *mp, ip_recv_attr_t *ira, ip_stack_t *ipst,
2754721fffe3SKacheong Poon conn_t *connp)
2755721fffe3SKacheong Poon {
2756721fffe3SKacheong Poon uchar_t *rptr;
2757721fffe3SKacheong Poon uint32_t seg_len;
2758721fffe3SKacheong Poon tcpha_t *tcpha;
2759721fffe3SKacheong Poon uint32_t seg_seq;
2760721fffe3SKacheong Poon uint32_t seg_ack;
2761721fffe3SKacheong Poon uint_t flags;
27628a06b3d6SToomas Soome ipha_t *ipha;
27638a06b3d6SToomas Soome ip6_t *ip6h;
2764721fffe3SKacheong Poon boolean_t policy_present;
2765721fffe3SKacheong Poon netstack_t *ns = ipst->ips_netstack;
2766721fffe3SKacheong Poon tcp_stack_t *tcps = ns->netstack_tcp;
2767721fffe3SKacheong Poon ipsec_stack_t *ipss = tcps->tcps_netstack->netstack_ipsec;
2768721fffe3SKacheong Poon uint_t ip_hdr_len = ira->ira_ip_hdr_length;
2769721fffe3SKacheong Poon
2770721fffe3SKacheong Poon TCP_STAT(tcps, tcp_no_listener);
2771721fffe3SKacheong Poon
27729cd928feSAlan Maguire /*
27739cd928feSAlan Maguire * DTrace this "unknown" segment as a tcp:::receive, as we did
27749cd928feSAlan Maguire * just receive something that was TCP.
27759cd928feSAlan Maguire */
27769cd928feSAlan Maguire DTRACE_TCP5(receive, mblk_t *, NULL, ip_xmit_attr_t *, NULL,
27779cd928feSAlan Maguire __dtrace_tcp_void_ip_t *, mp->b_rptr, tcp_t *, NULL,
27789cd928feSAlan Maguire __dtrace_tcp_tcph_t *, &mp->b_rptr[ip_hdr_len]);
27799cd928feSAlan Maguire
2780721fffe3SKacheong Poon if (IPH_HDR_VERSION(mp->b_rptr) == IPV4_VERSION) {
2781721fffe3SKacheong Poon policy_present = ipss->ipsec_inbound_v4_policy_present;
2782721fffe3SKacheong Poon ipha = (ipha_t *)mp->b_rptr;
2783721fffe3SKacheong Poon ip6h = NULL;
2784721fffe3SKacheong Poon } else {
2785721fffe3SKacheong Poon policy_present = ipss->ipsec_inbound_v6_policy_present;
2786721fffe3SKacheong Poon ipha = NULL;
2787721fffe3SKacheong Poon ip6h = (ip6_t *)mp->b_rptr;
2788721fffe3SKacheong Poon }
2789721fffe3SKacheong Poon
2790721fffe3SKacheong Poon if (policy_present) {
2791721fffe3SKacheong Poon /*
2792721fffe3SKacheong Poon * The conn_t parameter is NULL because we already know
2793721fffe3SKacheong Poon * nobody's home.
2794721fffe3SKacheong Poon */
2795721fffe3SKacheong Poon mp = ipsec_check_global_policy(mp, (conn_t *)NULL, ipha, ip6h,
2796721fffe3SKacheong Poon ira, ns);
2797721fffe3SKacheong Poon if (mp == NULL)
2798721fffe3SKacheong Poon return;
2799721fffe3SKacheong Poon }
2800721fffe3SKacheong Poon if (is_system_labeled() && !tsol_can_reply_error(mp, ira)) {
2801721fffe3SKacheong Poon DTRACE_PROBE2(
2802721fffe3SKacheong Poon tx__ip__log__error__nolistener__tcp,
2803721fffe3SKacheong Poon char *, "Could not reply with RST to mp(1)",
2804721fffe3SKacheong Poon mblk_t *, mp);
2805721fffe3SKacheong Poon ip2dbg(("tcp_xmit_listeners_reset: not permitted to reply\n"));
2806721fffe3SKacheong Poon freemsg(mp);
2807721fffe3SKacheong Poon return;
2808721fffe3SKacheong Poon }
2809721fffe3SKacheong Poon
2810721fffe3SKacheong Poon rptr = mp->b_rptr;
2811721fffe3SKacheong Poon
2812721fffe3SKacheong Poon tcpha = (tcpha_t *)&rptr[ip_hdr_len];
2813721fffe3SKacheong Poon seg_seq = ntohl(tcpha->tha_seq);
2814721fffe3SKacheong Poon seg_ack = ntohl(tcpha->tha_ack);
2815721fffe3SKacheong Poon flags = tcpha->tha_flags;
2816721fffe3SKacheong Poon
2817721fffe3SKacheong Poon seg_len = msgdsize(mp) - (TCP_HDR_LENGTH(tcpha) + ip_hdr_len);
2818721fffe3SKacheong Poon if (flags & TH_RST) {
2819721fffe3SKacheong Poon freemsg(mp);
2820721fffe3SKacheong Poon } else if (flags & TH_ACK) {
2821721fffe3SKacheong Poon tcp_xmit_early_reset("no tcp, reset", mp, seg_ack, 0, TH_RST,
2822721fffe3SKacheong Poon ira, ipst, connp);
2823721fffe3SKacheong Poon } else {
2824721fffe3SKacheong Poon if (flags & TH_SYN) {
2825721fffe3SKacheong Poon seg_len++;
2826721fffe3SKacheong Poon } else {
2827721fffe3SKacheong Poon /*
2828721fffe3SKacheong Poon * Here we violate the RFC. Note that a normal
2829721fffe3SKacheong Poon * TCP will never send a segment without the ACK
2830721fffe3SKacheong Poon * flag, except for RST or SYN segment. This
2831721fffe3SKacheong Poon * segment is neither. Just drop it on the
2832721fffe3SKacheong Poon * floor.
2833721fffe3SKacheong Poon */
2834721fffe3SKacheong Poon freemsg(mp);
2835721fffe3SKacheong Poon TCP_STAT(tcps, tcp_rst_unsent);
2836721fffe3SKacheong Poon return;
2837721fffe3SKacheong Poon }
2838721fffe3SKacheong Poon
2839721fffe3SKacheong Poon tcp_xmit_early_reset("no tcp, reset/ack", mp, 0,
2840721fffe3SKacheong Poon seg_seq + seg_len, TH_RST | TH_ACK, ira, ipst, connp);
2841721fffe3SKacheong Poon }
2842721fffe3SKacheong Poon }
2843721fffe3SKacheong Poon
2844b7de80edSKacheong Poon /*
2845b7de80edSKacheong Poon * Helper function for tcp_xmit_mp() in handling connection set up flag
2846b7de80edSKacheong Poon * options setting.
2847b7de80edSKacheong Poon */
2848b7de80edSKacheong Poon static void
tcp_xmit_mp_aux_iss(tcp_t * tcp,conn_t * connp,tcpha_t * tcpha,mblk_t * mp,uint_t * flags)2849b7de80edSKacheong Poon tcp_xmit_mp_aux_iss(tcp_t *tcp, conn_t *connp, tcpha_t *tcpha, mblk_t *mp,
2850b7de80edSKacheong Poon uint_t *flags)
2851b7de80edSKacheong Poon {
2852b7de80edSKacheong Poon uint32_t u1;
2853b7de80edSKacheong Poon uint8_t *wptr = mp->b_wptr;
2854b7de80edSKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
2855b7de80edSKacheong Poon boolean_t add_sack = B_FALSE;
2856b7de80edSKacheong Poon
2857b7de80edSKacheong Poon /*
2858b7de80edSKacheong Poon * If TCP_ISS_VALID and the seq number is tcp_iss,
2859b7de80edSKacheong Poon * TCP can only be in SYN-SENT, SYN-RCVD or
2860b7de80edSKacheong Poon * FIN-WAIT-1 state. It can be FIN-WAIT-1 if
2861b7de80edSKacheong Poon * our SYN is not ack'ed but the app closes this
2862b7de80edSKacheong Poon * TCP connection.
2863b7de80edSKacheong Poon */
2864b7de80edSKacheong Poon ASSERT(tcp->tcp_state == TCPS_SYN_SENT ||
2865b7de80edSKacheong Poon tcp->tcp_state == TCPS_SYN_RCVD ||
2866b7de80edSKacheong Poon tcp->tcp_state == TCPS_FIN_WAIT_1);
2867b7de80edSKacheong Poon
2868b7de80edSKacheong Poon /*
2869b7de80edSKacheong Poon * Tack on the MSS option. It is always needed
2870b7de80edSKacheong Poon * for both active and passive open.
2871b7de80edSKacheong Poon *
2872b7de80edSKacheong Poon * MSS option value should be interface MTU - MIN
2873b7de80edSKacheong Poon * TCP/IP header according to RFC 793 as it means
2874b7de80edSKacheong Poon * the maximum segment size TCP can receive. But
2875b7de80edSKacheong Poon * to get around some broken middle boxes/end hosts
2876b7de80edSKacheong Poon * out there, we allow the option value to be the
2877b7de80edSKacheong Poon * same as the MSS option size on the peer side.
2878b7de80edSKacheong Poon * In this way, the other side will not send
2879b7de80edSKacheong Poon * anything larger than they can receive.
2880b7de80edSKacheong Poon *
2881b7de80edSKacheong Poon * Note that for SYN_SENT state, the ndd param
2882b7de80edSKacheong Poon * tcp_use_smss_as_mss_opt has no effect as we
2883b7de80edSKacheong Poon * don't know the peer's MSS option value. So
2884b7de80edSKacheong Poon * the only case we need to take care of is in
2885b7de80edSKacheong Poon * SYN_RCVD state, which is done later.
2886b7de80edSKacheong Poon */
2887b7de80edSKacheong Poon wptr[0] = TCPOPT_MAXSEG;
2888b7de80edSKacheong Poon wptr[1] = TCPOPT_MAXSEG_LEN;
2889b7de80edSKacheong Poon wptr += 2;
2890b7de80edSKacheong Poon u1 = tcp->tcp_initial_pmtu - (connp->conn_ipversion == IPV4_VERSION ?
2891b7de80edSKacheong Poon IP_SIMPLE_HDR_LENGTH : IPV6_HDR_LEN) - TCP_MIN_HEADER_LENGTH;
2892b7de80edSKacheong Poon U16_TO_BE16(u1, wptr);
2893b7de80edSKacheong Poon wptr += 2;
2894b7de80edSKacheong Poon
2895b7de80edSKacheong Poon /* Update the offset to cover the additional word */
2896b7de80edSKacheong Poon tcpha->tha_offset_and_reserved += (1 << 4);
2897b7de80edSKacheong Poon
2898b7de80edSKacheong Poon switch (tcp->tcp_state) {
2899b7de80edSKacheong Poon case TCPS_SYN_SENT:
2900b7de80edSKacheong Poon *flags = TH_SYN;
2901b7de80edSKacheong Poon
2902b7de80edSKacheong Poon if (tcp->tcp_snd_sack_ok)
2903b7de80edSKacheong Poon add_sack = B_TRUE;
2904b7de80edSKacheong Poon
2905b7de80edSKacheong Poon if (tcp->tcp_snd_ts_ok) {
2906b7de80edSKacheong Poon uint32_t llbolt = (uint32_t)LBOLT_FASTPATH;
2907b7de80edSKacheong Poon
2908b7de80edSKacheong Poon if (add_sack) {
2909b7de80edSKacheong Poon wptr[0] = TCPOPT_SACK_PERMITTED;
2910b7de80edSKacheong Poon wptr[1] = TCPOPT_SACK_OK_LEN;
2911b7de80edSKacheong Poon add_sack = B_FALSE;
2912b7de80edSKacheong Poon } else {
2913b7de80edSKacheong Poon wptr[0] = TCPOPT_NOP;
2914b7de80edSKacheong Poon wptr[1] = TCPOPT_NOP;
2915b7de80edSKacheong Poon }
2916b7de80edSKacheong Poon wptr[2] = TCPOPT_TSTAMP;
2917b7de80edSKacheong Poon wptr[3] = TCPOPT_TSTAMP_LEN;
2918b7de80edSKacheong Poon wptr += 4;
2919b7de80edSKacheong Poon U32_TO_BE32(llbolt, wptr);
2920b7de80edSKacheong Poon wptr += 4;
2921b7de80edSKacheong Poon ASSERT(tcp->tcp_ts_recent == 0);
2922b7de80edSKacheong Poon U32_TO_BE32(0L, wptr);
2923b7de80edSKacheong Poon wptr += 4;
2924b7de80edSKacheong Poon tcpha->tha_offset_and_reserved += (3 << 4);
2925b7de80edSKacheong Poon }
2926b7de80edSKacheong Poon
2927b7de80edSKacheong Poon /*
2928b7de80edSKacheong Poon * Set up all the bits to tell other side
2929b7de80edSKacheong Poon * we are ECN capable.
2930b7de80edSKacheong Poon */
2931b7de80edSKacheong Poon if (tcp->tcp_ecn_ok)
2932b7de80edSKacheong Poon *flags |= (TH_ECE | TH_CWR);
2933b7de80edSKacheong Poon
2934b7de80edSKacheong Poon break;
2935b7de80edSKacheong Poon
2936b7de80edSKacheong Poon case TCPS_SYN_RCVD:
2937b7de80edSKacheong Poon *flags |= TH_SYN;
2938b7de80edSKacheong Poon
2939b7de80edSKacheong Poon /*
2940b7de80edSKacheong Poon * Reset the MSS option value to be SMSS
2941b7de80edSKacheong Poon * We should probably add back the bytes
2942b7de80edSKacheong Poon * for timestamp option and IPsec. We
2943b7de80edSKacheong Poon * don't do that as this is a workaround
2944b7de80edSKacheong Poon * for broken middle boxes/end hosts, it
2945b7de80edSKacheong Poon * is better for us to be more cautious.
2946b7de80edSKacheong Poon * They may not take these things into
2947b7de80edSKacheong Poon * account in their SMSS calculation. Thus
2948b7de80edSKacheong Poon * the peer's calculated SMSS may be smaller
2949b7de80edSKacheong Poon * than what it can be. This should be OK.
2950b7de80edSKacheong Poon */
2951b7de80edSKacheong Poon if (tcps->tcps_use_smss_as_mss_opt) {
2952b7de80edSKacheong Poon u1 = tcp->tcp_mss;
2953b7de80edSKacheong Poon /*
2954b7de80edSKacheong Poon * Note that wptr points just past the MSS
2955b7de80edSKacheong Poon * option value.
2956b7de80edSKacheong Poon */
2957b7de80edSKacheong Poon U16_TO_BE16(u1, wptr - 2);
2958b7de80edSKacheong Poon }
2959b7de80edSKacheong Poon
2960b7de80edSKacheong Poon /*
2961b7de80edSKacheong Poon * tcp_snd_ts_ok can only be set in TCPS_SYN_RCVD
2962b7de80edSKacheong Poon * when the peer also uses timestamps option. And
2963b7de80edSKacheong Poon * the TCP header template must have already been
2964b7de80edSKacheong Poon * updated to include the timestamps option.
2965b7de80edSKacheong Poon */
2966b7de80edSKacheong Poon if (tcp->tcp_snd_sack_ok) {
2967b7de80edSKacheong Poon if (tcp->tcp_snd_ts_ok) {
2968b7de80edSKacheong Poon uint8_t *tmp_wptr;
2969b7de80edSKacheong Poon
2970b7de80edSKacheong Poon /*
2971b7de80edSKacheong Poon * Use the NOP in the header just
2972b7de80edSKacheong Poon * before timestamps opton.
2973b7de80edSKacheong Poon */
2974b7de80edSKacheong Poon tmp_wptr = (uint8_t *)tcpha +
2975b7de80edSKacheong Poon TCP_MIN_HEADER_LENGTH;
2976b7de80edSKacheong Poon ASSERT(tmp_wptr[0] == TCPOPT_NOP &&
2977b7de80edSKacheong Poon tmp_wptr[1] == TCPOPT_NOP);
2978b7de80edSKacheong Poon tmp_wptr[0] = TCPOPT_SACK_PERMITTED;
2979b7de80edSKacheong Poon tmp_wptr[1] = TCPOPT_SACK_OK_LEN;
2980b7de80edSKacheong Poon } else {
2981b7de80edSKacheong Poon add_sack = B_TRUE;
2982b7de80edSKacheong Poon }
2983b7de80edSKacheong Poon }
2984b7de80edSKacheong Poon
2985b7de80edSKacheong Poon
2986b7de80edSKacheong Poon /*
2987b7de80edSKacheong Poon * If the other side is ECN capable, reply
2988b7de80edSKacheong Poon * that we are also ECN capable.
2989b7de80edSKacheong Poon */
2990b7de80edSKacheong Poon if (tcp->tcp_ecn_ok)
2991b7de80edSKacheong Poon *flags |= TH_ECE;
2992b7de80edSKacheong Poon break;
2993b7de80edSKacheong Poon
2994b7de80edSKacheong Poon default:
2995b7de80edSKacheong Poon /*
2996b7de80edSKacheong Poon * The above ASSERT() makes sure that this
2997b7de80edSKacheong Poon * must be FIN-WAIT-1 state. Our SYN has
2998b7de80edSKacheong Poon * not been ack'ed so retransmit it.
2999b7de80edSKacheong Poon */
3000b7de80edSKacheong Poon *flags |= TH_SYN;
3001b7de80edSKacheong Poon break;
3002b7de80edSKacheong Poon }
3003b7de80edSKacheong Poon
3004b7de80edSKacheong Poon if (add_sack) {
3005b7de80edSKacheong Poon wptr[0] = TCPOPT_NOP;
3006b7de80edSKacheong Poon wptr[1] = TCPOPT_NOP;
3007b7de80edSKacheong Poon wptr[2] = TCPOPT_SACK_PERMITTED;
3008b7de80edSKacheong Poon wptr[3] = TCPOPT_SACK_OK_LEN;
3009b7de80edSKacheong Poon wptr += TCPOPT_REAL_SACK_OK_LEN;
3010b7de80edSKacheong Poon tcpha->tha_offset_and_reserved += (1 << 4);
3011b7de80edSKacheong Poon }
3012b7de80edSKacheong Poon
3013b7de80edSKacheong Poon if (tcp->tcp_snd_ws_ok) {
3014b7de80edSKacheong Poon wptr[0] = TCPOPT_NOP;
3015b7de80edSKacheong Poon wptr[1] = TCPOPT_WSCALE;
3016b7de80edSKacheong Poon wptr[2] = TCPOPT_WS_LEN;
3017b7de80edSKacheong Poon wptr[3] = (uchar_t)tcp->tcp_rcv_ws;
3018b7de80edSKacheong Poon wptr += TCPOPT_REAL_WS_LEN;
3019b7de80edSKacheong Poon tcpha->tha_offset_and_reserved += (1 << 4);
3020b7de80edSKacheong Poon }
3021b7de80edSKacheong Poon
3022b7de80edSKacheong Poon mp->b_wptr = wptr;
3023b7de80edSKacheong Poon u1 = (int)(mp->b_wptr - mp->b_rptr);
3024b7de80edSKacheong Poon /*
3025b7de80edSKacheong Poon * Get IP set to checksum on our behalf
3026b7de80edSKacheong Poon * Include the adjustment for a source route if any.
3027b7de80edSKacheong Poon */
3028b7de80edSKacheong Poon u1 += connp->conn_sum;
3029b7de80edSKacheong Poon u1 = (u1 >> 16) + (u1 & 0xFFFF);
3030b7de80edSKacheong Poon tcpha->tha_sum = htons(u1);
3031b7de80edSKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutControl);
3032b7de80edSKacheong Poon }
3033b7de80edSKacheong Poon
3034b7de80edSKacheong Poon /*
3035b7de80edSKacheong Poon * Helper function for tcp_xmit_mp() in handling connection tear down
3036b7de80edSKacheong Poon * flag setting and state changes.
3037b7de80edSKacheong Poon */
3038b7de80edSKacheong Poon static void
tcp_xmit_mp_aux_fss(tcp_t * tcp,ip_xmit_attr_t * ixa,uint_t * flags)3039b7de80edSKacheong Poon tcp_xmit_mp_aux_fss(tcp_t *tcp, ip_xmit_attr_t *ixa, uint_t *flags)
3040b7de80edSKacheong Poon {
3041b7de80edSKacheong Poon if (!tcp->tcp_fin_acked) {
3042b7de80edSKacheong Poon *flags |= TH_FIN;
3043b7de80edSKacheong Poon TCPS_BUMP_MIB(tcp->tcp_tcps, tcpOutControl);
3044b7de80edSKacheong Poon }
3045b7de80edSKacheong Poon if (!tcp->tcp_fin_sent) {
3046b7de80edSKacheong Poon tcp->tcp_fin_sent = B_TRUE;
3047b7de80edSKacheong Poon switch (tcp->tcp_state) {
3048b7de80edSKacheong Poon case TCPS_SYN_RCVD:
3049b7de80edSKacheong Poon tcp->tcp_state = TCPS_FIN_WAIT_1;
3050b7de80edSKacheong Poon DTRACE_TCP6(state__change, void, NULL,
3051b7de80edSKacheong Poon ip_xmit_attr_t *, ixa, void, NULL,
3052b7de80edSKacheong Poon tcp_t *, tcp, void, NULL,
3053b7de80edSKacheong Poon int32_t, TCPS_SYN_RCVD);
3054b7de80edSKacheong Poon break;
3055b7de80edSKacheong Poon case TCPS_ESTABLISHED:
3056b7de80edSKacheong Poon tcp->tcp_state = TCPS_FIN_WAIT_1;
3057b7de80edSKacheong Poon DTRACE_TCP6(state__change, void, NULL,
3058b7de80edSKacheong Poon ip_xmit_attr_t *, ixa, void, NULL,
3059b7de80edSKacheong Poon tcp_t *, tcp, void, NULL,
3060b7de80edSKacheong Poon int32_t, TCPS_ESTABLISHED);
3061b7de80edSKacheong Poon break;
3062b7de80edSKacheong Poon case TCPS_CLOSE_WAIT:
3063b7de80edSKacheong Poon tcp->tcp_state = TCPS_LAST_ACK;
3064b7de80edSKacheong Poon DTRACE_TCP6(state__change, void, NULL,
3065b7de80edSKacheong Poon ip_xmit_attr_t *, ixa, void, NULL,
3066b7de80edSKacheong Poon tcp_t *, tcp, void, NULL,
3067b7de80edSKacheong Poon int32_t, TCPS_CLOSE_WAIT);
3068b7de80edSKacheong Poon break;
3069b7de80edSKacheong Poon }
3070b7de80edSKacheong Poon if (tcp->tcp_suna == tcp->tcp_snxt)
3071b7de80edSKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
3072b7de80edSKacheong Poon tcp->tcp_snxt = tcp->tcp_fss + 1;
3073b7de80edSKacheong Poon }
3074b7de80edSKacheong Poon }
3075b7de80edSKacheong Poon
3076721fffe3SKacheong Poon /*
3077721fffe3SKacheong Poon * tcp_xmit_mp is called to return a pointer to an mblk chain complete with
3078721fffe3SKacheong Poon * ip and tcp header ready to pass down to IP. If the mp passed in is
3079721fffe3SKacheong Poon * non-NULL, then up to max_to_send bytes of data will be dup'ed off that
3080721fffe3SKacheong Poon * mblk. (If sendall is not set the dup'ing will stop at an mblk boundary
3081721fffe3SKacheong Poon * otherwise it will dup partial mblks.)
3082721fffe3SKacheong Poon * Otherwise, an appropriate ACK packet will be generated. This
3083721fffe3SKacheong Poon * routine is not usually called to send new data for the first time. It
3084721fffe3SKacheong Poon * is mostly called out of the timer for retransmits, and to generate ACKs.
3085721fffe3SKacheong Poon *
3086721fffe3SKacheong Poon * If offset is not NULL, the returned mblk chain's first mblk's b_rptr will
3087721fffe3SKacheong Poon * be adjusted by *offset. And after dupb(), the offset and the ending mblk
3088721fffe3SKacheong Poon * of the original mblk chain will be returned in *offset and *end_mp.
3089721fffe3SKacheong Poon */
3090721fffe3SKacheong Poon mblk_t *
tcp_xmit_mp(tcp_t * tcp,mblk_t * mp,int32_t max_to_send,int32_t * offset,mblk_t ** end_mp,uint32_t seq,boolean_t sendall,uint32_t * seg_len,boolean_t rexmit)3091721fffe3SKacheong Poon tcp_xmit_mp(tcp_t *tcp, mblk_t *mp, int32_t max_to_send, int32_t *offset,
3092721fffe3SKacheong Poon mblk_t **end_mp, uint32_t seq, boolean_t sendall, uint32_t *seg_len,
3093721fffe3SKacheong Poon boolean_t rexmit)
3094721fffe3SKacheong Poon {
3095721fffe3SKacheong Poon int data_length;
3096721fffe3SKacheong Poon int32_t off = 0;
3097721fffe3SKacheong Poon uint_t flags;
3098721fffe3SKacheong Poon mblk_t *mp1;
3099721fffe3SKacheong Poon mblk_t *mp2;
3100721fffe3SKacheong Poon uchar_t *rptr;
3101721fffe3SKacheong Poon tcpha_t *tcpha;
3102721fffe3SKacheong Poon int32_t num_sack_blk = 0;
3103*1edba515SAndy Fiddaman int32_t sack_opt_len = 0, opt_len = 0;
3104721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
3105721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
3106721fffe3SKacheong Poon ip_xmit_attr_t *ixa = connp->conn_ixa;
3107721fffe3SKacheong Poon
3108721fffe3SKacheong Poon /* Allocate for our maximum TCP header + link-level */
3109721fffe3SKacheong Poon mp1 = allocb(connp->conn_ht_iphc_allocated + tcps->tcps_wroff_xtra,
3110721fffe3SKacheong Poon BPRI_MED);
3111b7de80edSKacheong Poon if (mp1 == NULL)
3112721fffe3SKacheong Poon return (NULL);
3113721fffe3SKacheong Poon data_length = 0;
3114721fffe3SKacheong Poon
3115721fffe3SKacheong Poon /*
3116721fffe3SKacheong Poon * Note that tcp_mss has been adjusted to take into account the
3117721fffe3SKacheong Poon * timestamp option if applicable. Because SACK options do not
3118*1edba515SAndy Fiddaman * appear in every TCP segment and they are of variable lengths,
3119721fffe3SKacheong Poon * they cannot be included in tcp_mss. Thus we need to calculate
3120721fffe3SKacheong Poon * the actual segment length when we need to send a segment which
3121721fffe3SKacheong Poon * includes SACK options.
3122721fffe3SKacheong Poon */
3123721fffe3SKacheong Poon if (tcp->tcp_snd_sack_ok && tcp->tcp_num_sack_blk > 0) {
3124721fffe3SKacheong Poon num_sack_blk = MIN(tcp->tcp_max_sack_blk,
3125721fffe3SKacheong Poon tcp->tcp_num_sack_blk);
3126721fffe3SKacheong Poon sack_opt_len = num_sack_blk * sizeof (sack_blk_t) +
3127721fffe3SKacheong Poon TCPOPT_NOP_LEN * 2 + TCPOPT_HEADER_LEN;
3128*1edba515SAndy Fiddaman opt_len += sack_opt_len;
3129721fffe3SKacheong Poon }
3130*1edba515SAndy Fiddaman if (tcp->tcp_md5sig)
3131*1edba515SAndy Fiddaman opt_len += TCPOPT_REAL_MD5_LEN;
3132*1edba515SAndy Fiddaman
3133*1edba515SAndy Fiddaman if (max_to_send + opt_len > tcp->tcp_mss)
3134*1edba515SAndy Fiddaman max_to_send -= opt_len;
3135721fffe3SKacheong Poon
3136721fffe3SKacheong Poon if (offset != NULL) {
3137721fffe3SKacheong Poon off = *offset;
3138721fffe3SKacheong Poon /* We use offset as an indicator that end_mp is not NULL. */
3139721fffe3SKacheong Poon *end_mp = NULL;
3140721fffe3SKacheong Poon }
3141721fffe3SKacheong Poon for (mp2 = mp1; mp && data_length != max_to_send; mp = mp->b_cont) {
3142721fffe3SKacheong Poon /* This could be faster with cooperation from downstream */
3143721fffe3SKacheong Poon if (mp2 != mp1 && !sendall &&
3144721fffe3SKacheong Poon data_length + (int)(mp->b_wptr - mp->b_rptr) >
3145721fffe3SKacheong Poon max_to_send)
3146721fffe3SKacheong Poon /*
3147721fffe3SKacheong Poon * Don't send the next mblk since the whole mblk
3148721fffe3SKacheong Poon * does not fit.
3149721fffe3SKacheong Poon */
3150721fffe3SKacheong Poon break;
3151721fffe3SKacheong Poon mp2->b_cont = dupb(mp);
3152721fffe3SKacheong Poon mp2 = mp2->b_cont;
3153721fffe3SKacheong Poon if (!mp2) {
3154721fffe3SKacheong Poon freemsg(mp1);
3155721fffe3SKacheong Poon return (NULL);
3156721fffe3SKacheong Poon }
3157721fffe3SKacheong Poon mp2->b_rptr += off;
3158721fffe3SKacheong Poon ASSERT((uintptr_t)(mp2->b_wptr - mp2->b_rptr) <=
3159721fffe3SKacheong Poon (uintptr_t)INT_MAX);
3160721fffe3SKacheong Poon
3161721fffe3SKacheong Poon data_length += (int)(mp2->b_wptr - mp2->b_rptr);
3162721fffe3SKacheong Poon if (data_length > max_to_send) {
3163721fffe3SKacheong Poon mp2->b_wptr -= data_length - max_to_send;
3164721fffe3SKacheong Poon data_length = max_to_send;
3165721fffe3SKacheong Poon off = mp2->b_wptr - mp->b_rptr;
3166721fffe3SKacheong Poon break;
3167721fffe3SKacheong Poon } else {
3168721fffe3SKacheong Poon off = 0;
3169721fffe3SKacheong Poon }
3170721fffe3SKacheong Poon }
3171721fffe3SKacheong Poon if (offset != NULL) {
3172721fffe3SKacheong Poon *offset = off;
3173721fffe3SKacheong Poon *end_mp = mp;
3174721fffe3SKacheong Poon }
3175721fffe3SKacheong Poon if (seg_len != NULL) {
3176721fffe3SKacheong Poon *seg_len = data_length;
3177721fffe3SKacheong Poon }
3178721fffe3SKacheong Poon
3179721fffe3SKacheong Poon /* Update the latest receive window size in TCP header. */
3180721fffe3SKacheong Poon tcp->tcp_tcpha->tha_win = htons(tcp->tcp_rwnd >> tcp->tcp_rcv_ws);
3181721fffe3SKacheong Poon
3182721fffe3SKacheong Poon rptr = mp1->b_rptr + tcps->tcps_wroff_xtra;
3183721fffe3SKacheong Poon mp1->b_rptr = rptr;
3184721fffe3SKacheong Poon mp1->b_wptr = rptr + connp->conn_ht_iphc_len + sack_opt_len;
3185721fffe3SKacheong Poon bcopy(connp->conn_ht_iphc, rptr, connp->conn_ht_iphc_len);
3186721fffe3SKacheong Poon tcpha = (tcpha_t *)&rptr[ixa->ixa_ip_hdr_length];
3187721fffe3SKacheong Poon tcpha->tha_seq = htonl(seq);
3188721fffe3SKacheong Poon
3189721fffe3SKacheong Poon /*
3190721fffe3SKacheong Poon * Use tcp_unsent to determine if the PUSH bit should be used assumes
3191721fffe3SKacheong Poon * that this function was called from tcp_wput_data. Thus, when called
3192721fffe3SKacheong Poon * to retransmit data the setting of the PUSH bit may appear some
3193721fffe3SKacheong Poon * what random in that it might get set when it should not. This
3194721fffe3SKacheong Poon * should not pose any performance issues.
3195721fffe3SKacheong Poon */
3196721fffe3SKacheong Poon if (data_length != 0 && (tcp->tcp_unsent == 0 ||
3197721fffe3SKacheong Poon tcp->tcp_unsent == data_length)) {
3198721fffe3SKacheong Poon flags = TH_ACK | TH_PUSH;
3199721fffe3SKacheong Poon } else {
3200721fffe3SKacheong Poon flags = TH_ACK;
3201721fffe3SKacheong Poon }
3202721fffe3SKacheong Poon
3203721fffe3SKacheong Poon if (tcp->tcp_ecn_ok) {
3204721fffe3SKacheong Poon if (tcp->tcp_ecn_echo_on)
3205721fffe3SKacheong Poon flags |= TH_ECE;
3206721fffe3SKacheong Poon
3207721fffe3SKacheong Poon /*
3208721fffe3SKacheong Poon * Only set ECT bit and ECN_CWR if a segment contains new data.
3209721fffe3SKacheong Poon * There is no TCP flow control for non-data segments, and
3210721fffe3SKacheong Poon * only data segment is transmitted reliably.
3211721fffe3SKacheong Poon */
3212721fffe3SKacheong Poon if (data_length > 0 && !rexmit) {
3213721fffe3SKacheong Poon TCP_SET_ECT(tcp, rptr);
3214721fffe3SKacheong Poon if (tcp->tcp_cwr && !tcp->tcp_ecn_cwr_sent) {
3215721fffe3SKacheong Poon flags |= TH_CWR;
3216721fffe3SKacheong Poon tcp->tcp_ecn_cwr_sent = B_TRUE;
3217721fffe3SKacheong Poon }
3218721fffe3SKacheong Poon }
3219721fffe3SKacheong Poon }
3220721fffe3SKacheong Poon
3221b7de80edSKacheong Poon /* Check if there is any special processing needs to be done. */
3222721fffe3SKacheong Poon if (tcp->tcp_valid_bits) {
3223721fffe3SKacheong Poon uint32_t u1;
3224721fffe3SKacheong Poon
3225b7de80edSKacheong Poon /* We don't allow having SYN and FIN in the same segment... */
3226721fffe3SKacheong Poon if ((tcp->tcp_valid_bits & TCP_ISS_VALID) &&
3227721fffe3SKacheong Poon seq == tcp->tcp_iss) {
3228b7de80edSKacheong Poon /* Need to do connection set up processing. */
3229b7de80edSKacheong Poon tcp_xmit_mp_aux_iss(tcp, connp, tcpha, mp1, &flags);
3230b7de80edSKacheong Poon } else if ((tcp->tcp_valid_bits & TCP_FSS_VALID) &&
3231721fffe3SKacheong Poon (seq + data_length) == tcp->tcp_fss) {
3232b7de80edSKacheong Poon /* Need to do connection tear down processing. */
3233b7de80edSKacheong Poon tcp_xmit_mp_aux_fss(tcp, ixa, &flags);
3234721fffe3SKacheong Poon }
3235b7de80edSKacheong Poon
3236721fffe3SKacheong Poon /*
3237b7de80edSKacheong Poon * Need to do urgent pointer processing.
3238b7de80edSKacheong Poon *
3239721fffe3SKacheong Poon * Note the trick here. u1 is unsigned. When tcp_urg
3240721fffe3SKacheong Poon * is smaller than seq, u1 will become a very huge value.
3241721fffe3SKacheong Poon * So the comparison will fail. Also note that tcp_urp
3242721fffe3SKacheong Poon * should be positive, see RFC 793 page 17.
3243721fffe3SKacheong Poon */
3244721fffe3SKacheong Poon u1 = tcp->tcp_urg - seq + TCP_OLD_URP_INTERPRETATION;
3245721fffe3SKacheong Poon if ((tcp->tcp_valid_bits & TCP_URG_VALID) && u1 != 0 &&
3246721fffe3SKacheong Poon u1 < (uint32_t)(64 * 1024)) {
3247721fffe3SKacheong Poon flags |= TH_URG;
3248721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutUrg);
3249721fffe3SKacheong Poon tcpha->tha_urp = htons(u1);
3250721fffe3SKacheong Poon }
3251721fffe3SKacheong Poon }
3252721fffe3SKacheong Poon tcpha->tha_flags = (uchar_t)flags;
3253721fffe3SKacheong Poon tcp->tcp_rack = tcp->tcp_rnxt;
3254721fffe3SKacheong Poon tcp->tcp_rack_cnt = 0;
3255721fffe3SKacheong Poon
3256b7de80edSKacheong Poon /* Fill in the current value of timestamps option. */
3257721fffe3SKacheong Poon if (tcp->tcp_snd_ts_ok) {
3258721fffe3SKacheong Poon if (tcp->tcp_state != TCPS_SYN_SENT) {
3259721fffe3SKacheong Poon uint32_t llbolt = (uint32_t)LBOLT_FASTPATH;
3260721fffe3SKacheong Poon
3261721fffe3SKacheong Poon U32_TO_BE32(llbolt,
3262*1edba515SAndy Fiddaman (char *)tcpha + TCP_MIN_HEADER_LENGTH + 4);
3263721fffe3SKacheong Poon U32_TO_BE32(tcp->tcp_ts_recent,
3264*1edba515SAndy Fiddaman (char *)tcpha + TCP_MIN_HEADER_LENGTH + 8);
3265721fffe3SKacheong Poon }
3266721fffe3SKacheong Poon }
3267721fffe3SKacheong Poon
3268b7de80edSKacheong Poon /* Fill in the SACK blocks. */
3269721fffe3SKacheong Poon if (num_sack_blk > 0) {
3270721fffe3SKacheong Poon uchar_t *wptr = (uchar_t *)tcpha + connp->conn_ht_ulp_len;
3271721fffe3SKacheong Poon sack_blk_t *tmp;
3272721fffe3SKacheong Poon int32_t i;
3273721fffe3SKacheong Poon
3274721fffe3SKacheong Poon wptr[0] = TCPOPT_NOP;
3275721fffe3SKacheong Poon wptr[1] = TCPOPT_NOP;
3276721fffe3SKacheong Poon wptr[2] = TCPOPT_SACK;
3277721fffe3SKacheong Poon wptr[3] = TCPOPT_HEADER_LEN + num_sack_blk *
3278721fffe3SKacheong Poon sizeof (sack_blk_t);
3279721fffe3SKacheong Poon wptr += TCPOPT_REAL_SACK_LEN;
3280721fffe3SKacheong Poon
3281721fffe3SKacheong Poon tmp = tcp->tcp_sack_list;
3282721fffe3SKacheong Poon for (i = 0; i < num_sack_blk; i++) {
3283721fffe3SKacheong Poon U32_TO_BE32(tmp[i].begin, wptr);
3284721fffe3SKacheong Poon wptr += sizeof (tcp_seq);
3285721fffe3SKacheong Poon U32_TO_BE32(tmp[i].end, wptr);
3286721fffe3SKacheong Poon wptr += sizeof (tcp_seq);
3287721fffe3SKacheong Poon }
3288721fffe3SKacheong Poon tcpha->tha_offset_and_reserved += ((num_sack_blk * 2 + 1) << 4);
3289721fffe3SKacheong Poon }
3290*1edba515SAndy Fiddaman
3291*1edba515SAndy Fiddaman /* Fill in the MD5 signature option */
3292*1edba515SAndy Fiddaman if (tcp->tcp_md5sig) {
3293*1edba515SAndy Fiddaman uint8_t digest[MD5_DIGEST_LENGTH];
3294*1edba515SAndy Fiddaman int tcplen = data_length + (int)(mp1->b_wptr - rptr) +
3295*1edba515SAndy Fiddaman TCPOPT_REAL_MD5_LEN - ixa->ixa_ip_hdr_length;
3296*1edba515SAndy Fiddaman
3297*1edba515SAndy Fiddaman if (tcpsig_signature(mp1->b_cont, tcp, tcpha, tcplen, digest,
3298*1edba515SAndy Fiddaman false)) {
3299*1edba515SAndy Fiddaman uint8_t *wptr = mp1->b_wptr;
3300*1edba515SAndy Fiddaman
3301*1edba515SAndy Fiddaman wptr[0] = TCPOPT_NOP;
3302*1edba515SAndy Fiddaman wptr[1] = TCPOPT_NOP;
3303*1edba515SAndy Fiddaman wptr[2] = TCPOPT_MD5;
3304*1edba515SAndy Fiddaman wptr[3] = TCPOPT_MD5_LEN;
3305*1edba515SAndy Fiddaman bcopy(digest, &wptr[4], sizeof (digest));
3306*1edba515SAndy Fiddaman
3307*1edba515SAndy Fiddaman tcpha->tha_offset_and_reserved += (5 << 4);
3308*1edba515SAndy Fiddaman mp1->b_wptr += TCPOPT_REAL_MD5_LEN;
3309*1edba515SAndy Fiddaman } else {
3310*1edba515SAndy Fiddaman /* Silently drop the packet */
3311*1edba515SAndy Fiddaman freemsg(mp1);
3312*1edba515SAndy Fiddaman return (NULL);
3313*1edba515SAndy Fiddaman }
3314*1edba515SAndy Fiddaman }
3315*1edba515SAndy Fiddaman
3316721fffe3SKacheong Poon ASSERT((uintptr_t)(mp1->b_wptr - rptr) <= (uintptr_t)INT_MAX);
3317721fffe3SKacheong Poon data_length += (int)(mp1->b_wptr - rptr);
3318721fffe3SKacheong Poon
3319721fffe3SKacheong Poon ixa->ixa_pktlen = data_length;
3320721fffe3SKacheong Poon
3321721fffe3SKacheong Poon if (ixa->ixa_flags & IXAF_IS_IPV4) {
3322721fffe3SKacheong Poon ((ipha_t *)rptr)->ipha_length = htons(data_length);
3323721fffe3SKacheong Poon } else {
3324721fffe3SKacheong Poon ip6_t *ip6 = (ip6_t *)rptr;
3325721fffe3SKacheong Poon
3326721fffe3SKacheong Poon ip6->ip6_plen = htons(data_length - IPV6_HDR_LEN);
3327721fffe3SKacheong Poon }
3328721fffe3SKacheong Poon
3329721fffe3SKacheong Poon /*
3330721fffe3SKacheong Poon * Prime pump for IP
3331721fffe3SKacheong Poon * Include the adjustment for a source route if any.
3332721fffe3SKacheong Poon */
3333721fffe3SKacheong Poon data_length -= ixa->ixa_ip_hdr_length;
3334721fffe3SKacheong Poon data_length += connp->conn_sum;
3335721fffe3SKacheong Poon data_length = (data_length >> 16) + (data_length & 0xFFFF);
3336721fffe3SKacheong Poon tcpha->tha_sum = htons(data_length);
3337721fffe3SKacheong Poon if (tcp->tcp_ip_forward_progress) {
3338721fffe3SKacheong Poon tcp->tcp_ip_forward_progress = B_FALSE;
3339721fffe3SKacheong Poon connp->conn_ixa->ixa_flags |= IXAF_REACH_CONF;
3340721fffe3SKacheong Poon } else {
3341721fffe3SKacheong Poon connp->conn_ixa->ixa_flags &= ~IXAF_REACH_CONF;
3342721fffe3SKacheong Poon }
3343721fffe3SKacheong Poon return (mp1);
3344721fffe3SKacheong Poon }
3345721fffe3SKacheong Poon
3346721fffe3SKacheong Poon /*
3347721fffe3SKacheong Poon * If this routine returns B_TRUE, TCP can generate a RST in response
3348721fffe3SKacheong Poon * to a segment. If it returns B_FALSE, TCP should not respond.
3349721fffe3SKacheong Poon */
3350721fffe3SKacheong Poon static boolean_t
tcp_send_rst_chk(tcp_stack_t * tcps)3351721fffe3SKacheong Poon tcp_send_rst_chk(tcp_stack_t *tcps)
3352721fffe3SKacheong Poon {
3353721fffe3SKacheong Poon int64_t now;
3354721fffe3SKacheong Poon
3355721fffe3SKacheong Poon /*
3356721fffe3SKacheong Poon * TCP needs to protect itself from generating too many RSTs.
3357721fffe3SKacheong Poon * This can be a DoS attack by sending us random segments
3358721fffe3SKacheong Poon * soliciting RSTs.
3359721fffe3SKacheong Poon *
3360721fffe3SKacheong Poon * What we do here is to have a limit of tcp_rst_sent_rate RSTs
3361721fffe3SKacheong Poon * in each 1 second interval. In this way, TCP still generate
3362721fffe3SKacheong Poon * RSTs in normal cases but when under attack, the impact is
3363721fffe3SKacheong Poon * limited.
3364721fffe3SKacheong Poon */
3365721fffe3SKacheong Poon if (tcps->tcps_rst_sent_rate_enabled != 0) {
3366721fffe3SKacheong Poon now = ddi_get_lbolt64();
3367721fffe3SKacheong Poon if (TICK_TO_MSEC(now - tcps->tcps_last_rst_intrvl) >
3368721fffe3SKacheong Poon 1*SECONDS) {
3369721fffe3SKacheong Poon tcps->tcps_last_rst_intrvl = now;
3370721fffe3SKacheong Poon tcps->tcps_rst_cnt = 1;
3371721fffe3SKacheong Poon } else if (++tcps->tcps_rst_cnt > tcps->tcps_rst_sent_rate) {
3372721fffe3SKacheong Poon return (B_FALSE);
3373721fffe3SKacheong Poon }
3374721fffe3SKacheong Poon }
3375721fffe3SKacheong Poon return (B_TRUE);
3376721fffe3SKacheong Poon }
3377721fffe3SKacheong Poon
3378721fffe3SKacheong Poon /*
3379721fffe3SKacheong Poon * This function handles all retransmissions if SACK is enabled for this
3380721fffe3SKacheong Poon * connection. First it calculates how many segments can be retransmitted
3381721fffe3SKacheong Poon * based on tcp_pipe. Then it goes thru the notsack list to find eligible
3382721fffe3SKacheong Poon * segments. A segment is eligible if sack_cnt for that segment is greater
3383721fffe3SKacheong Poon * than or equal tcp_dupack_fast_retransmit. After it has retransmitted
3384721fffe3SKacheong Poon * all eligible segments, it checks to see if TCP can send some new segments
3385721fffe3SKacheong Poon * (fast recovery). If it can, set the appropriate flag for tcp_input_data().
3386721fffe3SKacheong Poon *
3387721fffe3SKacheong Poon * Parameters:
3388721fffe3SKacheong Poon * tcp_t *tcp: the tcp structure of the connection.
3389721fffe3SKacheong Poon * uint_t *flags: in return, appropriate value will be set for
3390721fffe3SKacheong Poon * tcp_input_data().
3391721fffe3SKacheong Poon */
3392721fffe3SKacheong Poon void
tcp_sack_rexmit(tcp_t * tcp,uint_t * flags)3393721fffe3SKacheong Poon tcp_sack_rexmit(tcp_t *tcp, uint_t *flags)
3394721fffe3SKacheong Poon {
3395721fffe3SKacheong Poon notsack_blk_t *notsack_blk;
3396721fffe3SKacheong Poon int32_t usable_swnd;
3397721fffe3SKacheong Poon int32_t mss;
3398721fffe3SKacheong Poon uint32_t seg_len;
3399721fffe3SKacheong Poon mblk_t *xmit_mp;
3400721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
3401721fffe3SKacheong Poon
3402721fffe3SKacheong Poon ASSERT(tcp->tcp_notsack_list != NULL);
3403721fffe3SKacheong Poon ASSERT(tcp->tcp_rexmit == B_FALSE);
3404721fffe3SKacheong Poon
3405721fffe3SKacheong Poon /* Defensive coding in case there is a bug... */
3406721fffe3SKacheong Poon if (tcp->tcp_notsack_list == NULL) {
3407721fffe3SKacheong Poon return;
3408721fffe3SKacheong Poon }
3409721fffe3SKacheong Poon notsack_blk = tcp->tcp_notsack_list;
3410721fffe3SKacheong Poon mss = tcp->tcp_mss;
3411721fffe3SKacheong Poon
3412721fffe3SKacheong Poon /*
3413721fffe3SKacheong Poon * Limit the num of outstanding data in the network to be
3414721fffe3SKacheong Poon * tcp_cwnd_ssthresh, which is half of the original congestion wnd.
3415721fffe3SKacheong Poon */
3416721fffe3SKacheong Poon usable_swnd = tcp->tcp_cwnd_ssthresh - tcp->tcp_pipe;
3417721fffe3SKacheong Poon
3418721fffe3SKacheong Poon /* At least retransmit 1 MSS of data. */
3419721fffe3SKacheong Poon if (usable_swnd <= 0) {
3420721fffe3SKacheong Poon usable_swnd = mss;
3421721fffe3SKacheong Poon }
3422721fffe3SKacheong Poon
3423721fffe3SKacheong Poon /* Make sure no new RTT samples will be taken. */
3424721fffe3SKacheong Poon tcp->tcp_csuna = tcp->tcp_snxt;
3425721fffe3SKacheong Poon
3426721fffe3SKacheong Poon notsack_blk = tcp->tcp_notsack_list;
3427721fffe3SKacheong Poon while (usable_swnd > 0) {
3428721fffe3SKacheong Poon mblk_t *snxt_mp, *tmp_mp;
3429721fffe3SKacheong Poon tcp_seq begin = tcp->tcp_sack_snxt;
3430721fffe3SKacheong Poon tcp_seq end;
3431721fffe3SKacheong Poon int32_t off;
3432721fffe3SKacheong Poon
3433721fffe3SKacheong Poon for (; notsack_blk != NULL; notsack_blk = notsack_blk->next) {
3434721fffe3SKacheong Poon if (SEQ_GT(notsack_blk->end, begin) &&
3435721fffe3SKacheong Poon (notsack_blk->sack_cnt >=
3436721fffe3SKacheong Poon tcps->tcps_dupack_fast_retransmit)) {
3437721fffe3SKacheong Poon end = notsack_blk->end;
3438721fffe3SKacheong Poon if (SEQ_LT(begin, notsack_blk->begin)) {
3439721fffe3SKacheong Poon begin = notsack_blk->begin;
3440721fffe3SKacheong Poon }
3441721fffe3SKacheong Poon break;
3442721fffe3SKacheong Poon }
3443721fffe3SKacheong Poon }
3444721fffe3SKacheong Poon /*
3445721fffe3SKacheong Poon * All holes are filled. Manipulate tcp_cwnd to send more
3446721fffe3SKacheong Poon * if we can. Note that after the SACK recovery, tcp_cwnd is
3447721fffe3SKacheong Poon * set to tcp_cwnd_ssthresh.
3448721fffe3SKacheong Poon */
3449721fffe3SKacheong Poon if (notsack_blk == NULL) {
3450721fffe3SKacheong Poon usable_swnd = tcp->tcp_cwnd_ssthresh - tcp->tcp_pipe;
3451721fffe3SKacheong Poon if (usable_swnd <= 0 || tcp->tcp_unsent == 0) {
3452721fffe3SKacheong Poon tcp->tcp_cwnd = tcp->tcp_snxt - tcp->tcp_suna;
3453721fffe3SKacheong Poon ASSERT(tcp->tcp_cwnd > 0);
3454721fffe3SKacheong Poon return;
3455721fffe3SKacheong Poon } else {
3456721fffe3SKacheong Poon usable_swnd = usable_swnd / mss;
3457721fffe3SKacheong Poon tcp->tcp_cwnd = tcp->tcp_snxt - tcp->tcp_suna +
3458721fffe3SKacheong Poon MAX(usable_swnd * mss, mss);
3459721fffe3SKacheong Poon *flags |= TH_XMIT_NEEDED;
3460721fffe3SKacheong Poon return;
3461721fffe3SKacheong Poon }
3462721fffe3SKacheong Poon }
3463721fffe3SKacheong Poon
3464721fffe3SKacheong Poon /*
3465721fffe3SKacheong Poon * Note that we may send more than usable_swnd allows here
3466721fffe3SKacheong Poon * because of round off, but no more than 1 MSS of data.
3467721fffe3SKacheong Poon */
3468721fffe3SKacheong Poon seg_len = end - begin;
3469721fffe3SKacheong Poon if (seg_len > mss)
3470721fffe3SKacheong Poon seg_len = mss;
3471721fffe3SKacheong Poon snxt_mp = tcp_get_seg_mp(tcp, begin, &off);
3472721fffe3SKacheong Poon ASSERT(snxt_mp != NULL);
3473721fffe3SKacheong Poon /* This should not happen. Defensive coding again... */
3474721fffe3SKacheong Poon if (snxt_mp == NULL) {
3475721fffe3SKacheong Poon return;
3476721fffe3SKacheong Poon }
3477721fffe3SKacheong Poon
3478721fffe3SKacheong Poon xmit_mp = tcp_xmit_mp(tcp, snxt_mp, seg_len, &off,
3479721fffe3SKacheong Poon &tmp_mp, begin, B_TRUE, &seg_len, B_TRUE);
3480721fffe3SKacheong Poon if (xmit_mp == NULL)
3481721fffe3SKacheong Poon return;
3482721fffe3SKacheong Poon
3483721fffe3SKacheong Poon usable_swnd -= seg_len;
3484721fffe3SKacheong Poon tcp->tcp_pipe += seg_len;
3485721fffe3SKacheong Poon tcp->tcp_sack_snxt = begin + seg_len;
3486721fffe3SKacheong Poon
3487721fffe3SKacheong Poon tcp_send_data(tcp, xmit_mp);
3488721fffe3SKacheong Poon
3489721fffe3SKacheong Poon /*
3490721fffe3SKacheong Poon * Update the send timestamp to avoid false retransmission.
3491721fffe3SKacheong Poon */
3492c12492cfSSebastien Roy snxt_mp->b_prev = (mblk_t *)(intptr_t)gethrtime();
3493721fffe3SKacheong Poon
3494721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpRetransSegs);
3495721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpRetransBytes, seg_len);
3496721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpOutSackRetransSegs);
3497a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_retrans_segs++;
3498a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_retrans_bytes += seg_len;
3499721fffe3SKacheong Poon /*
3500721fffe3SKacheong Poon * Update tcp_rexmit_max to extend this SACK recovery phase.
3501721fffe3SKacheong Poon * This happens when new data sent during fast recovery is
3502721fffe3SKacheong Poon * also lost. If TCP retransmits those new data, it needs
3503721fffe3SKacheong Poon * to extend SACK recover phase to avoid starting another
3504721fffe3SKacheong Poon * fast retransmit/recovery unnecessarily.
3505721fffe3SKacheong Poon */
3506721fffe3SKacheong Poon if (SEQ_GT(tcp->tcp_sack_snxt, tcp->tcp_rexmit_max)) {
3507721fffe3SKacheong Poon tcp->tcp_rexmit_max = tcp->tcp_sack_snxt;
3508721fffe3SKacheong Poon }
3509721fffe3SKacheong Poon }
3510721fffe3SKacheong Poon }
3511721fffe3SKacheong Poon
3512721fffe3SKacheong Poon /*
3513721fffe3SKacheong Poon * tcp_ss_rexmit() is called to do slow start retransmission after a timeout
3514721fffe3SKacheong Poon * or ICMP errors.
3515721fffe3SKacheong Poon */
3516721fffe3SKacheong Poon void
tcp_ss_rexmit(tcp_t * tcp)3517721fffe3SKacheong Poon tcp_ss_rexmit(tcp_t *tcp)
3518721fffe3SKacheong Poon {
3519721fffe3SKacheong Poon uint32_t snxt;
3520721fffe3SKacheong Poon uint32_t smax;
3521721fffe3SKacheong Poon int32_t win;
3522721fffe3SKacheong Poon int32_t mss;
3523721fffe3SKacheong Poon int32_t off;
3524721fffe3SKacheong Poon mblk_t *snxt_mp;
3525721fffe3SKacheong Poon tcp_stack_t *tcps = tcp->tcp_tcps;
3526721fffe3SKacheong Poon
3527721fffe3SKacheong Poon /*
3528721fffe3SKacheong Poon * Note that tcp_rexmit can be set even though TCP has retransmitted
3529721fffe3SKacheong Poon * all unack'ed segments.
3530721fffe3SKacheong Poon */
3531721fffe3SKacheong Poon if (SEQ_LT(tcp->tcp_rexmit_nxt, tcp->tcp_rexmit_max)) {
3532721fffe3SKacheong Poon smax = tcp->tcp_rexmit_max;
3533721fffe3SKacheong Poon snxt = tcp->tcp_rexmit_nxt;
3534721fffe3SKacheong Poon if (SEQ_LT(snxt, tcp->tcp_suna)) {
3535721fffe3SKacheong Poon snxt = tcp->tcp_suna;
3536721fffe3SKacheong Poon }
3537721fffe3SKacheong Poon win = MIN(tcp->tcp_cwnd, tcp->tcp_swnd);
3538721fffe3SKacheong Poon win -= snxt - tcp->tcp_suna;
3539721fffe3SKacheong Poon mss = tcp->tcp_mss;
3540721fffe3SKacheong Poon snxt_mp = tcp_get_seg_mp(tcp, snxt, &off);
3541721fffe3SKacheong Poon
3542633fc3a6SSebastien Roy while (SEQ_LT(snxt, smax) && (win > 0) && (snxt_mp != NULL)) {
3543721fffe3SKacheong Poon mblk_t *xmit_mp;
3544721fffe3SKacheong Poon mblk_t *old_snxt_mp = snxt_mp;
3545721fffe3SKacheong Poon uint32_t cnt = mss;
3546721fffe3SKacheong Poon
3547721fffe3SKacheong Poon if (win < cnt) {
3548721fffe3SKacheong Poon cnt = win;
3549721fffe3SKacheong Poon }
3550721fffe3SKacheong Poon if (SEQ_GT(snxt + cnt, smax)) {
3551721fffe3SKacheong Poon cnt = smax - snxt;
3552721fffe3SKacheong Poon }
3553721fffe3SKacheong Poon xmit_mp = tcp_xmit_mp(tcp, snxt_mp, cnt, &off,
3554721fffe3SKacheong Poon &snxt_mp, snxt, B_TRUE, &cnt, B_TRUE);
3555721fffe3SKacheong Poon if (xmit_mp == NULL)
3556721fffe3SKacheong Poon return;
3557721fffe3SKacheong Poon
3558721fffe3SKacheong Poon tcp_send_data(tcp, xmit_mp);
3559721fffe3SKacheong Poon
3560721fffe3SKacheong Poon snxt += cnt;
3561721fffe3SKacheong Poon win -= cnt;
3562721fffe3SKacheong Poon /*
3563721fffe3SKacheong Poon * Update the send timestamp to avoid false
3564721fffe3SKacheong Poon * retransmission.
3565721fffe3SKacheong Poon */
3566c12492cfSSebastien Roy old_snxt_mp->b_prev = (mblk_t *)(intptr_t)gethrtime();
3567721fffe3SKacheong Poon TCPS_BUMP_MIB(tcps, tcpRetransSegs);
3568721fffe3SKacheong Poon TCPS_UPDATE_MIB(tcps, tcpRetransBytes, cnt);
3569a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_retrans_segs++;
3570a2f04351SSebastien Roy tcp->tcp_cs.tcp_out_retrans_bytes += cnt;
3571721fffe3SKacheong Poon
3572721fffe3SKacheong Poon tcp->tcp_rexmit_nxt = snxt;
3573721fffe3SKacheong Poon }
3574721fffe3SKacheong Poon /*
3575721fffe3SKacheong Poon * If we have transmitted all we have at the time
3576721fffe3SKacheong Poon * we started the retranmission, we can leave
3577721fffe3SKacheong Poon * the rest of the job to tcp_wput_data(). But we
3578721fffe3SKacheong Poon * need to check the send window first. If the
3579721fffe3SKacheong Poon * win is not 0, go on with tcp_wput_data().
3580721fffe3SKacheong Poon */
3581721fffe3SKacheong Poon if (SEQ_LT(snxt, smax) || win == 0) {
3582721fffe3SKacheong Poon return;
3583721fffe3SKacheong Poon }
3584721fffe3SKacheong Poon }
3585721fffe3SKacheong Poon /* Only call tcp_wput_data() if there is data to be sent. */
3586721fffe3SKacheong Poon if (tcp->tcp_unsent) {
3587721fffe3SKacheong Poon tcp_wput_data(tcp, NULL, B_FALSE);
3588721fffe3SKacheong Poon }
3589721fffe3SKacheong Poon }
3590721fffe3SKacheong Poon
3591721fffe3SKacheong Poon /*
3592721fffe3SKacheong Poon * Do slow start retransmission after ICMP errors of PMTU changes.
3593721fffe3SKacheong Poon */
3594721fffe3SKacheong Poon void
tcp_rexmit_after_error(tcp_t * tcp)3595721fffe3SKacheong Poon tcp_rexmit_after_error(tcp_t *tcp)
3596721fffe3SKacheong Poon {
3597721fffe3SKacheong Poon /*
3598721fffe3SKacheong Poon * All sent data has been acknowledged or no data left to send, just
3599721fffe3SKacheong Poon * to return.
3600721fffe3SKacheong Poon */
3601721fffe3SKacheong Poon if (!SEQ_LT(tcp->tcp_suna, tcp->tcp_snxt) ||
3602721fffe3SKacheong Poon (tcp->tcp_xmit_head == NULL))
3603721fffe3SKacheong Poon return;
3604721fffe3SKacheong Poon
3605721fffe3SKacheong Poon if ((tcp->tcp_valid_bits & TCP_FSS_VALID) && (tcp->tcp_unsent == 0))
3606721fffe3SKacheong Poon tcp->tcp_rexmit_max = tcp->tcp_fss;
3607721fffe3SKacheong Poon else
3608721fffe3SKacheong Poon tcp->tcp_rexmit_max = tcp->tcp_snxt;
3609721fffe3SKacheong Poon
3610721fffe3SKacheong Poon tcp->tcp_rexmit_nxt = tcp->tcp_suna;
3611721fffe3SKacheong Poon tcp->tcp_rexmit = B_TRUE;
3612721fffe3SKacheong Poon tcp->tcp_dupack_cnt = 0;
3613721fffe3SKacheong Poon tcp_ss_rexmit(tcp);
3614721fffe3SKacheong Poon }
3615721fffe3SKacheong Poon
3616721fffe3SKacheong Poon /*
3617721fffe3SKacheong Poon * tcp_get_seg_mp() is called to get the pointer to a segment in the
3618721fffe3SKacheong Poon * send queue which starts at the given sequence number. If the given
3619721fffe3SKacheong Poon * sequence number is equal to last valid sequence number (tcp_snxt), the
3620721fffe3SKacheong Poon * returned mblk is the last valid mblk, and off is set to the length of
3621721fffe3SKacheong Poon * that mblk.
3622721fffe3SKacheong Poon *
3623721fffe3SKacheong Poon * send queue which starts at the given seq. no.
3624721fffe3SKacheong Poon *
3625721fffe3SKacheong Poon * Parameters:
3626721fffe3SKacheong Poon * tcp_t *tcp: the tcp instance pointer.
3627721fffe3SKacheong Poon * uint32_t seq: the starting seq. no of the requested segment.
3628721fffe3SKacheong Poon * int32_t *off: after the execution, *off will be the offset to
3629721fffe3SKacheong Poon * the returned mblk which points to the requested seq no.
3630721fffe3SKacheong Poon * It is the caller's responsibility to send in a non-null off.
3631721fffe3SKacheong Poon *
3632721fffe3SKacheong Poon * Return:
3633721fffe3SKacheong Poon * A mblk_t pointer pointing to the requested segment in send queue.
3634721fffe3SKacheong Poon */
3635721fffe3SKacheong Poon static mblk_t *
tcp_get_seg_mp(tcp_t * tcp,uint32_t seq,int32_t * off)3636721fffe3SKacheong Poon tcp_get_seg_mp(tcp_t *tcp, uint32_t seq, int32_t *off)
3637721fffe3SKacheong Poon {
3638721fffe3SKacheong Poon int32_t cnt;
3639721fffe3SKacheong Poon mblk_t *mp;
3640721fffe3SKacheong Poon
3641721fffe3SKacheong Poon /* Defensive coding. Make sure we don't send incorrect data. */
3642721fffe3SKacheong Poon if (SEQ_LT(seq, tcp->tcp_suna) || SEQ_GT(seq, tcp->tcp_snxt))
3643721fffe3SKacheong Poon return (NULL);
3644721fffe3SKacheong Poon
3645721fffe3SKacheong Poon cnt = seq - tcp->tcp_suna;
3646721fffe3SKacheong Poon mp = tcp->tcp_xmit_head;
3647721fffe3SKacheong Poon while (cnt > 0 && mp != NULL) {
3648721fffe3SKacheong Poon cnt -= mp->b_wptr - mp->b_rptr;
3649721fffe3SKacheong Poon if (cnt <= 0) {
3650721fffe3SKacheong Poon cnt += mp->b_wptr - mp->b_rptr;
3651721fffe3SKacheong Poon break;
3652721fffe3SKacheong Poon }
3653721fffe3SKacheong Poon mp = mp->b_cont;
3654721fffe3SKacheong Poon }
3655721fffe3SKacheong Poon ASSERT(mp != NULL);
3656721fffe3SKacheong Poon *off = cnt;
3657721fffe3SKacheong Poon return (mp);
3658721fffe3SKacheong Poon }
3659721fffe3SKacheong Poon
3660721fffe3SKacheong Poon /*
3661721fffe3SKacheong Poon * This routine adjusts next-to-send sequence number variables, in the
3662721fffe3SKacheong Poon * case where the reciever has shrunk it's window.
3663721fffe3SKacheong Poon */
3664721fffe3SKacheong Poon void
tcp_update_xmit_tail(tcp_t * tcp,uint32_t snxt)3665721fffe3SKacheong Poon tcp_update_xmit_tail(tcp_t *tcp, uint32_t snxt)
3666721fffe3SKacheong Poon {
3667721fffe3SKacheong Poon mblk_t *xmit_tail;
3668721fffe3SKacheong Poon int32_t offset;
3669721fffe3SKacheong Poon
3670721fffe3SKacheong Poon tcp->tcp_snxt = snxt;
3671721fffe3SKacheong Poon
3672721fffe3SKacheong Poon /* Get the mblk, and the offset in it, as per the shrunk window */
3673721fffe3SKacheong Poon xmit_tail = tcp_get_seg_mp(tcp, snxt, &offset);
3674721fffe3SKacheong Poon ASSERT(xmit_tail != NULL);
3675721fffe3SKacheong Poon tcp->tcp_xmit_tail = xmit_tail;
3676721fffe3SKacheong Poon tcp->tcp_xmit_tail_unsent = xmit_tail->b_wptr -
3677721fffe3SKacheong Poon xmit_tail->b_rptr - offset;
3678721fffe3SKacheong Poon }
3679721fffe3SKacheong Poon
3680721fffe3SKacheong Poon /*
3681721fffe3SKacheong Poon * This handles the case when the receiver has shrunk its win. Per RFC 1122
3682721fffe3SKacheong Poon * if the receiver shrinks the window, i.e. moves the right window to the
3683721fffe3SKacheong Poon * left, the we should not send new data, but should retransmit normally the
3684721fffe3SKacheong Poon * old unacked data between suna and suna + swnd. We might has sent data
3685721fffe3SKacheong Poon * that is now outside the new window, pretend that we didn't send it.
3686721fffe3SKacheong Poon */
3687721fffe3SKacheong Poon static void
tcp_process_shrunk_swnd(tcp_t * tcp,uint32_t shrunk_count)3688721fffe3SKacheong Poon tcp_process_shrunk_swnd(tcp_t *tcp, uint32_t shrunk_count)
3689721fffe3SKacheong Poon {
3690721fffe3SKacheong Poon uint32_t snxt = tcp->tcp_snxt;
3691721fffe3SKacheong Poon
3692721fffe3SKacheong Poon ASSERT(shrunk_count > 0);
3693721fffe3SKacheong Poon
3694721fffe3SKacheong Poon if (!tcp->tcp_is_wnd_shrnk) {
3695721fffe3SKacheong Poon tcp->tcp_snxt_shrunk = snxt;
3696721fffe3SKacheong Poon tcp->tcp_is_wnd_shrnk = B_TRUE;
3697721fffe3SKacheong Poon } else if (SEQ_GT(snxt, tcp->tcp_snxt_shrunk)) {
3698721fffe3SKacheong Poon tcp->tcp_snxt_shrunk = snxt;
3699721fffe3SKacheong Poon }
3700721fffe3SKacheong Poon
3701721fffe3SKacheong Poon /* Pretend we didn't send the data outside the window */
3702721fffe3SKacheong Poon snxt -= shrunk_count;
3703721fffe3SKacheong Poon
3704721fffe3SKacheong Poon /* Reset all the values per the now shrunk window */
3705721fffe3SKacheong Poon tcp_update_xmit_tail(tcp, snxt);
3706721fffe3SKacheong Poon tcp->tcp_unsent += shrunk_count;
3707721fffe3SKacheong Poon
3708721fffe3SKacheong Poon /*
3709721fffe3SKacheong Poon * If the SACK option is set, delete the entire list of
3710721fffe3SKacheong Poon * notsack'ed blocks.
3711721fffe3SKacheong Poon */
371266cd0f60SKacheong Poon TCP_NOTSACK_REMOVE_ALL(tcp->tcp_notsack_list, tcp);
3713721fffe3SKacheong Poon
3714721fffe3SKacheong Poon if (tcp->tcp_suna == tcp->tcp_snxt && tcp->tcp_swnd == 0)
3715721fffe3SKacheong Poon /*
3716721fffe3SKacheong Poon * Make sure the timer is running so that we will probe a zero
3717721fffe3SKacheong Poon * window.
3718721fffe3SKacheong Poon */
3719721fffe3SKacheong Poon TCP_TIMER_RESTART(tcp, tcp->tcp_rto);
3720721fffe3SKacheong Poon }
3721721fffe3SKacheong Poon
3722721fffe3SKacheong Poon /*
3723721fffe3SKacheong Poon * tcp_fill_header is called by tcp_send() to fill the outgoing TCP header
3724721fffe3SKacheong Poon * with the template header, as well as other options such as time-stamp,
3725721fffe3SKacheong Poon * ECN and/or SACK.
3726721fffe3SKacheong Poon */
3727721fffe3SKacheong Poon static void
tcp_fill_header(tcp_t * tcp,uchar_t * rptr,int num_sack_blk)3728c12492cfSSebastien Roy tcp_fill_header(tcp_t *tcp, uchar_t *rptr, int num_sack_blk)
3729721fffe3SKacheong Poon {
3730721fffe3SKacheong Poon tcpha_t *tcp_tmpl, *tcpha;
3731721fffe3SKacheong Poon uint32_t *dst, *src;
3732721fffe3SKacheong Poon int hdrlen;
3733721fffe3SKacheong Poon conn_t *connp = tcp->tcp_connp;
3734721fffe3SKacheong Poon
3735721fffe3SKacheong Poon ASSERT(OK_32PTR(rptr));
3736721fffe3SKacheong Poon
3737721fffe3SKacheong Poon /* Template header */
3738721fffe3SKacheong Poon tcp_tmpl = tcp->tcp_tcpha;
3739721fffe3SKacheong Poon
3740721fffe3SKacheong Poon /* Header of outgoing packet */
3741721fffe3SKacheong Poon tcpha = (tcpha_t *)(rptr + connp->conn_ixa->ixa_ip_hdr_length);
3742721fffe3SKacheong Poon
3743721fffe3SKacheong Poon /* dst and src are opaque 32-bit fields, used for copying */
3744721fffe3SKacheong Poon dst = (uint32_t *)rptr;
3745721fffe3SKacheong Poon src = (uint32_t *)connp->conn_ht_iphc;
3746721fffe3SKacheong Poon hdrlen = connp->conn_ht_iphc_len;
3747721fffe3SKacheong Poon
3748721fffe3SKacheong Poon /* Fill time-stamp option if needed */
3749721fffe3SKacheong Poon if (tcp->tcp_snd_ts_ok) {
3750c12492cfSSebastien Roy U32_TO_BE32(LBOLT_FASTPATH,
3751721fffe3SKacheong Poon (char *)tcp_tmpl + TCP_MIN_HEADER_LENGTH + 4);
3752721fffe3SKacheong Poon U32_TO_BE32(tcp->tcp_ts_recent,
3753721fffe3SKacheong Poon (char *)tcp_tmpl + TCP_MIN_HEADER_LENGTH + 8);
3754721fffe3SKacheong Poon } else {
3755721fffe3SKacheong Poon ASSERT(connp->conn_ht_ulp_len == TCP_MIN_HEADER_LENGTH);
3756721fffe3SKacheong Poon }
3757721fffe3SKacheong Poon
3758721fffe3SKacheong Poon /*
3759721fffe3SKacheong Poon * Copy the template header; is this really more efficient than
3760721fffe3SKacheong Poon * calling bcopy()? For simple IPv4/TCP, it may be the case,
3761721fffe3SKacheong Poon * but perhaps not for other scenarios.
3762721fffe3SKacheong Poon */
3763721fffe3SKacheong Poon dst[0] = src[0];
3764721fffe3SKacheong Poon dst[1] = src[1];
3765721fffe3SKacheong Poon dst[2] = src[2];
3766721fffe3SKacheong Poon dst[3] = src[3];
3767721fffe3SKacheong Poon dst[4] = src[4];
3768721fffe3SKacheong Poon dst[5] = src[5];
3769721fffe3SKacheong Poon dst[6] = src[6];
3770721fffe3SKacheong Poon dst[7] = src[7];
3771721fffe3SKacheong Poon dst[8] = src[8];
3772721fffe3SKacheong Poon dst[9] = src[9];
3773721fffe3SKacheong Poon if (hdrlen -= 40) {
3774721fffe3SKacheong Poon hdrlen >>= 2;
3775721fffe3SKacheong Poon dst += 10;
3776721fffe3SKacheong Poon src += 10;
3777721fffe3SKacheong Poon do {
3778721fffe3SKacheong Poon *dst++ = *src++;
3779721fffe3SKacheong Poon } while (--hdrlen);
3780721fffe3SKacheong Poon }
3781721fffe3SKacheong Poon
3782721fffe3SKacheong Poon /*
3783721fffe3SKacheong Poon * Set the ECN info in the TCP header if it is not a zero
3784721fffe3SKacheong Poon * window probe. Zero window probe is only sent in
3785721fffe3SKacheong Poon * tcp_wput_data() and tcp_timer().
3786721fffe3SKacheong Poon */
3787721fffe3SKacheong Poon if (tcp->tcp_ecn_ok && !tcp->tcp_zero_win_probe) {
3788721fffe3SKacheong Poon TCP_SET_ECT(tcp, rptr);
3789721fffe3SKacheong Poon
3790721fffe3SKacheong Poon if (tcp->tcp_ecn_echo_on)
3791721fffe3SKacheong Poon tcpha->tha_flags |= TH_ECE;
3792721fffe3SKacheong Poon if (tcp->tcp_cwr && !tcp->tcp_ecn_cwr_sent) {
3793721fffe3SKacheong Poon tcpha->tha_flags |= TH_CWR;
3794721fffe3SKacheong Poon tcp->tcp_ecn_cwr_sent = B_TRUE;
3795721fffe3SKacheong Poon }
3796721fffe3SKacheong Poon }
3797721fffe3SKacheong Poon
3798721fffe3SKacheong Poon /* Fill in SACK options */
3799721fffe3SKacheong Poon if (num_sack_blk > 0) {
3800721fffe3SKacheong Poon uchar_t *wptr = rptr + connp->conn_ht_iphc_len;
3801721fffe3SKacheong Poon sack_blk_t *tmp;
3802721fffe3SKacheong Poon int32_t i;
3803721fffe3SKacheong Poon
3804721fffe3SKacheong Poon wptr[0] = TCPOPT_NOP;
3805721fffe3SKacheong Poon wptr[1] = TCPOPT_NOP;
3806721fffe3SKacheong Poon wptr[2] = TCPOPT_SACK;
3807721fffe3SKacheong Poon wptr[3] = TCPOPT_HEADER_LEN + num_sack_blk *
3808721fffe3SKacheong Poon sizeof (sack_blk_t);
3809721fffe3SKacheong Poon wptr += TCPOPT_REAL_SACK_LEN;
3810721fffe3SKacheong Poon
3811721fffe3SKacheong Poon tmp = tcp->tcp_sack_list;
3812721fffe3SKacheong Poon for (i = 0; i < num_sack_blk; i++) {
3813721fffe3SKacheong Poon U32_TO_BE32(tmp[i].begin, wptr);
3814721fffe3SKacheong Poon wptr += sizeof (tcp_seq);
3815721fffe3SKacheong Poon U32_TO_BE32(tmp[i].end, wptr);
3816721fffe3SKacheong Poon wptr += sizeof (tcp_seq);
3817721fffe3SKacheong Poon }
3818721fffe3SKacheong Poon tcpha->tha_offset_and_reserved +=
3819721fffe3SKacheong Poon ((num_sack_blk * 2 + 1) << 4);
3820721fffe3SKacheong Poon }
3821721fffe3SKacheong Poon }
3822