1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <sys/systm.h>
28 #include <sys/stream.h>
29 #include <sys/cmn_err.h>
30 #define _SUN_TPI_VERSION 2
31 #include <sys/tihdr.h>
32 #include <sys/socket.h>
33 #include <sys/stropts.h>
34 #include <sys/strsun.h>
35 #include <sys/strsubr.h>
36 #include <sys/socketvar.h>
37 #include <inet/common.h>
38 #include <inet/mi.h>
39 #include <inet/ip.h>
40 #include <inet/ip_ire.h>
41 #include <inet/ip6.h>
42 #include <inet/sctp_ip.h>
43 #include <inet/ipclassifier.h>
44
45 /*
46 * PR-SCTP comments.
47 *
48 * A message can expire before it gets to the transmit list (i.e. it is still
49 * in the unsent list - unchunked), after it gets to the transmit list, but
50 * before transmission has actually started, or after transmission has begun.
51 * Accordingly, we check for the status of a message in sctp_chunkify() when
52 * the message is being transferred from the unsent list to the transmit list;
53 * in sctp_get_msg_to_send(), when we get the next chunk from the transmit
54 * list and in sctp_rexmit() when we get the next chunk to be (re)transmitted.
55 * When we nuke a message in sctp_chunkify(), all we need to do is take it
56 * out of the unsent list and update sctp_unsent; when a message is deemed
57 * timed-out in sctp_get_msg_to_send() we can just take it out of the transmit
58 * list, update sctp_unsent IFF transmission for the message has not yet begun
59 * (i.e. !SCTP_CHUNK_ISSENT(meta->b_cont)). However, if transmission for the
60 * message has started, then we cannot just take it out of the list, we need
61 * to send Forward TSN chunk to the peer so that the peer can clear its
62 * fragment list for this message. However, we cannot just send the Forward
63 * TSN in sctp_get_msg_to_send() because there might be unacked chunks for
64 * messages preceeding this abandoned message. So, we send a Forward TSN
65 * IFF all messages prior to this abandoned message has been SACKd, if not
66 * we defer sending the Forward TSN to sctp_cumack(), which will check for
67 * this condition and send the Forward TSN via sctp_check_abandoned_msg(). In
68 * sctp_rexmit() when we check for retransmissions, we need to determine if
69 * the advanced peer ack point can be moved ahead, and if so, send a Forward
70 * TSN to the peer instead of retransmitting the chunk. Note that when
71 * we send a Forward TSN for a message, there may be yet unsent chunks for
72 * this message; we need to mark all such chunks as abandoned, so that
73 * sctp_cumack() can take the message out of the transmit list, additionally
74 * sctp_unsent need to be adjusted. Whenever sctp_unsent is updated (i.e.
75 * decremented when a message/chunk is deemed abandoned), sockfs needs to
76 * be notified so that it can adjust its idea of the queued message.
77 */
78
79 #include "sctp_impl.h"
80
81 static struct kmem_cache *sctp_kmem_ftsn_set_cache;
82 static mblk_t *sctp_chunkify(sctp_t *, int, int, int);
83
84 #ifdef DEBUG
85 static boolean_t sctp_verify_chain(mblk_t *, mblk_t *);
86 #endif
87
88 /*
89 * Called to allocate a header mblk when sending data to SCTP.
90 * Data will follow in b_cont of this mblk.
91 */
92 mblk_t *
sctp_alloc_hdr(const char * name,int nlen,const char * control,int clen,int flags)93 sctp_alloc_hdr(const char *name, int nlen, const char *control, int clen,
94 int flags)
95 {
96 mblk_t *mp;
97 struct T_unitdata_req *tudr;
98 size_t size;
99 int error;
100
101 size = sizeof (*tudr) + _TPI_ALIGN_TOPT(nlen) + clen;
102 size = MAX(size, sizeof (sctp_msg_hdr_t));
103 if (flags & SCTP_CAN_BLOCK) {
104 mp = allocb_wait(size, BPRI_MED, 0, &error);
105 } else {
106 mp = allocb(size, BPRI_MED);
107 }
108 if (mp) {
109 tudr = (struct T_unitdata_req *)mp->b_rptr;
110 tudr->PRIM_type = T_UNITDATA_REQ;
111 tudr->DEST_length = nlen;
112 tudr->DEST_offset = sizeof (*tudr);
113 tudr->OPT_length = clen;
114 tudr->OPT_offset = (t_scalar_t)(sizeof (*tudr) +
115 _TPI_ALIGN_TOPT(nlen));
116 if (nlen > 0)
117 bcopy(name, tudr + 1, nlen);
118 if (clen > 0)
119 bcopy(control, (char *)tudr + tudr->OPT_offset, clen);
120 mp->b_wptr += (tudr ->OPT_offset + clen);
121 mp->b_datap->db_type = M_PROTO;
122 }
123 return (mp);
124 }
125
126 /*ARGSUSED2*/
127 int
sctp_sendmsg(sctp_t * sctp,mblk_t * mp,int flags)128 sctp_sendmsg(sctp_t *sctp, mblk_t *mp, int flags)
129 {
130 sctp_faddr_t *fp = NULL;
131 struct T_unitdata_req *tudr;
132 int error = 0;
133 mblk_t *mproto = mp;
134 in6_addr_t *addr;
135 in6_addr_t tmpaddr;
136 uint16_t sid = sctp->sctp_def_stream;
137 uint32_t ppid = sctp->sctp_def_ppid;
138 uint32_t context = sctp->sctp_def_context;
139 uint16_t msg_flags = sctp->sctp_def_flags;
140 sctp_msg_hdr_t *sctp_msg_hdr;
141 uint32_t msg_len = 0;
142 uint32_t timetolive = sctp->sctp_def_timetolive;
143 conn_t *connp = sctp->sctp_connp;
144
145 ASSERT(DB_TYPE(mproto) == M_PROTO);
146
147 mp = mp->b_cont;
148 ASSERT(mp == NULL || DB_TYPE(mp) == M_DATA);
149
150 tudr = (struct T_unitdata_req *)mproto->b_rptr;
151 ASSERT(tudr->PRIM_type == T_UNITDATA_REQ);
152
153 /* Get destination address, if specified */
154 if (tudr->DEST_length > 0) {
155 sin_t *sin;
156 sin6_t *sin6;
157
158 sin = (struct sockaddr_in *)
159 (mproto->b_rptr + tudr->DEST_offset);
160 switch (sin->sin_family) {
161 case AF_INET:
162 if (tudr->DEST_length < sizeof (*sin)) {
163 return (EINVAL);
164 }
165 IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &tmpaddr);
166 addr = &tmpaddr;
167 break;
168 case AF_INET6:
169 if (tudr->DEST_length < sizeof (*sin6)) {
170 return (EINVAL);
171 }
172 sin6 = (struct sockaddr_in6 *)
173 (mproto->b_rptr + tudr->DEST_offset);
174 addr = &sin6->sin6_addr;
175 break;
176 default:
177 return (EAFNOSUPPORT);
178 }
179 fp = sctp_lookup_faddr(sctp, addr);
180 if (fp == NULL) {
181 return (EINVAL);
182 }
183 }
184 /* Ancillary Data? */
185 if (tudr->OPT_length > 0) {
186 struct cmsghdr *cmsg;
187 char *cend;
188 struct sctp_sndrcvinfo *sndrcv;
189
190 cmsg = (struct cmsghdr *)(mproto->b_rptr + tudr->OPT_offset);
191 cend = ((char *)cmsg + tudr->OPT_length);
192 ASSERT(cend <= (char *)mproto->b_wptr);
193
194 for (;;) {
195 if ((char *)(cmsg + 1) > cend ||
196 ((char *)cmsg + cmsg->cmsg_len) > cend) {
197 break;
198 }
199 if ((cmsg->cmsg_level == IPPROTO_SCTP) &&
200 (cmsg->cmsg_type == SCTP_SNDRCV)) {
201 if (cmsg->cmsg_len <
202 (sizeof (*sndrcv) + sizeof (*cmsg))) {
203 return (EINVAL);
204 }
205 sndrcv = (struct sctp_sndrcvinfo *)(cmsg + 1);
206 sid = sndrcv->sinfo_stream;
207 msg_flags = sndrcv->sinfo_flags;
208 ppid = sndrcv->sinfo_ppid;
209 context = sndrcv->sinfo_context;
210 timetolive = sndrcv->sinfo_timetolive;
211 break;
212 }
213 if (cmsg->cmsg_len > 0)
214 cmsg = CMSG_NEXT(cmsg);
215 else
216 break;
217 }
218 }
219 if (msg_flags & MSG_ABORT) {
220 if (mp && mp->b_cont) {
221 mblk_t *pump = msgpullup(mp, -1);
222 if (!pump) {
223 return (ENOMEM);
224 }
225 freemsg(mp);
226 mp = pump;
227 mproto->b_cont = mp;
228 }
229 RUN_SCTP(sctp);
230 sctp_user_abort(sctp, mp);
231 freemsg(mproto);
232 goto done2;
233 }
234 if (mp == NULL)
235 goto done;
236
237 RUN_SCTP(sctp);
238
239 /* Reject any new data requests if we are shutting down */
240 if (sctp->sctp_state > SCTPS_ESTABLISHED ||
241 (sctp->sctp_connp->conn_state_flags & CONN_CLOSING)) {
242 error = EPIPE;
243 goto unlock_done;
244 }
245
246 /* Re-use the mproto to store relevant info. */
247 ASSERT(MBLKSIZE(mproto) >= sizeof (*sctp_msg_hdr));
248
249 mproto->b_rptr = mproto->b_datap->db_base;
250 mproto->b_wptr = mproto->b_rptr + sizeof (*sctp_msg_hdr);
251
252 sctp_msg_hdr = (sctp_msg_hdr_t *)mproto->b_rptr;
253 bzero(sctp_msg_hdr, sizeof (*sctp_msg_hdr));
254 sctp_msg_hdr->smh_context = context;
255 sctp_msg_hdr->smh_sid = sid;
256 sctp_msg_hdr->smh_ppid = ppid;
257 sctp_msg_hdr->smh_flags = msg_flags;
258 sctp_msg_hdr->smh_ttl = MSEC_TO_TICK(timetolive);
259 sctp_msg_hdr->smh_tob = ddi_get_lbolt64();
260 for (; mp != NULL; mp = mp->b_cont)
261 msg_len += MBLKL(mp);
262 sctp_msg_hdr->smh_msglen = msg_len;
263
264 /* User requested specific destination */
265 SCTP_SET_CHUNK_DEST(mproto, fp);
266
267 if (sctp->sctp_state >= SCTPS_COOKIE_ECHOED &&
268 sid >= sctp->sctp_num_ostr) {
269 /* Send sendfail event */
270 sctp_sendfail_event(sctp, dupmsg(mproto), SCTP_ERR_BAD_SID,
271 B_FALSE);
272 error = EINVAL;
273 goto unlock_done;
274 }
275
276 /* no data */
277 if (msg_len == 0) {
278 sctp_sendfail_event(sctp, dupmsg(mproto),
279 SCTP_ERR_NO_USR_DATA, B_FALSE);
280 error = EINVAL;
281 goto unlock_done;
282 }
283
284 /* Add it to the unsent list */
285 if (sctp->sctp_xmit_unsent == NULL) {
286 sctp->sctp_xmit_unsent = sctp->sctp_xmit_unsent_tail = mproto;
287 } else {
288 sctp->sctp_xmit_unsent_tail->b_next = mproto;
289 sctp->sctp_xmit_unsent_tail = mproto;
290 }
291 sctp->sctp_unsent += msg_len;
292 BUMP_LOCAL(sctp->sctp_msgcount);
293 /*
294 * Notify sockfs if the tx queue is full.
295 */
296 if (SCTP_TXQ_LEN(sctp) >= connp->conn_sndbuf) {
297 sctp->sctp_txq_full = 1;
298 sctp->sctp_ulp_txq_full(sctp->sctp_ulpd, B_TRUE);
299 }
300 if (sctp->sctp_state == SCTPS_ESTABLISHED)
301 sctp_output(sctp, UINT_MAX);
302 done2:
303 WAKE_SCTP(sctp);
304 return (0);
305 unlock_done:
306 WAKE_SCTP(sctp);
307 done:
308 return (error);
309 }
310
311 /*
312 * While there are messages on sctp_xmit_unsent, detach each one. For each:
313 * allocate space for the chunk header, fill in the data chunk, and fill in
314 * the chunk header. Then append it to sctp_xmit_tail.
315 * Return after appending as many bytes as required (bytes_to_send).
316 * We also return if we've appended one or more chunks, and find a subsequent
317 * unsent message is too big to fit in the segment.
318 */
319 mblk_t *
sctp_chunkify(sctp_t * sctp,int mss,int firstseg_len,int bytes_to_send)320 sctp_chunkify(sctp_t *sctp, int mss, int firstseg_len, int bytes_to_send)
321 {
322 mblk_t *mp;
323 mblk_t *chunk_mp;
324 mblk_t *chunk_head;
325 mblk_t *chunk_hdr;
326 mblk_t *chunk_tail = NULL;
327 int count;
328 int chunksize;
329 sctp_data_hdr_t *sdc;
330 mblk_t *mdblk = sctp->sctp_xmit_unsent;
331 sctp_faddr_t *fp;
332 sctp_faddr_t *fp1;
333 size_t xtralen;
334 sctp_msg_hdr_t *msg_hdr;
335 sctp_stack_t *sctps = sctp->sctp_sctps;
336 sctp_msg_hdr_t *next_msg_hdr;
337 size_t nextlen;
338 int remaining_len = mss - firstseg_len;
339
340 ASSERT(remaining_len >= 0);
341
342 fp = SCTP_CHUNK_DEST(mdblk);
343 if (fp == NULL)
344 fp = sctp->sctp_current;
345 if (fp->sf_isv4)
346 xtralen = sctp->sctp_hdr_len + sctps->sctps_wroff_xtra +
347 sizeof (*sdc);
348 else
349 xtralen = sctp->sctp_hdr6_len + sctps->sctps_wroff_xtra +
350 sizeof (*sdc);
351 count = chunksize = remaining_len - sizeof (*sdc);
352 nextmsg:
353 next_msg_hdr = (sctp_msg_hdr_t *)sctp->sctp_xmit_unsent->b_rptr;
354 nextlen = next_msg_hdr->smh_msglen;
355 /*
356 * Will the entire next message fit in the current packet ?
357 * if not, leave it on the unsent list.
358 */
359 if ((firstseg_len != 0) && (nextlen > remaining_len))
360 return (NULL);
361
362 chunk_mp = mdblk->b_cont;
363
364 /*
365 * If this partially chunked, we ignore the next one for now and
366 * use the one already present. For the unchunked bits, we use the
367 * length of the last chunk.
368 */
369 if (SCTP_IS_MSG_CHUNKED(mdblk)) {
370 int chunk_len;
371
372 ASSERT(chunk_mp->b_next != NULL);
373 mdblk->b_cont = chunk_mp->b_next;
374 chunk_mp->b_next = NULL;
375 SCTP_MSG_CLEAR_CHUNKED(mdblk);
376 mp = mdblk->b_cont;
377 while (mp->b_next != NULL)
378 mp = mp->b_next;
379 chunk_len = ntohs(((sctp_data_hdr_t *)mp->b_rptr)->sdh_len);
380 if (fp->sf_pmss - chunk_len > sizeof (*sdc))
381 count = chunksize = fp->sf_pmss - chunk_len;
382 else
383 count = chunksize = fp->sf_pmss;
384 count = chunksize = count - sizeof (*sdc);
385 } else {
386 msg_hdr = (sctp_msg_hdr_t *)mdblk->b_rptr;
387 if (SCTP_MSG_TO_BE_ABANDONED(mdblk, msg_hdr, sctp)) {
388 sctp->sctp_xmit_unsent = mdblk->b_next;
389 if (sctp->sctp_xmit_unsent == NULL)
390 sctp->sctp_xmit_unsent_tail = NULL;
391 ASSERT(sctp->sctp_unsent >= msg_hdr->smh_msglen);
392 sctp->sctp_unsent -= msg_hdr->smh_msglen;
393 mdblk->b_next = NULL;
394 BUMP_LOCAL(sctp->sctp_prsctpdrop);
395 /*
396 * Update ULP the amount of queued data, which is
397 * sent-unack'ed + unsent.
398 */
399 if (!SCTP_IS_DETACHED(sctp))
400 SCTP_TXQ_UPDATE(sctp);
401 sctp_sendfail_event(sctp, mdblk, 0, B_FALSE);
402 goto try_next;
403 }
404 mdblk->b_cont = NULL;
405 }
406 msg_hdr = (sctp_msg_hdr_t *)mdblk->b_rptr;
407 nextchunk:
408 chunk_head = chunk_mp;
409 chunk_tail = NULL;
410
411 /* Skip as many mblk's as we need */
412 while (chunk_mp != NULL && ((count - MBLKL(chunk_mp)) >= 0)) {
413 count -= MBLKL(chunk_mp);
414 chunk_tail = chunk_mp;
415 chunk_mp = chunk_mp->b_cont;
416 }
417 /* Split the chain, if needed */
418 if (chunk_mp != NULL) {
419 if (count > 0) {
420 mblk_t *split_mp = dupb(chunk_mp);
421
422 if (split_mp == NULL) {
423 if (mdblk->b_cont == NULL) {
424 mdblk->b_cont = chunk_head;
425 } else {
426 SCTP_MSG_SET_CHUNKED(mdblk);
427 ASSERT(chunk_head->b_next == NULL);
428 chunk_head->b_next = mdblk->b_cont;
429 mdblk->b_cont = chunk_head;
430 }
431 return (sctp->sctp_xmit_tail);
432 }
433 if (chunk_tail != NULL) {
434 chunk_tail->b_cont = split_mp;
435 chunk_tail = chunk_tail->b_cont;
436 } else {
437 chunk_head = chunk_tail = split_mp;
438 }
439 chunk_tail->b_wptr = chunk_tail->b_rptr + count;
440 chunk_mp->b_rptr = chunk_tail->b_wptr;
441 count = 0;
442 } else if (chunk_tail == NULL) {
443 goto next;
444 } else {
445 chunk_tail->b_cont = NULL;
446 }
447 }
448 /* Alloc chunk hdr, if needed */
449 if (DB_REF(chunk_head) > 1 ||
450 ((intptr_t)chunk_head->b_rptr) & (SCTP_ALIGN - 1) ||
451 MBLKHEAD(chunk_head) < sizeof (*sdc)) {
452 if ((chunk_hdr = allocb(xtralen, BPRI_MED)) == NULL) {
453 if (mdblk->b_cont == NULL) {
454 if (chunk_mp != NULL)
455 linkb(chunk_head, chunk_mp);
456 mdblk->b_cont = chunk_head;
457 } else {
458 SCTP_MSG_SET_CHUNKED(mdblk);
459 if (chunk_mp != NULL)
460 linkb(chunk_head, chunk_mp);
461 ASSERT(chunk_head->b_next == NULL);
462 chunk_head->b_next = mdblk->b_cont;
463 mdblk->b_cont = chunk_head;
464 }
465 return (sctp->sctp_xmit_tail);
466 }
467 chunk_hdr->b_rptr += xtralen - sizeof (*sdc);
468 chunk_hdr->b_wptr = chunk_hdr->b_rptr + sizeof (*sdc);
469 chunk_hdr->b_cont = chunk_head;
470 } else {
471 chunk_hdr = chunk_head;
472 chunk_hdr->b_rptr -= sizeof (*sdc);
473 }
474 ASSERT(chunk_hdr->b_datap->db_ref == 1);
475 sdc = (sctp_data_hdr_t *)chunk_hdr->b_rptr;
476 sdc->sdh_id = CHUNK_DATA;
477 sdc->sdh_flags = 0;
478 sdc->sdh_len = htons(sizeof (*sdc) + chunksize - count);
479 ASSERT(sdc->sdh_len);
480 sdc->sdh_sid = htons(msg_hdr->smh_sid);
481 /*
482 * We defer assigning the SSN just before sending the chunk, else
483 * if we drop the chunk in sctp_get_msg_to_send(), we would need
484 * to send a Forward TSN to let the peer know. Some more comments
485 * about this in sctp_impl.h for SCTP_CHUNK_SENT.
486 */
487 sdc->sdh_payload_id = msg_hdr->smh_ppid;
488
489 if (mdblk->b_cont == NULL) {
490 mdblk->b_cont = chunk_hdr;
491 SCTP_DATA_SET_BBIT(sdc);
492 } else {
493 mp = mdblk->b_cont;
494 while (mp->b_next != NULL)
495 mp = mp->b_next;
496 mp->b_next = chunk_hdr;
497 }
498
499 bytes_to_send -= (chunksize - count);
500 if (chunk_mp != NULL) {
501 next:
502 count = chunksize = fp->sf_pmss - sizeof (*sdc);
503 goto nextchunk;
504 }
505 SCTP_DATA_SET_EBIT(sdc);
506 sctp->sctp_xmit_unsent = mdblk->b_next;
507 if (mdblk->b_next == NULL) {
508 sctp->sctp_xmit_unsent_tail = NULL;
509 }
510 mdblk->b_next = NULL;
511
512 if (sctp->sctp_xmit_tail == NULL) {
513 sctp->sctp_xmit_head = sctp->sctp_xmit_tail = mdblk;
514 } else {
515 mp = sctp->sctp_xmit_tail;
516 while (mp->b_next != NULL)
517 mp = mp->b_next;
518 mp->b_next = mdblk;
519 mdblk->b_prev = mp;
520 }
521 try_next:
522 if (bytes_to_send > 0 && sctp->sctp_xmit_unsent != NULL) {
523 mdblk = sctp->sctp_xmit_unsent;
524 fp1 = SCTP_CHUNK_DEST(mdblk);
525 if (fp1 == NULL)
526 fp1 = sctp->sctp_current;
527 if (fp == fp1) {
528 size_t len = MBLKL(mdblk->b_cont);
529 if ((count > 0) &&
530 ((len > fp->sf_pmss - sizeof (*sdc)) ||
531 (len <= count))) {
532 count -= sizeof (*sdc);
533 count = chunksize = count - (count & 0x3);
534 } else {
535 count = chunksize = fp->sf_pmss -
536 sizeof (*sdc);
537 }
538 } else {
539 if (fp1->sf_isv4)
540 xtralen = sctp->sctp_hdr_len;
541 else
542 xtralen = sctp->sctp_hdr6_len;
543 xtralen += sctps->sctps_wroff_xtra + sizeof (*sdc);
544 count = chunksize = fp1->sf_pmss - sizeof (*sdc);
545 fp = fp1;
546 }
547 goto nextmsg;
548 }
549 return (sctp->sctp_xmit_tail);
550 }
551
552 void
sctp_free_msg(mblk_t * ump)553 sctp_free_msg(mblk_t *ump)
554 {
555 mblk_t *mp, *nmp;
556
557 for (mp = ump->b_cont; mp; mp = nmp) {
558 nmp = mp->b_next;
559 mp->b_next = mp->b_prev = NULL;
560 freemsg(mp);
561 }
562 ASSERT(!ump->b_prev);
563 ump->b_next = NULL;
564 freeb(ump);
565 }
566
567 mblk_t *
sctp_add_proto_hdr(sctp_t * sctp,sctp_faddr_t * fp,mblk_t * mp,int sacklen,int * error)568 sctp_add_proto_hdr(sctp_t *sctp, sctp_faddr_t *fp, mblk_t *mp, int sacklen,
569 int *error)
570 {
571 int hdrlen;
572 uchar_t *hdr;
573 int isv4 = fp->sf_isv4;
574 sctp_stack_t *sctps = sctp->sctp_sctps;
575
576 if (error != NULL)
577 *error = 0;
578
579 if (isv4) {
580 hdrlen = sctp->sctp_hdr_len;
581 hdr = sctp->sctp_iphc;
582 } else {
583 hdrlen = sctp->sctp_hdr6_len;
584 hdr = sctp->sctp_iphc6;
585 }
586 /*
587 * A reject|blackhole could mean that the address is 'down'. Similarly,
588 * it is possible that the address went down, we tried to send an
589 * heartbeat and ended up setting fp->sf_saddr as unspec because we
590 * didn't have any usable source address. In either case
591 * sctp_get_dest() will try find an IRE, if available, and set
592 * the source address, if needed. If we still don't have any
593 * usable source address, fp->sf_state will be SCTP_FADDRS_UNREACH and
594 * we return EHOSTUNREACH.
595 */
596 ASSERT(fp->sf_ixa->ixa_ire != NULL);
597 if ((fp->sf_ixa->ixa_ire->ire_flags & (RTF_REJECT|RTF_BLACKHOLE)) ||
598 SCTP_IS_ADDR_UNSPEC(fp->sf_isv4, fp->sf_saddr)) {
599 sctp_get_dest(sctp, fp);
600 if (fp->sf_state == SCTP_FADDRS_UNREACH) {
601 if (error != NULL)
602 *error = EHOSTUNREACH;
603 return (NULL);
604 }
605 }
606 /* Copy in IP header. */
607 if ((mp->b_rptr - mp->b_datap->db_base) <
608 (sctps->sctps_wroff_xtra + hdrlen + sacklen) || DB_REF(mp) > 2) {
609 mblk_t *nmp;
610
611 /*
612 * This can happen if IP headers are adjusted after
613 * data was moved into chunks, or during retransmission,
614 * or things like snoop is running.
615 */
616 nmp = allocb(sctps->sctps_wroff_xtra + hdrlen + sacklen,
617 BPRI_MED);
618 if (nmp == NULL) {
619 if (error != NULL)
620 *error = ENOMEM;
621 return (NULL);
622 }
623 nmp->b_rptr += sctps->sctps_wroff_xtra;
624 nmp->b_wptr = nmp->b_rptr + hdrlen + sacklen;
625 nmp->b_cont = mp;
626 mp = nmp;
627 } else {
628 mp->b_rptr -= (hdrlen + sacklen);
629 }
630 bcopy(hdr, mp->b_rptr, hdrlen);
631 if (sacklen) {
632 sctp_fill_sack(sctp, mp->b_rptr + hdrlen, sacklen);
633 }
634 if (fp != sctp->sctp_current) {
635 /* change addresses in header */
636 if (isv4) {
637 ipha_t *iph = (ipha_t *)mp->b_rptr;
638
639 IN6_V4MAPPED_TO_IPADDR(&fp->sf_faddr, iph->ipha_dst);
640 if (!IN6_IS_ADDR_V4MAPPED_ANY(&fp->sf_saddr)) {
641 IN6_V4MAPPED_TO_IPADDR(&fp->sf_saddr,
642 iph->ipha_src);
643 } else if (sctp->sctp_bound_to_all) {
644 iph->ipha_src = INADDR_ANY;
645 }
646 } else {
647 ip6_t *ip6h = (ip6_t *)mp->b_rptr;
648
649 ip6h->ip6_dst = fp->sf_faddr;
650 if (!IN6_IS_ADDR_UNSPECIFIED(&fp->sf_saddr)) {
651 ip6h->ip6_src = fp->sf_saddr;
652 } else if (sctp->sctp_bound_to_all) {
653 ip6h->ip6_src = ipv6_all_zeros;
654 }
655 }
656 }
657 return (mp);
658 }
659
660 /*
661 * SCTP requires every chunk to be padded so that the total length
662 * is a multiple of SCTP_ALIGN. This function returns a mblk with
663 * the specified pad length.
664 */
665 static mblk_t *
sctp_get_padding(sctp_t * sctp,int pad)666 sctp_get_padding(sctp_t *sctp, int pad)
667 {
668 mblk_t *fill;
669
670 ASSERT(pad < SCTP_ALIGN);
671 ASSERT(sctp->sctp_pad_mp != NULL);
672 if ((fill = dupb(sctp->sctp_pad_mp)) != NULL) {
673 fill->b_wptr += pad;
674 return (fill);
675 }
676
677 /*
678 * The memory saving path of reusing the sctp_pad_mp
679 * fails may be because it has been dupb() too
680 * many times (DBLK_REFMAX). Use the memory consuming
681 * path of allocating the pad mblk.
682 */
683 if ((fill = allocb(SCTP_ALIGN, BPRI_MED)) != NULL) {
684 /* Zero it out. SCTP_ALIGN is sizeof (int32_t) */
685 *(int32_t *)fill->b_rptr = 0;
686 fill->b_wptr += pad;
687 }
688 return (fill);
689 }
690
691 static mblk_t *
sctp_find_fast_rexmit_mblks(sctp_t * sctp,int * total,sctp_faddr_t ** fp)692 sctp_find_fast_rexmit_mblks(sctp_t *sctp, int *total, sctp_faddr_t **fp)
693 {
694 mblk_t *meta;
695 mblk_t *start_mp = NULL;
696 mblk_t *end_mp = NULL;
697 mblk_t *mp, *nmp;
698 mblk_t *fill;
699 sctp_data_hdr_t *sdh;
700 int msglen;
701 int extra;
702 sctp_msg_hdr_t *msg_hdr;
703 sctp_faddr_t *old_fp = NULL;
704 sctp_faddr_t *chunk_fp;
705 sctp_stack_t *sctps = sctp->sctp_sctps;
706
707 for (meta = sctp->sctp_xmit_head; meta != NULL; meta = meta->b_next) {
708 msg_hdr = (sctp_msg_hdr_t *)meta->b_rptr;
709 if (SCTP_IS_MSG_ABANDONED(meta) ||
710 SCTP_MSG_TO_BE_ABANDONED(meta, msg_hdr, sctp)) {
711 continue;
712 }
713 for (mp = meta->b_cont; mp != NULL; mp = mp->b_next) {
714 if (SCTP_CHUNK_WANT_REXMIT(mp)) {
715 /*
716 * Use the same peer address to do fast
717 * retransmission. If the original peer
718 * address is dead, switch to the current
719 * one. Record the old one so that we
720 * will pick the chunks sent to the old
721 * one for fast retransmission.
722 */
723 chunk_fp = SCTP_CHUNK_DEST(mp);
724 if (*fp == NULL) {
725 *fp = chunk_fp;
726 if ((*fp)->sf_state !=
727 SCTP_FADDRS_ALIVE) {
728 old_fp = *fp;
729 *fp = sctp->sctp_current;
730 }
731 } else if (old_fp == NULL && *fp != chunk_fp) {
732 continue;
733 } else if (old_fp != NULL &&
734 old_fp != chunk_fp) {
735 continue;
736 }
737
738 sdh = (sctp_data_hdr_t *)mp->b_rptr;
739 msglen = ntohs(sdh->sdh_len);
740 if ((extra = msglen & (SCTP_ALIGN - 1)) != 0) {
741 extra = SCTP_ALIGN - extra;
742 }
743
744 /*
745 * We still return at least the first message
746 * even if that message cannot fit in as
747 * PMTU may have changed.
748 */
749 if (*total + msglen + extra >
750 (*fp)->sf_pmss && start_mp != NULL) {
751 return (start_mp);
752 }
753 if ((nmp = dupmsg(mp)) == NULL)
754 return (start_mp);
755 if (extra > 0) {
756 fill = sctp_get_padding(sctp, extra);
757 if (fill != NULL) {
758 linkb(nmp, fill);
759 } else {
760 return (start_mp);
761 }
762 }
763 SCTPS_BUMP_MIB(sctps, sctpOutFastRetrans);
764 BUMP_LOCAL(sctp->sctp_rxtchunks);
765 SCTP_CHUNK_CLEAR_REXMIT(mp);
766 if (start_mp == NULL) {
767 start_mp = nmp;
768 } else {
769 linkb(end_mp, nmp);
770 }
771 end_mp = nmp;
772 *total += msglen + extra;
773 dprint(2, ("sctp_find_fast_rexmit_mblks: "
774 "tsn %x\n", sdh->sdh_tsn));
775 }
776 }
777 }
778 /* Clear the flag as there is no more message to be fast rexmitted. */
779 sctp->sctp_chk_fast_rexmit = B_FALSE;
780 return (start_mp);
781 }
782
783 /* A debug function just to make sure that a mblk chain is not broken */
784 #ifdef DEBUG
785 static boolean_t
sctp_verify_chain(mblk_t * head,mblk_t * tail)786 sctp_verify_chain(mblk_t *head, mblk_t *tail)
787 {
788 mblk_t *mp = head;
789
790 if (head == NULL || tail == NULL)
791 return (B_TRUE);
792 while (mp != NULL) {
793 if (mp == tail)
794 return (B_TRUE);
795 mp = mp->b_next;
796 }
797 return (B_FALSE);
798 }
799 #endif
800
801 /*
802 * Gets the next unsent chunk to transmit. Messages that are abandoned are
803 * skipped. A message can be abandoned if it has a non-zero timetolive and
804 * transmission has not yet started or if it is a partially reliable
805 * message and its time is up (assuming we are PR-SCTP aware).
806 * We only return a chunk if it will fit entirely in the current packet.
807 * 'cansend' is used to determine if need to try and chunkify messages from
808 * the unsent list, if any, and also as an input to sctp_chunkify() if so.
809 *
810 * firstseg_len indicates the space already used, cansend represents remaining
811 * space in the window, ((sf_pmss - firstseg_len) can therefore reasonably
812 * be used to compute the cansend arg).
813 */
814 mblk_t *
sctp_get_msg_to_send(sctp_t * sctp,mblk_t ** mp,mblk_t * meta,int * error,int32_t firstseg_len,uint32_t cansend,sctp_faddr_t * fp)815 sctp_get_msg_to_send(sctp_t *sctp, mblk_t **mp, mblk_t *meta, int *error,
816 int32_t firstseg_len, uint32_t cansend, sctp_faddr_t *fp)
817 {
818 mblk_t *mp1;
819 sctp_msg_hdr_t *msg_hdr;
820 mblk_t *tmp_meta;
821 sctp_faddr_t *fp1;
822
823 ASSERT(error != NULL && mp != NULL);
824 *error = 0;
825
826 ASSERT(sctp->sctp_current != NULL);
827
828 chunkified:
829 while (meta != NULL) {
830 tmp_meta = meta->b_next;
831 msg_hdr = (sctp_msg_hdr_t *)meta->b_rptr;
832 mp1 = meta->b_cont;
833 if (SCTP_IS_MSG_ABANDONED(meta))
834 goto next_msg;
835 if (!SCTP_MSG_TO_BE_ABANDONED(meta, msg_hdr, sctp)) {
836 while (mp1 != NULL) {
837 if (SCTP_CHUNK_CANSEND(mp1)) {
838 *mp = mp1;
839 #ifdef DEBUG
840 ASSERT(sctp_verify_chain(
841 sctp->sctp_xmit_head, meta));
842 #endif
843 return (meta);
844 }
845 mp1 = mp1->b_next;
846 }
847 goto next_msg;
848 }
849 /*
850 * If we come here and the first chunk is sent, then we
851 * we are PR-SCTP aware, in which case if the cumulative
852 * TSN has moved upto or beyond the first chunk (which
853 * means all the previous messages have been cumulative
854 * SACK'd), then we send a Forward TSN with the last
855 * chunk that was sent in this message. If we can't send
856 * a Forward TSN because previous non-abandoned messages
857 * have not been acked then we will defer the Forward TSN
858 * to sctp_rexmit() or sctp_cumack().
859 */
860 if (SCTP_CHUNK_ISSENT(mp1)) {
861 *error = sctp_check_abandoned_msg(sctp, meta);
862 if (*error != 0) {
863 #ifdef DEBUG
864 ASSERT(sctp_verify_chain(sctp->sctp_xmit_head,
865 sctp->sctp_xmit_tail));
866 #endif
867 return (NULL);
868 }
869 goto next_msg;
870 }
871 BUMP_LOCAL(sctp->sctp_prsctpdrop);
872 ASSERT(sctp->sctp_unsent >= msg_hdr->smh_msglen);
873 if (meta->b_prev == NULL) {
874 ASSERT(sctp->sctp_xmit_head == meta);
875 sctp->sctp_xmit_head = tmp_meta;
876 if (sctp->sctp_xmit_tail == meta)
877 sctp->sctp_xmit_tail = tmp_meta;
878 meta->b_next = NULL;
879 if (tmp_meta != NULL)
880 tmp_meta->b_prev = NULL;
881 } else if (meta->b_next == NULL) {
882 if (sctp->sctp_xmit_tail == meta)
883 sctp->sctp_xmit_tail = meta->b_prev;
884 meta->b_prev->b_next = NULL;
885 meta->b_prev = NULL;
886 } else {
887 meta->b_prev->b_next = tmp_meta;
888 tmp_meta->b_prev = meta->b_prev;
889 if (sctp->sctp_xmit_tail == meta)
890 sctp->sctp_xmit_tail = tmp_meta;
891 meta->b_prev = NULL;
892 meta->b_next = NULL;
893 }
894 sctp->sctp_unsent -= msg_hdr->smh_msglen;
895 /*
896 * Update ULP the amount of queued data, which is
897 * sent-unack'ed + unsent.
898 */
899 if (!SCTP_IS_DETACHED(sctp))
900 SCTP_TXQ_UPDATE(sctp);
901 sctp_sendfail_event(sctp, meta, 0, B_TRUE);
902 next_msg:
903 meta = tmp_meta;
904 }
905 /* chunkify, if needed */
906 if (cansend > 0 && sctp->sctp_xmit_unsent != NULL) {
907 ASSERT(sctp->sctp_unsent > 0);
908 if (fp == NULL) {
909 fp = SCTP_CHUNK_DEST(sctp->sctp_xmit_unsent);
910 if (fp == NULL || fp->sf_state != SCTP_FADDRS_ALIVE)
911 fp = sctp->sctp_current;
912 } else {
913 /*
914 * If user specified destination, try to honor that.
915 */
916 fp1 = SCTP_CHUNK_DEST(sctp->sctp_xmit_unsent);
917 if (fp1 != NULL && fp1->sf_state == SCTP_FADDRS_ALIVE &&
918 fp1 != fp) {
919 goto chunk_done;
920 }
921 }
922 meta = sctp_chunkify(sctp, fp->sf_pmss, firstseg_len, cansend);
923 if (meta == NULL)
924 goto chunk_done;
925 /*
926 * sctp_chunkify() won't advance sctp_xmit_tail if it adds
927 * new chunk(s) to the tail, so we need to skip the
928 * sctp_xmit_tail, which would have already been processed.
929 * This could happen when there is unacked chunks, but
930 * nothing new to send.
931 * When sctp_chunkify() is called when the transmit queue
932 * is empty then we need to start from sctp_xmit_tail.
933 */
934 if (SCTP_CHUNK_ISSENT(sctp->sctp_xmit_tail->b_cont)) {
935 #ifdef DEBUG
936 mp1 = sctp->sctp_xmit_tail->b_cont;
937 while (mp1 != NULL) {
938 ASSERT(!SCTP_CHUNK_CANSEND(mp1));
939 mp1 = mp1->b_next;
940 }
941 #endif
942 if ((meta = sctp->sctp_xmit_tail->b_next) == NULL)
943 goto chunk_done;
944 }
945 goto chunkified;
946 }
947 chunk_done:
948 #ifdef DEBUG
949 ASSERT(sctp_verify_chain(sctp->sctp_xmit_head, sctp->sctp_xmit_tail));
950 #endif
951 return (NULL);
952 }
953
954 void
sctp_fast_rexmit(sctp_t * sctp)955 sctp_fast_rexmit(sctp_t *sctp)
956 {
957 mblk_t *mp, *head;
958 int pktlen = 0;
959 sctp_faddr_t *fp = NULL;
960 sctp_stack_t *sctps = sctp->sctp_sctps;
961
962 ASSERT(sctp->sctp_xmit_head != NULL);
963 mp = sctp_find_fast_rexmit_mblks(sctp, &pktlen, &fp);
964 if (mp == NULL) {
965 SCTP_KSTAT(sctps, sctp_fr_not_found);
966 return;
967 }
968 if ((head = sctp_add_proto_hdr(sctp, fp, mp, 0, NULL)) == NULL) {
969 freemsg(mp);
970 SCTP_KSTAT(sctps, sctp_fr_add_hdr);
971 return;
972 }
973 if ((pktlen > fp->sf_pmss) && fp->sf_isv4) {
974 ipha_t *iph = (ipha_t *)head->b_rptr;
975
976 iph->ipha_fragment_offset_and_flags = 0;
977 }
978
979 sctp_set_iplen(sctp, head, fp->sf_ixa);
980 (void) conn_ip_output(head, fp->sf_ixa);
981 BUMP_LOCAL(sctp->sctp_opkts);
982 sctp->sctp_active = fp->sf_lastactive = ddi_get_lbolt64();
983 }
984
985 void
sctp_output(sctp_t * sctp,uint_t num_pkt)986 sctp_output(sctp_t *sctp, uint_t num_pkt)
987 {
988 mblk_t *mp = NULL;
989 mblk_t *nmp;
990 mblk_t *head;
991 mblk_t *meta = sctp->sctp_xmit_tail;
992 mblk_t *fill = NULL;
993 uint16_t chunklen;
994 uint32_t cansend;
995 int32_t seglen;
996 int32_t xtralen;
997 int32_t sacklen;
998 int32_t pad = 0;
999 int32_t pathmax;
1000 int extra;
1001 int64_t now = LBOLT_FASTPATH64;
1002 sctp_faddr_t *fp;
1003 sctp_faddr_t *lfp;
1004 sctp_data_hdr_t *sdc;
1005 int error;
1006 boolean_t notsent = B_TRUE;
1007 sctp_stack_t *sctps = sctp->sctp_sctps;
1008 uint32_t tsn;
1009
1010 lfp = NULL;
1011
1012 if (sctp->sctp_ftsn == sctp->sctp_lastacked + 1) {
1013 sacklen = 0;
1014 } else {
1015 /* send a SACK chunk */
1016 sacklen = sizeof (sctp_chunk_hdr_t) +
1017 sizeof (sctp_sack_chunk_t) +
1018 (sizeof (sctp_sack_frag_t) * sctp->sctp_sack_gaps);
1019 lfp = sctp->sctp_lastdata;
1020 ASSERT(lfp != NULL);
1021 if (lfp->sf_state != SCTP_FADDRS_ALIVE)
1022 lfp = sctp->sctp_current;
1023 }
1024
1025 cansend = sctp->sctp_frwnd;
1026 if (sctp->sctp_unsent < cansend)
1027 cansend = sctp->sctp_unsent;
1028
1029 /*
1030 * Start persist timer if unable to send or when
1031 * trying to send into a zero window. This timer
1032 * ensures the blocked send attempt is retried.
1033 */
1034 if ((cansend < sctp->sctp_current->sf_pmss / 2) &&
1035 (sctp->sctp_unacked != 0) &&
1036 (sctp->sctp_unacked < sctp->sctp_current->sf_pmss) &&
1037 !sctp->sctp_ndelay ||
1038 (cansend == 0 && sctp->sctp_unacked == 0 &&
1039 sctp->sctp_unsent != 0)) {
1040 head = NULL;
1041 fp = sctp->sctp_current;
1042 goto unsent_data;
1043 }
1044 if (meta != NULL)
1045 mp = meta->b_cont;
1046 while (cansend > 0 && num_pkt-- != 0) {
1047 pad = 0;
1048
1049 /*
1050 * Find first segment eligible for transmit.
1051 */
1052 while (mp != NULL) {
1053 if (SCTP_CHUNK_CANSEND(mp))
1054 break;
1055 mp = mp->b_next;
1056 }
1057 if (mp == NULL) {
1058 meta = sctp_get_msg_to_send(sctp, &mp,
1059 meta == NULL ? NULL : meta->b_next, &error, sacklen,
1060 cansend, NULL);
1061 if (error != 0 || meta == NULL) {
1062 head = NULL;
1063 fp = sctp->sctp_current;
1064 goto unsent_data;
1065 }
1066 sctp->sctp_xmit_tail = meta;
1067 }
1068
1069 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1070 seglen = ntohs(sdc->sdh_len);
1071 xtralen = sizeof (*sdc);
1072 chunklen = seglen - xtralen;
1073
1074 /*
1075 * Check rwnd.
1076 */
1077 if (chunklen > cansend) {
1078 head = NULL;
1079 fp = SCTP_CHUNK_DEST(meta);
1080 if (fp == NULL || fp->sf_state != SCTP_FADDRS_ALIVE)
1081 fp = sctp->sctp_current;
1082 goto unsent_data;
1083 }
1084 if ((extra = seglen & (SCTP_ALIGN - 1)) != 0)
1085 extra = SCTP_ALIGN - extra;
1086
1087 /*
1088 * Pick destination address, and check cwnd.
1089 */
1090 if (sacklen > 0 && (seglen + extra <= lfp->sf_cwnd -
1091 lfp->sf_suna) &&
1092 (seglen + sacklen + extra <= lfp->sf_pmss)) {
1093 /*
1094 * Only include SACK chunk if it can be bundled
1095 * with a data chunk, and sent to sctp_lastdata.
1096 */
1097 pathmax = lfp->sf_cwnd - lfp->sf_suna;
1098
1099 fp = lfp;
1100 if ((nmp = dupmsg(mp)) == NULL) {
1101 head = NULL;
1102 goto unsent_data;
1103 }
1104 SCTP_CHUNK_CLEAR_FLAGS(nmp);
1105 head = sctp_add_proto_hdr(sctp, fp, nmp, sacklen,
1106 &error);
1107 if (head == NULL) {
1108 /*
1109 * If none of the source addresses are
1110 * available (i.e error == EHOSTUNREACH),
1111 * pretend we have sent the data. We will
1112 * eventually time out trying to retramsmit
1113 * the data if the interface never comes up.
1114 * If we have already sent some stuff (i.e.,
1115 * notsent is B_FALSE) then we are fine, else
1116 * just mark this packet as sent.
1117 */
1118 if (notsent && error == EHOSTUNREACH) {
1119 SCTP_CHUNK_SENT(sctp, mp, sdc,
1120 fp, chunklen, meta);
1121 }
1122 freemsg(nmp);
1123 SCTP_KSTAT(sctps, sctp_output_failed);
1124 goto unsent_data;
1125 }
1126 seglen += sacklen;
1127 xtralen += sacklen;
1128 sacklen = 0;
1129 } else {
1130 fp = SCTP_CHUNK_DEST(meta);
1131 if (fp == NULL || fp->sf_state != SCTP_FADDRS_ALIVE)
1132 fp = sctp->sctp_current;
1133 /*
1134 * If we haven't sent data to this destination for
1135 * a while, do slow start again.
1136 */
1137 if (now - fp->sf_lastactive > fp->sf_rto) {
1138 SET_CWND(fp, fp->sf_pmss,
1139 sctps->sctps_slow_start_after_idle);
1140 }
1141
1142 pathmax = fp->sf_cwnd - fp->sf_suna;
1143 if (seglen + extra > pathmax) {
1144 head = NULL;
1145 goto unsent_data;
1146 }
1147 if ((nmp = dupmsg(mp)) == NULL) {
1148 head = NULL;
1149 goto unsent_data;
1150 }
1151 SCTP_CHUNK_CLEAR_FLAGS(nmp);
1152 head = sctp_add_proto_hdr(sctp, fp, nmp, 0, &error);
1153 if (head == NULL) {
1154 /*
1155 * If none of the source addresses are
1156 * available (i.e error == EHOSTUNREACH),
1157 * pretend we have sent the data. We will
1158 * eventually time out trying to retramsmit
1159 * the data if the interface never comes up.
1160 * If we have already sent some stuff (i.e.,
1161 * notsent is B_FALSE) then we are fine, else
1162 * just mark this packet as sent.
1163 */
1164 if (notsent && error == EHOSTUNREACH) {
1165 SCTP_CHUNK_SENT(sctp, mp, sdc,
1166 fp, chunklen, meta);
1167 }
1168 freemsg(nmp);
1169 SCTP_KSTAT(sctps, sctp_output_failed);
1170 goto unsent_data;
1171 }
1172 }
1173 fp->sf_lastactive = now;
1174 if (pathmax > fp->sf_pmss)
1175 pathmax = fp->sf_pmss;
1176 SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunklen, meta);
1177 mp = mp->b_next;
1178
1179 /*
1180 * Use this chunk to measure RTT?
1181 * Must not be a retransmision of an earlier chunk,
1182 * ensure the tsn is current.
1183 */
1184 tsn = ntohl(sdc->sdh_tsn);
1185 if (sctp->sctp_out_time == 0 && tsn == (sctp->sctp_ltsn - 1)) {
1186 sctp->sctp_out_time = now;
1187 sctp->sctp_rtt_tsn = tsn;
1188 }
1189 if (extra > 0) {
1190 fill = sctp_get_padding(sctp, extra);
1191 if (fill != NULL) {
1192 linkb(head, fill);
1193 pad = extra;
1194 seglen += extra;
1195 } else {
1196 goto unsent_data;
1197 }
1198 }
1199 /*
1200 * Bundle chunks. We linkb() the chunks together to send
1201 * downstream in a single packet.
1202 * Partial chunks MUST NOT be bundled with full chunks, so we
1203 * rely on sctp_get_msg_to_send() to only return messages that
1204 * will fit entirely in the current packet.
1205 */
1206 while (seglen < pathmax) {
1207 int32_t new_len;
1208 int32_t new_xtralen;
1209
1210 while (mp != NULL) {
1211 if (SCTP_CHUNK_CANSEND(mp))
1212 break;
1213 mp = mp->b_next;
1214 }
1215 if (mp == NULL) {
1216 meta = sctp_get_msg_to_send(sctp, &mp,
1217 meta->b_next, &error, seglen,
1218 (seglen - xtralen) >= cansend ? 0 :
1219 cansend - seglen, fp);
1220 if (error != 0)
1221 break;
1222 /* If no more eligible chunks, cease bundling */
1223 if (meta == NULL)
1224 break;
1225 sctp->sctp_xmit_tail = meta;
1226 }
1227 ASSERT(mp != NULL);
1228 if (!SCTP_CHUNK_ISSENT(mp) && SCTP_CHUNK_DEST(meta) &&
1229 fp != SCTP_CHUNK_DEST(meta)) {
1230 break;
1231 }
1232 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1233 chunklen = ntohs(sdc->sdh_len);
1234 if ((extra = chunklen & (SCTP_ALIGN - 1)) != 0)
1235 extra = SCTP_ALIGN - extra;
1236
1237 new_len = seglen + chunklen;
1238 new_xtralen = xtralen + sizeof (*sdc);
1239 chunklen -= sizeof (*sdc);
1240
1241 if (new_len - new_xtralen > cansend ||
1242 new_len + extra > pathmax) {
1243 break;
1244 }
1245 if ((nmp = dupmsg(mp)) == NULL)
1246 break;
1247 if (extra > 0) {
1248 fill = sctp_get_padding(sctp, extra);
1249 if (fill != NULL) {
1250 pad += extra;
1251 new_len += extra;
1252 linkb(nmp, fill);
1253 } else {
1254 freemsg(nmp);
1255 break;
1256 }
1257 }
1258 seglen = new_len;
1259 xtralen = new_xtralen;
1260 SCTP_CHUNK_CLEAR_FLAGS(nmp);
1261 SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunklen, meta);
1262 linkb(head, nmp);
1263 mp = mp->b_next;
1264 }
1265 if ((seglen > fp->sf_pmss) && fp->sf_isv4) {
1266 ipha_t *iph = (ipha_t *)head->b_rptr;
1267
1268 /*
1269 * Path MTU is different from what we thought it would
1270 * be when we created chunks, or IP headers have grown.
1271 * Need to clear the DF bit.
1272 */
1273 iph->ipha_fragment_offset_and_flags = 0;
1274 }
1275 /* xmit segment */
1276 ASSERT(cansend >= seglen - pad - xtralen);
1277 cansend -= (seglen - pad - xtralen);
1278 dprint(2, ("sctp_output: Sending packet %d bytes, tsn %x "
1279 "ssn %d to %p (rwnd %d, cansend %d, lastack_rxd %x)\n",
1280 seglen - xtralen, ntohl(sdc->sdh_tsn),
1281 ntohs(sdc->sdh_ssn), (void *)fp, sctp->sctp_frwnd,
1282 cansend, sctp->sctp_lastack_rxd));
1283 sctp_set_iplen(sctp, head, fp->sf_ixa);
1284 (void) conn_ip_output(head, fp->sf_ixa);
1285 BUMP_LOCAL(sctp->sctp_opkts);
1286 /* arm rto timer (if not set) */
1287 if (!fp->sf_timer_running)
1288 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
1289 notsent = B_FALSE;
1290 }
1291 sctp->sctp_active = now;
1292 return;
1293 unsent_data:
1294 /* arm persist timer (if rto timer not set) */
1295 if (!fp->sf_timer_running)
1296 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
1297 if (head != NULL)
1298 freemsg(head);
1299 }
1300
1301 /*
1302 * The following two functions initialize and destroy the cache
1303 * associated with the sets used for PR-SCTP.
1304 */
1305 void
sctp_ftsn_sets_init(void)1306 sctp_ftsn_sets_init(void)
1307 {
1308 sctp_kmem_ftsn_set_cache = kmem_cache_create("sctp_ftsn_set_cache",
1309 sizeof (sctp_ftsn_set_t), 0, NULL, NULL, NULL, NULL,
1310 NULL, 0);
1311 }
1312
1313 void
sctp_ftsn_sets_fini(void)1314 sctp_ftsn_sets_fini(void)
1315 {
1316 kmem_cache_destroy(sctp_kmem_ftsn_set_cache);
1317 }
1318
1319
1320 /* Free PR-SCTP sets */
1321 void
sctp_free_ftsn_set(sctp_ftsn_set_t * s)1322 sctp_free_ftsn_set(sctp_ftsn_set_t *s)
1323 {
1324 sctp_ftsn_set_t *p;
1325
1326 while (s != NULL) {
1327 p = s->next;
1328 s->next = NULL;
1329 kmem_cache_free(sctp_kmem_ftsn_set_cache, s);
1330 s = p;
1331 }
1332 }
1333
1334 /*
1335 * Given a message meta block, meta, this routine creates or modifies
1336 * the set that will be used to generate a Forward TSN chunk. If the
1337 * entry for stream id, sid, for this message already exists, the
1338 * sequence number, ssn, is updated if it is greater than the existing
1339 * one. If an entry for this sid does not exist, one is created if
1340 * the size does not exceed fp->sf_pmss. We return false in case
1341 * or an error.
1342 */
1343 boolean_t
sctp_add_ftsn_set(sctp_ftsn_set_t ** s,sctp_faddr_t * fp,mblk_t * meta,uint_t * nsets,uint32_t * slen)1344 sctp_add_ftsn_set(sctp_ftsn_set_t **s, sctp_faddr_t *fp, mblk_t *meta,
1345 uint_t *nsets, uint32_t *slen)
1346 {
1347 sctp_ftsn_set_t *p;
1348 sctp_msg_hdr_t *msg_hdr = (sctp_msg_hdr_t *)meta->b_rptr;
1349 uint16_t sid = htons(msg_hdr->smh_sid);
1350 /* msg_hdr->smh_ssn is already in NBO */
1351 uint16_t ssn = msg_hdr->smh_ssn;
1352
1353 ASSERT(s != NULL && nsets != NULL);
1354 ASSERT((*nsets == 0 && *s == NULL) || (*nsets > 0 && *s != NULL));
1355
1356 if (*s == NULL) {
1357 ASSERT((*slen + sizeof (uint32_t)) <= fp->sf_pmss);
1358 *s = kmem_cache_alloc(sctp_kmem_ftsn_set_cache, KM_NOSLEEP);
1359 if (*s == NULL)
1360 return (B_FALSE);
1361 (*s)->ftsn_entries.ftsn_sid = sid;
1362 (*s)->ftsn_entries.ftsn_ssn = ssn;
1363 (*s)->next = NULL;
1364 *nsets = 1;
1365 *slen += sizeof (uint32_t);
1366 return (B_TRUE);
1367 }
1368 for (p = *s; p->next != NULL; p = p->next) {
1369 if (p->ftsn_entries.ftsn_sid == sid) {
1370 if (SSN_GT(ssn, p->ftsn_entries.ftsn_ssn))
1371 p->ftsn_entries.ftsn_ssn = ssn;
1372 return (B_TRUE);
1373 }
1374 }
1375 /* the last one */
1376 if (p->ftsn_entries.ftsn_sid == sid) {
1377 if (SSN_GT(ssn, p->ftsn_entries.ftsn_ssn))
1378 p->ftsn_entries.ftsn_ssn = ssn;
1379 } else {
1380 if ((*slen + sizeof (uint32_t)) > fp->sf_pmss)
1381 return (B_FALSE);
1382 p->next = kmem_cache_alloc(sctp_kmem_ftsn_set_cache,
1383 KM_NOSLEEP);
1384 if (p->next == NULL)
1385 return (B_FALSE);
1386 p = p->next;
1387 p->ftsn_entries.ftsn_sid = sid;
1388 p->ftsn_entries.ftsn_ssn = ssn;
1389 p->next = NULL;
1390 (*nsets)++;
1391 *slen += sizeof (uint32_t);
1392 }
1393 return (B_TRUE);
1394 }
1395
1396 /*
1397 * Given a set of stream id - sequence number pairs, this routing creates
1398 * a Forward TSN chunk. The cumulative TSN (advanced peer ack point)
1399 * for the chunk is obtained from sctp->sctp_adv_pap. The caller
1400 * will add the IP/SCTP header.
1401 */
1402 mblk_t *
sctp_make_ftsn_chunk(sctp_t * sctp,sctp_faddr_t * fp,sctp_ftsn_set_t * sets,uint_t nsets,uint32_t seglen)1403 sctp_make_ftsn_chunk(sctp_t *sctp, sctp_faddr_t *fp, sctp_ftsn_set_t *sets,
1404 uint_t nsets, uint32_t seglen)
1405 {
1406 mblk_t *ftsn_mp;
1407 sctp_chunk_hdr_t *ch_hdr;
1408 uint32_t *advtsn;
1409 uint16_t schlen;
1410 size_t xtralen;
1411 ftsn_entry_t *ftsn_entry;
1412 sctp_stack_t *sctps = sctp->sctp_sctps;
1413
1414 seglen += sizeof (sctp_chunk_hdr_t);
1415 if (fp->sf_isv4)
1416 xtralen = sctp->sctp_hdr_len + sctps->sctps_wroff_xtra;
1417 else
1418 xtralen = sctp->sctp_hdr6_len + sctps->sctps_wroff_xtra;
1419 ftsn_mp = allocb(xtralen + seglen, BPRI_MED);
1420 if (ftsn_mp == NULL)
1421 return (NULL);
1422 ftsn_mp->b_rptr += xtralen;
1423 ftsn_mp->b_wptr = ftsn_mp->b_rptr + seglen;
1424
1425 ch_hdr = (sctp_chunk_hdr_t *)ftsn_mp->b_rptr;
1426 ch_hdr->sch_id = CHUNK_FORWARD_TSN;
1427 ch_hdr->sch_flags = 0;
1428 /*
1429 * The cast here should not be an issue since seglen is
1430 * the length of the Forward TSN chunk.
1431 */
1432 schlen = (uint16_t)seglen;
1433 U16_TO_ABE16(schlen, &(ch_hdr->sch_len));
1434
1435 advtsn = (uint32_t *)(ch_hdr + 1);
1436 U32_TO_ABE32(sctp->sctp_adv_pap, advtsn);
1437 ftsn_entry = (ftsn_entry_t *)(advtsn + 1);
1438 while (nsets > 0) {
1439 ASSERT((uchar_t *)&ftsn_entry[1] <= ftsn_mp->b_wptr);
1440 ftsn_entry->ftsn_sid = sets->ftsn_entries.ftsn_sid;
1441 ftsn_entry->ftsn_ssn = sets->ftsn_entries.ftsn_ssn;
1442 ftsn_entry++;
1443 sets = sets->next;
1444 nsets--;
1445 }
1446 return (ftsn_mp);
1447 }
1448
1449 /*
1450 * Given a starting message, the routine steps through all the
1451 * messages whose TSN is less than sctp->sctp_adv_pap and creates
1452 * ftsn sets. The ftsn sets is then used to create an Forward TSN
1453 * chunk. All the messages, that have chunks that are included in the
1454 * ftsn sets, are flagged abandonded. If a message is partially sent
1455 * and is deemed abandoned, all remaining unsent chunks are marked
1456 * abandoned and are deducted from sctp_unsent.
1457 */
1458 void
sctp_make_ftsns(sctp_t * sctp,mblk_t * meta,mblk_t * mp,mblk_t ** nmp,sctp_faddr_t * fp,uint32_t * seglen)1459 sctp_make_ftsns(sctp_t *sctp, mblk_t *meta, mblk_t *mp, mblk_t **nmp,
1460 sctp_faddr_t *fp, uint32_t *seglen)
1461 {
1462 mblk_t *mp1 = mp;
1463 mblk_t *mp_head = mp;
1464 mblk_t *meta_head = meta;
1465 mblk_t *head;
1466 sctp_ftsn_set_t *sets = NULL;
1467 uint_t nsets = 0;
1468 uint16_t clen;
1469 sctp_data_hdr_t *sdc;
1470 uint32_t sacklen;
1471 uint32_t adv_pap = sctp->sctp_adv_pap;
1472 uint32_t unsent = 0;
1473 boolean_t ubit;
1474 sctp_stack_t *sctps = sctp->sctp_sctps;
1475
1476 *seglen = sizeof (uint32_t);
1477
1478 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1479 while (meta != NULL &&
1480 SEQ_GEQ(sctp->sctp_adv_pap, ntohl(sdc->sdh_tsn))) {
1481 /*
1482 * Skip adding FTSN sets for un-ordered messages as they do
1483 * not have SSNs.
1484 */
1485 ubit = SCTP_DATA_GET_UBIT(sdc);
1486 if (!ubit &&
1487 !sctp_add_ftsn_set(&sets, fp, meta, &nsets, seglen)) {
1488 meta = NULL;
1489 sctp->sctp_adv_pap = adv_pap;
1490 goto ftsn_done;
1491 }
1492 while (mp1 != NULL && SCTP_CHUNK_ISSENT(mp1)) {
1493 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1494 adv_pap = ntohl(sdc->sdh_tsn);
1495 mp1 = mp1->b_next;
1496 }
1497 meta = meta->b_next;
1498 if (meta != NULL) {
1499 mp1 = meta->b_cont;
1500 if (!SCTP_CHUNK_ISSENT(mp1))
1501 break;
1502 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1503 }
1504 }
1505 ftsn_done:
1506 /*
1507 * Can't compare with sets == NULL, since we don't add any
1508 * sets for un-ordered messages.
1509 */
1510 if (meta == meta_head)
1511 return;
1512 *nmp = sctp_make_ftsn_chunk(sctp, fp, sets, nsets, *seglen);
1513 sctp_free_ftsn_set(sets);
1514 if (*nmp == NULL)
1515 return;
1516 if (sctp->sctp_ftsn == sctp->sctp_lastacked + 1) {
1517 sacklen = 0;
1518 } else {
1519 sacklen = sizeof (sctp_chunk_hdr_t) +
1520 sizeof (sctp_sack_chunk_t) +
1521 (sizeof (sctp_sack_frag_t) * sctp->sctp_sack_gaps);
1522 if (*seglen + sacklen > sctp->sctp_lastdata->sf_pmss) {
1523 /* piggybacked SACK doesn't fit */
1524 sacklen = 0;
1525 } else {
1526 fp = sctp->sctp_lastdata;
1527 }
1528 }
1529 head = sctp_add_proto_hdr(sctp, fp, *nmp, sacklen, NULL);
1530 if (head == NULL) {
1531 freemsg(*nmp);
1532 *nmp = NULL;
1533 SCTP_KSTAT(sctps, sctp_send_ftsn_failed);
1534 return;
1535 }
1536 *seglen += sacklen;
1537 *nmp = head;
1538
1539 /*
1540 * XXXNeed to optimise this, the reason it is done here is so
1541 * that we don't have to undo in case of failure.
1542 */
1543 mp1 = mp_head;
1544 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1545 while (meta_head != NULL &&
1546 SEQ_GEQ(sctp->sctp_adv_pap, ntohl(sdc->sdh_tsn))) {
1547 if (!SCTP_IS_MSG_ABANDONED(meta_head))
1548 SCTP_MSG_SET_ABANDONED(meta_head);
1549 while (mp1 != NULL && SCTP_CHUNK_ISSENT(mp1)) {
1550 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1551 if (!SCTP_CHUNK_ISACKED(mp1)) {
1552 clen = ntohs(sdc->sdh_len) - sizeof (*sdc);
1553 SCTP_CHUNK_SENT(sctp, mp1, sdc, fp, clen,
1554 meta_head);
1555 }
1556 mp1 = mp1->b_next;
1557 }
1558 while (mp1 != NULL) {
1559 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1560 if (!SCTP_CHUNK_ABANDONED(mp1)) {
1561 ASSERT(!SCTP_CHUNK_ISSENT(mp1));
1562 unsent += ntohs(sdc->sdh_len) - sizeof (*sdc);
1563 SCTP_ABANDON_CHUNK(mp1);
1564 }
1565 mp1 = mp1->b_next;
1566 }
1567 meta_head = meta_head->b_next;
1568 if (meta_head != NULL) {
1569 mp1 = meta_head->b_cont;
1570 if (!SCTP_CHUNK_ISSENT(mp1))
1571 break;
1572 sdc = (sctp_data_hdr_t *)mp1->b_rptr;
1573 }
1574 }
1575 if (unsent > 0) {
1576 ASSERT(sctp->sctp_unsent >= unsent);
1577 sctp->sctp_unsent -= unsent;
1578 /*
1579 * Update ULP the amount of queued data, which is
1580 * sent-unack'ed + unsent.
1581 */
1582 if (!SCTP_IS_DETACHED(sctp))
1583 SCTP_TXQ_UPDATE(sctp);
1584 }
1585 }
1586
1587 /*
1588 * This function steps through messages starting at meta and checks if
1589 * the message is abandoned. It stops when it hits an unsent chunk or
1590 * a message that has all its chunk acked. This is the only place
1591 * where the sctp_adv_pap is moved forward to indicated abandoned
1592 * messages.
1593 */
1594 void
sctp_check_adv_ack_pt(sctp_t * sctp,mblk_t * meta,mblk_t * mp)1595 sctp_check_adv_ack_pt(sctp_t *sctp, mblk_t *meta, mblk_t *mp)
1596 {
1597 uint32_t tsn = sctp->sctp_adv_pap;
1598 sctp_data_hdr_t *sdc;
1599 sctp_msg_hdr_t *msg_hdr;
1600
1601 ASSERT(mp != NULL);
1602 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1603 ASSERT(SEQ_GT(ntohl(sdc->sdh_tsn), sctp->sctp_lastack_rxd));
1604 msg_hdr = (sctp_msg_hdr_t *)meta->b_rptr;
1605 if (!SCTP_IS_MSG_ABANDONED(meta) &&
1606 !SCTP_MSG_TO_BE_ABANDONED(meta, msg_hdr, sctp)) {
1607 return;
1608 }
1609 while (meta != NULL) {
1610 while (mp != NULL && SCTP_CHUNK_ISSENT(mp)) {
1611 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1612 tsn = ntohl(sdc->sdh_tsn);
1613 mp = mp->b_next;
1614 }
1615 if (mp != NULL)
1616 break;
1617 /*
1618 * We continue checking for successive messages only if there
1619 * is a chunk marked for retransmission. Else, we might
1620 * end up sending FTSN prematurely for chunks that have been
1621 * sent, but not yet acked.
1622 */
1623 if ((meta = meta->b_next) != NULL) {
1624 msg_hdr = (sctp_msg_hdr_t *)meta->b_rptr;
1625 if (!SCTP_IS_MSG_ABANDONED(meta) &&
1626 !SCTP_MSG_TO_BE_ABANDONED(meta, msg_hdr, sctp)) {
1627 break;
1628 }
1629 for (mp = meta->b_cont; mp != NULL; mp = mp->b_next) {
1630 if (!SCTP_CHUNK_ISSENT(mp)) {
1631 sctp->sctp_adv_pap = tsn;
1632 return;
1633 }
1634 if (SCTP_CHUNK_WANT_REXMIT(mp))
1635 break;
1636 }
1637 if (mp == NULL)
1638 break;
1639 }
1640 }
1641 sctp->sctp_adv_pap = tsn;
1642 }
1643
1644
1645 /*
1646 * Determine if we should bundle a data chunk with the chunk being
1647 * retransmitted. We bundle if
1648 *
1649 * - the chunk is sent to the same destination and unack'ed.
1650 *
1651 * OR
1652 *
1653 * - the chunk is unsent, i.e. new data.
1654 */
1655 #define SCTP_CHUNK_RX_CANBUNDLE(mp, fp) \
1656 (!SCTP_CHUNK_ABANDONED((mp)) && \
1657 ((SCTP_CHUNK_ISSENT((mp)) && (SCTP_CHUNK_DEST(mp) == (fp) && \
1658 !SCTP_CHUNK_ISACKED(mp))) || \
1659 (((mp)->b_flag & (SCTP_CHUNK_FLAG_REXMIT|SCTP_CHUNK_FLAG_SENT)) != \
1660 SCTP_CHUNK_FLAG_SENT)))
1661
1662 /*
1663 * Retransmit first segment which hasn't been acked with cumtsn or send
1664 * a Forward TSN chunk, if appropriate.
1665 */
1666 void
sctp_rexmit(sctp_t * sctp,sctp_faddr_t * oldfp)1667 sctp_rexmit(sctp_t *sctp, sctp_faddr_t *oldfp)
1668 {
1669 mblk_t *mp;
1670 mblk_t *nmp = NULL;
1671 mblk_t *head;
1672 mblk_t *meta = sctp->sctp_xmit_head;
1673 mblk_t *fill;
1674 uint32_t seglen = 0;
1675 uint32_t sacklen;
1676 uint16_t chunklen;
1677 int extra;
1678 sctp_data_hdr_t *sdc;
1679 sctp_faddr_t *fp;
1680 uint32_t adv_pap = sctp->sctp_adv_pap;
1681 boolean_t do_ftsn = B_FALSE;
1682 boolean_t ftsn_check = B_TRUE;
1683 uint32_t first_ua_tsn;
1684 sctp_msg_hdr_t *mhdr;
1685 sctp_stack_t *sctps = sctp->sctp_sctps;
1686 int error;
1687
1688 while (meta != NULL) {
1689 for (mp = meta->b_cont; mp != NULL; mp = mp->b_next) {
1690 uint32_t tsn;
1691
1692 if (!SCTP_CHUNK_ISSENT(mp))
1693 goto window_probe;
1694 /*
1695 * We break in the following cases -
1696 *
1697 * if the advanced peer ack point includes the next
1698 * chunk to be retransmited - possibly the Forward
1699 * TSN was lost.
1700 *
1701 * if we are PRSCTP aware and the next chunk to be
1702 * retransmitted is now abandoned
1703 *
1704 * if the next chunk to be retransmitted is for
1705 * the dest on which the timer went off. (this
1706 * message is not abandoned).
1707 *
1708 * We check for Forward TSN only for the first
1709 * eligible chunk to be retransmitted. The reason
1710 * being if the first eligible chunk is skipped (say
1711 * it was sent to a destination other than oldfp)
1712 * then we cannot advance the cum TSN via Forward
1713 * TSN chunk.
1714 *
1715 * Also, ftsn_check is B_TRUE only for the first
1716 * eligible chunk, it will be B_FALSE for all
1717 * subsequent candidate messages for retransmission.
1718 */
1719 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1720 tsn = ntohl(sdc->sdh_tsn);
1721 if (SEQ_GT(tsn, sctp->sctp_lastack_rxd)) {
1722 if (sctp->sctp_prsctp_aware && ftsn_check) {
1723 if (SEQ_GEQ(sctp->sctp_adv_pap, tsn)) {
1724 ASSERT(sctp->sctp_prsctp_aware);
1725 do_ftsn = B_TRUE;
1726 goto out;
1727 } else {
1728 sctp_check_adv_ack_pt(sctp,
1729 meta, mp);
1730 if (SEQ_GT(sctp->sctp_adv_pap,
1731 adv_pap)) {
1732 do_ftsn = B_TRUE;
1733 goto out;
1734 }
1735 }
1736 ftsn_check = B_FALSE;
1737 }
1738 if (SCTP_CHUNK_DEST(mp) == oldfp)
1739 goto out;
1740 }
1741 }
1742 meta = meta->b_next;
1743 if (meta != NULL && sctp->sctp_prsctp_aware) {
1744 mhdr = (sctp_msg_hdr_t *)meta->b_rptr;
1745
1746 while (meta != NULL && (SCTP_IS_MSG_ABANDONED(meta) ||
1747 SCTP_MSG_TO_BE_ABANDONED(meta, mhdr, sctp))) {
1748 meta = meta->b_next;
1749 }
1750 }
1751 }
1752 window_probe:
1753 /*
1754 * Retransmit fired for a destination which didn't have
1755 * any unacked data pending.
1756 */
1757 if (sctp->sctp_unacked == 0 && sctp->sctp_unsent != 0) {
1758 /*
1759 * Send a window probe. Inflate frwnd to allow
1760 * sending one segment.
1761 */
1762 if (sctp->sctp_frwnd < (oldfp->sf_pmss - sizeof (*sdc)))
1763 sctp->sctp_frwnd = oldfp->sf_pmss - sizeof (*sdc);
1764
1765 /* next TSN to send */
1766 sctp->sctp_rxt_nxttsn = sctp->sctp_ltsn;
1767
1768 /*
1769 * The above sctp_frwnd adjustment is coarse. The "changed"
1770 * sctp_frwnd may allow us to send more than 1 packet. So
1771 * tell sctp_output() to send only 1 packet.
1772 */
1773 sctp_output(sctp, 1);
1774
1775 /* Last sent TSN */
1776 sctp->sctp_rxt_maxtsn = sctp->sctp_ltsn - 1;
1777 ASSERT(sctp->sctp_rxt_maxtsn >= sctp->sctp_rxt_nxttsn);
1778 sctp->sctp_zero_win_probe = B_TRUE;
1779 SCTPS_BUMP_MIB(sctps, sctpOutWinProbe);
1780 }
1781 return;
1782 out:
1783 /*
1784 * After a time out, assume that everything has left the network. So
1785 * we can clear rxt_unacked for the original peer address.
1786 */
1787 oldfp->sf_rxt_unacked = 0;
1788
1789 /*
1790 * If we were probing for zero window, don't adjust retransmission
1791 * variables, but the timer is still backed off.
1792 */
1793 if (sctp->sctp_zero_win_probe) {
1794 mblk_t *pkt;
1795 uint_t pkt_len;
1796
1797 /*
1798 * Get the Zero Win Probe for retrasmission, sctp_rxt_nxttsn
1799 * and sctp_rxt_maxtsn will specify the ZWP packet.
1800 */
1801 fp = oldfp;
1802 if (oldfp->sf_state != SCTP_FADDRS_ALIVE)
1803 fp = sctp_rotate_faddr(sctp, oldfp);
1804 pkt = sctp_rexmit_packet(sctp, &meta, &mp, fp, &pkt_len);
1805 if (pkt != NULL) {
1806 ASSERT(pkt_len <= fp->sf_pmss);
1807 sctp_set_iplen(sctp, pkt, fp->sf_ixa);
1808 (void) conn_ip_output(pkt, fp->sf_ixa);
1809 BUMP_LOCAL(sctp->sctp_opkts);
1810 } else {
1811 SCTP_KSTAT(sctps, sctp_ss_rexmit_failed);
1812 }
1813
1814 /*
1815 * The strikes will be clear by sctp_faddr_alive() when the
1816 * other side sends us an ack.
1817 */
1818 oldfp->sf_strikes++;
1819 sctp->sctp_strikes++;
1820
1821 SCTP_CALC_RXT(sctp, oldfp, sctp->sctp_rto_max);
1822 if (oldfp != fp && oldfp->sf_suna != 0)
1823 SCTP_FADDR_TIMER_RESTART(sctp, oldfp, fp->sf_rto);
1824 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
1825 SCTPS_BUMP_MIB(sctps, sctpOutWinProbe);
1826 return;
1827 }
1828
1829 /*
1830 * Enter slowstart for this destination
1831 */
1832 oldfp->sf_ssthresh = oldfp->sf_cwnd / 2;
1833 if (oldfp->sf_ssthresh < 2 * oldfp->sf_pmss)
1834 oldfp->sf_ssthresh = 2 * oldfp->sf_pmss;
1835 oldfp->sf_cwnd = oldfp->sf_pmss;
1836 oldfp->sf_pba = 0;
1837 fp = sctp_rotate_faddr(sctp, oldfp);
1838 ASSERT(fp != NULL);
1839 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1840
1841 first_ua_tsn = ntohl(sdc->sdh_tsn);
1842 if (do_ftsn) {
1843 sctp_make_ftsns(sctp, meta, mp, &nmp, fp, &seglen);
1844 if (nmp == NULL) {
1845 sctp->sctp_adv_pap = adv_pap;
1846 goto restart_timer;
1847 }
1848 head = nmp;
1849 /*
1850 * Move to the next unabandoned chunk. XXXCheck if meta will
1851 * always be marked abandoned.
1852 */
1853 while (meta != NULL && SCTP_IS_MSG_ABANDONED(meta))
1854 meta = meta->b_next;
1855 if (meta != NULL)
1856 mp = mp->b_cont;
1857 else
1858 mp = NULL;
1859 goto try_bundle;
1860 }
1861 seglen = ntohs(sdc->sdh_len);
1862 chunklen = seglen - sizeof (*sdc);
1863 if ((extra = seglen & (SCTP_ALIGN - 1)) != 0)
1864 extra = SCTP_ALIGN - extra;
1865
1866 /* Find out if we need to piggyback SACK. */
1867 if (sctp->sctp_ftsn == sctp->sctp_lastacked + 1) {
1868 sacklen = 0;
1869 } else {
1870 sacklen = sizeof (sctp_chunk_hdr_t) +
1871 sizeof (sctp_sack_chunk_t) +
1872 (sizeof (sctp_sack_frag_t) * sctp->sctp_sack_gaps);
1873 if (seglen + sacklen > sctp->sctp_lastdata->sf_pmss) {
1874 /* piggybacked SACK doesn't fit */
1875 sacklen = 0;
1876 } else {
1877 /*
1878 * OK, we have room to send SACK back. But we
1879 * should send it back to the last fp where we
1880 * receive data from, unless sctp_lastdata equals
1881 * oldfp, then we should probably not send it
1882 * back to that fp. Also we should check that
1883 * the fp is alive.
1884 */
1885 if (sctp->sctp_lastdata != oldfp &&
1886 sctp->sctp_lastdata->sf_state ==
1887 SCTP_FADDRS_ALIVE) {
1888 fp = sctp->sctp_lastdata;
1889 }
1890 }
1891 }
1892
1893 /*
1894 * Cancel RTT measurement if the retransmitted TSN is before the
1895 * TSN used for timimg.
1896 */
1897 if (sctp->sctp_out_time != 0 &&
1898 SEQ_GEQ(sctp->sctp_rtt_tsn, sdc->sdh_tsn)) {
1899 sctp->sctp_out_time = 0;
1900 }
1901 /* Clear the counter as the RTT calculation may be off. */
1902 fp->sf_rtt_updates = 0;
1903 oldfp->sf_rtt_updates = 0;
1904
1905 /*
1906 * After a timeout, we should change the current faddr so that
1907 * new chunks will be sent to the alternate address.
1908 */
1909 sctp_set_faddr_current(sctp, fp);
1910
1911 nmp = dupmsg(mp);
1912 if (nmp == NULL)
1913 goto restart_timer;
1914 if (extra > 0) {
1915 fill = sctp_get_padding(sctp, extra);
1916 if (fill != NULL) {
1917 linkb(nmp, fill);
1918 seglen += extra;
1919 } else {
1920 freemsg(nmp);
1921 goto restart_timer;
1922 }
1923 }
1924 SCTP_CHUNK_CLEAR_FLAGS(nmp);
1925 head = sctp_add_proto_hdr(sctp, fp, nmp, sacklen, NULL);
1926 if (head == NULL) {
1927 freemsg(nmp);
1928 SCTP_KSTAT(sctps, sctp_rexmit_failed);
1929 goto restart_timer;
1930 }
1931 seglen += sacklen;
1932
1933 SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunklen, meta);
1934
1935 mp = mp->b_next;
1936
1937 try_bundle:
1938 /* We can at least and at most send 1 packet at timeout. */
1939 while (seglen < fp->sf_pmss) {
1940 int32_t new_len;
1941
1942 /* Go through the list to find more chunks to be bundled. */
1943 while (mp != NULL) {
1944 /* Check if the chunk can be bundled. */
1945 if (SCTP_CHUNK_RX_CANBUNDLE(mp, oldfp))
1946 break;
1947 mp = mp->b_next;
1948 }
1949 /* Go to the next message. */
1950 if (mp == NULL) {
1951 for (meta = meta->b_next; meta != NULL;
1952 meta = meta->b_next) {
1953 mhdr = (sctp_msg_hdr_t *)meta->b_rptr;
1954
1955 if (SCTP_IS_MSG_ABANDONED(meta) ||
1956 SCTP_MSG_TO_BE_ABANDONED(meta, mhdr,
1957 sctp)) {
1958 continue;
1959 }
1960
1961 mp = meta->b_cont;
1962 goto try_bundle;
1963 }
1964 /*
1965 * Check if there is a new message which potentially
1966 * could be bundled with this retransmission.
1967 */
1968 meta = sctp_get_msg_to_send(sctp, &mp, NULL, &error,
1969 seglen, fp->sf_pmss - seglen, NULL);
1970 if (error != 0 || meta == NULL) {
1971 /* No more chunk to be bundled. */
1972 break;
1973 } else {
1974 goto try_bundle;
1975 }
1976 }
1977
1978 sdc = (sctp_data_hdr_t *)mp->b_rptr;
1979 new_len = ntohs(sdc->sdh_len);
1980 chunklen = new_len - sizeof (*sdc);
1981
1982 if ((extra = new_len & (SCTP_ALIGN - 1)) != 0)
1983 extra = SCTP_ALIGN - extra;
1984 if ((new_len = seglen + new_len + extra) > fp->sf_pmss)
1985 break;
1986 if ((nmp = dupmsg(mp)) == NULL)
1987 break;
1988
1989 if (extra > 0) {
1990 fill = sctp_get_padding(sctp, extra);
1991 if (fill != NULL) {
1992 linkb(nmp, fill);
1993 } else {
1994 freemsg(nmp);
1995 break;
1996 }
1997 }
1998 linkb(head, nmp);
1999
2000 SCTP_CHUNK_CLEAR_FLAGS(nmp);
2001 SCTP_CHUNK_SENT(sctp, mp, sdc, fp, chunklen, meta);
2002
2003 seglen = new_len;
2004 mp = mp->b_next;
2005 }
2006 done_bundle:
2007 if ((seglen > fp->sf_pmss) && fp->sf_isv4) {
2008 ipha_t *iph = (ipha_t *)head->b_rptr;
2009
2010 /*
2011 * Path MTU is different from path we thought it would
2012 * be when we created chunks, or IP headers have grown.
2013 * Need to clear the DF bit.
2014 */
2015 iph->ipha_fragment_offset_and_flags = 0;
2016 }
2017 fp->sf_rxt_unacked += seglen;
2018
2019 dprint(2, ("sctp_rexmit: Sending packet %d bytes, tsn %x "
2020 "ssn %d to %p (rwnd %d, lastack_rxd %x)\n",
2021 seglen, ntohl(sdc->sdh_tsn), ntohs(sdc->sdh_ssn),
2022 (void *)fp, sctp->sctp_frwnd, sctp->sctp_lastack_rxd));
2023
2024 sctp->sctp_rexmitting = B_TRUE;
2025 sctp->sctp_rxt_nxttsn = first_ua_tsn;
2026 sctp->sctp_rxt_maxtsn = sctp->sctp_ltsn - 1;
2027 sctp_set_iplen(sctp, head, fp->sf_ixa);
2028 (void) conn_ip_output(head, fp->sf_ixa);
2029 BUMP_LOCAL(sctp->sctp_opkts);
2030
2031 /*
2032 * Restart the oldfp timer with exponential backoff and
2033 * the new fp timer for the retransmitted chunks.
2034 */
2035 restart_timer:
2036 oldfp->sf_strikes++;
2037 sctp->sctp_strikes++;
2038 SCTP_CALC_RXT(sctp, oldfp, sctp->sctp_rto_max);
2039 /*
2040 * If there is still some data in the oldfp, restart the
2041 * retransmission timer. If there is no data, the heartbeat will
2042 * continue to run so it will do its job in checking the reachability
2043 * of the oldfp.
2044 */
2045 if (oldfp != fp && oldfp->sf_suna != 0)
2046 SCTP_FADDR_TIMER_RESTART(sctp, oldfp, oldfp->sf_rto);
2047
2048 /*
2049 * Should we restart the timer of the new fp? If there is
2050 * outstanding data to the new fp, the timer should be
2051 * running already. So restarting it means that the timer
2052 * will fire later for those outstanding data. But if
2053 * we don't restart it, the timer will fire too early for the
2054 * just retransmitted chunks to the new fp. The reason is that we
2055 * don't keep a timestamp on when a chunk is retransmitted.
2056 * So when the timer fires, it will just search for the
2057 * chunk with the earliest TSN sent to new fp. This probably
2058 * is the chunk we just retransmitted. So for now, let's
2059 * be conservative and restart the timer of the new fp.
2060 */
2061 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
2062
2063 sctp->sctp_active = ddi_get_lbolt64();
2064 }
2065
2066 /*
2067 * This function is called by sctp_ss_rexmit() to create a packet
2068 * to be retransmitted to the given fp. The given meta and mp
2069 * parameters are respectively the sctp_msg_hdr_t and the mblk of the
2070 * first chunk to be retransmitted. This is also called when we want
2071 * to retransmit a zero window probe from sctp_rexmit() or when we
2072 * want to retransmit the zero window probe after the window has
2073 * opened from sctp_got_sack().
2074 */
2075 mblk_t *
sctp_rexmit_packet(sctp_t * sctp,mblk_t ** meta,mblk_t ** mp,sctp_faddr_t * fp,uint_t * packet_len)2076 sctp_rexmit_packet(sctp_t *sctp, mblk_t **meta, mblk_t **mp, sctp_faddr_t *fp,
2077 uint_t *packet_len)
2078 {
2079 uint32_t seglen = 0;
2080 uint16_t chunklen;
2081 int extra;
2082 mblk_t *nmp;
2083 mblk_t *head;
2084 mblk_t *fill;
2085 sctp_data_hdr_t *sdc;
2086 sctp_msg_hdr_t *mhdr;
2087
2088 sdc = (sctp_data_hdr_t *)(*mp)->b_rptr;
2089 seglen = ntohs(sdc->sdh_len);
2090 chunklen = seglen - sizeof (*sdc);
2091 if ((extra = seglen & (SCTP_ALIGN - 1)) != 0)
2092 extra = SCTP_ALIGN - extra;
2093
2094 nmp = dupmsg(*mp);
2095 if (nmp == NULL)
2096 return (NULL);
2097 if (extra > 0) {
2098 fill = sctp_get_padding(sctp, extra);
2099 if (fill != NULL) {
2100 linkb(nmp, fill);
2101 seglen += extra;
2102 } else {
2103 freemsg(nmp);
2104 return (NULL);
2105 }
2106 }
2107 SCTP_CHUNK_CLEAR_FLAGS(nmp);
2108 head = sctp_add_proto_hdr(sctp, fp, nmp, 0, NULL);
2109 if (head == NULL) {
2110 freemsg(nmp);
2111 return (NULL);
2112 }
2113 SCTP_CHUNK_SENT(sctp, *mp, sdc, fp, chunklen, *meta);
2114 /*
2115 * Don't update the TSN if we are doing a Zero Win Probe.
2116 */
2117 if (!sctp->sctp_zero_win_probe)
2118 sctp->sctp_rxt_nxttsn = ntohl(sdc->sdh_tsn);
2119 *mp = (*mp)->b_next;
2120
2121 try_bundle:
2122 while (seglen < fp->sf_pmss) {
2123 int32_t new_len;
2124
2125 /*
2126 * Go through the list to find more chunks to be bundled.
2127 * We should only retransmit sent by unack'ed chunks. Since
2128 * they were sent before, the peer's receive window should
2129 * be able to receive them.
2130 */
2131 while (*mp != NULL) {
2132 /* Check if the chunk can be bundled. */
2133 if (SCTP_CHUNK_ISSENT(*mp) && !SCTP_CHUNK_ISACKED(*mp))
2134 break;
2135 *mp = (*mp)->b_next;
2136 }
2137 /* Go to the next message. */
2138 if (*mp == NULL) {
2139 for (*meta = (*meta)->b_next; *meta != NULL;
2140 *meta = (*meta)->b_next) {
2141 mhdr = (sctp_msg_hdr_t *)(*meta)->b_rptr;
2142
2143 if (SCTP_IS_MSG_ABANDONED(*meta) ||
2144 SCTP_MSG_TO_BE_ABANDONED(*meta, mhdr,
2145 sctp)) {
2146 continue;
2147 }
2148
2149 *mp = (*meta)->b_cont;
2150 goto try_bundle;
2151 }
2152 /* No more chunk to be bundled. */
2153 break;
2154 }
2155
2156 sdc = (sctp_data_hdr_t *)(*mp)->b_rptr;
2157 /* Don't bundle chunks beyond sctp_rxt_maxtsn. */
2158 if (SEQ_GT(ntohl(sdc->sdh_tsn), sctp->sctp_rxt_maxtsn))
2159 break;
2160 new_len = ntohs(sdc->sdh_len);
2161 chunklen = new_len - sizeof (*sdc);
2162
2163 if ((extra = new_len & (SCTP_ALIGN - 1)) != 0)
2164 extra = SCTP_ALIGN - extra;
2165 if ((new_len = seglen + new_len + extra) > fp->sf_pmss)
2166 break;
2167 if ((nmp = dupmsg(*mp)) == NULL)
2168 break;
2169
2170 if (extra > 0) {
2171 fill = sctp_get_padding(sctp, extra);
2172 if (fill != NULL) {
2173 linkb(nmp, fill);
2174 } else {
2175 freemsg(nmp);
2176 break;
2177 }
2178 }
2179 linkb(head, nmp);
2180
2181 SCTP_CHUNK_CLEAR_FLAGS(nmp);
2182 SCTP_CHUNK_SENT(sctp, *mp, sdc, fp, chunklen, *meta);
2183 /*
2184 * Don't update the TSN if we are doing a Zero Win Probe.
2185 */
2186 if (!sctp->sctp_zero_win_probe)
2187 sctp->sctp_rxt_nxttsn = ntohl(sdc->sdh_tsn);
2188
2189 seglen = new_len;
2190 *mp = (*mp)->b_next;
2191 }
2192 *packet_len = seglen;
2193 fp->sf_rxt_unacked += seglen;
2194 return (head);
2195 }
2196
2197 /*
2198 * sctp_ss_rexmit() is called when we get a SACK after a timeout which
2199 * advances the cum_tsn but the cum_tsn is still less than what we have sent
2200 * (sctp_rxt_maxtsn) at the time of the timeout. This SACK is a "partial"
2201 * SACK. We retransmit unacked chunks without having to wait for another
2202 * timeout. The rationale is that the SACK should not be "partial" if all the
2203 * lost chunks have been retransmitted. Since the SACK is "partial,"
2204 * the chunks between the cum_tsn and the sctp_rxt_maxtsn should still
2205 * be missing. It is better for us to retransmit them now instead
2206 * of waiting for a timeout.
2207 */
2208 void
sctp_ss_rexmit(sctp_t * sctp)2209 sctp_ss_rexmit(sctp_t *sctp)
2210 {
2211 mblk_t *meta;
2212 mblk_t *mp;
2213 mblk_t *pkt;
2214 sctp_faddr_t *fp;
2215 uint_t pkt_len;
2216 uint32_t tot_wnd;
2217 sctp_data_hdr_t *sdc;
2218 int burst;
2219 sctp_stack_t *sctps = sctp->sctp_sctps;
2220
2221 ASSERT(!sctp->sctp_zero_win_probe);
2222
2223 /*
2224 * If the last cum ack is smaller than what we have just
2225 * retransmitted, simply return.
2226 */
2227 if (SEQ_GEQ(sctp->sctp_lastack_rxd, sctp->sctp_rxt_nxttsn))
2228 sctp->sctp_rxt_nxttsn = sctp->sctp_lastack_rxd + 1;
2229 else
2230 return;
2231 ASSERT(SEQ_LEQ(sctp->sctp_rxt_nxttsn, sctp->sctp_rxt_maxtsn));
2232
2233 /*
2234 * After a timer fires, sctp_current should be set to the new
2235 * fp where the retransmitted chunks are sent.
2236 */
2237 fp = sctp->sctp_current;
2238
2239 /*
2240 * Since we are retransmitting, we only need to use cwnd to determine
2241 * how much we can send as we were allowed (by peer's receive window)
2242 * to send those retransmitted chunks previously when they are first
2243 * sent. If we record how much we have retransmitted but
2244 * unacknowledged using rxt_unacked, then the amount we can now send
2245 * is equal to cwnd minus rxt_unacked.
2246 *
2247 * The field rxt_unacked is incremented when we retransmit a packet
2248 * and decremented when we got a SACK acknowledging something. And
2249 * it is reset when the retransmission timer fires as we assume that
2250 * all packets have left the network after a timeout. If this
2251 * assumption is not true, it means that after a timeout, we can
2252 * get a SACK acknowledging more than rxt_unacked (its value only
2253 * contains what is retransmitted when the timer fires). So
2254 * rxt_unacked will become very big (it is an unsiged int so going
2255 * negative means that the value is huge). This is the reason we
2256 * always send at least 1 MSS bytes.
2257 *
2258 * The reason why we do not have an accurate count is that we
2259 * only know how many packets are outstanding (using the TSN numbers).
2260 * But we do not know how many bytes those packets contain. To
2261 * have an accurate count, we need to walk through the send list.
2262 * As it is not really important to have an accurate count during
2263 * retransmission, we skip this walk to save some time. This should
2264 * not make the retransmission too aggressive to cause congestion.
2265 */
2266 if (fp->sf_cwnd <= fp->sf_rxt_unacked)
2267 tot_wnd = fp->sf_pmss;
2268 else
2269 tot_wnd = fp->sf_cwnd - fp->sf_rxt_unacked;
2270
2271 /* Find the first unack'ed chunk */
2272 for (meta = sctp->sctp_xmit_head; meta != NULL; meta = meta->b_next) {
2273 sctp_msg_hdr_t *mhdr = (sctp_msg_hdr_t *)meta->b_rptr;
2274
2275 if (SCTP_IS_MSG_ABANDONED(meta) ||
2276 SCTP_MSG_TO_BE_ABANDONED(meta, mhdr, sctp)) {
2277 continue;
2278 }
2279
2280 for (mp = meta->b_cont; mp != NULL; mp = mp->b_next) {
2281 /* Again, this may not be possible */
2282 if (!SCTP_CHUNK_ISSENT(mp))
2283 return;
2284 sdc = (sctp_data_hdr_t *)mp->b_rptr;
2285 if (ntohl(sdc->sdh_tsn) == sctp->sctp_rxt_nxttsn)
2286 goto found_msg;
2287 }
2288 }
2289
2290 /* Everything is abandoned... */
2291 return;
2292
2293 found_msg:
2294 if (!fp->sf_timer_running)
2295 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
2296 pkt = sctp_rexmit_packet(sctp, &meta, &mp, fp, &pkt_len);
2297 if (pkt == NULL) {
2298 SCTP_KSTAT(sctps, sctp_ss_rexmit_failed);
2299 return;
2300 }
2301 if ((pkt_len > fp->sf_pmss) && fp->sf_isv4) {
2302 ipha_t *iph = (ipha_t *)pkt->b_rptr;
2303
2304 /*
2305 * Path MTU is different from path we thought it would
2306 * be when we created chunks, or IP headers have grown.
2307 * Need to clear the DF bit.
2308 */
2309 iph->ipha_fragment_offset_and_flags = 0;
2310 }
2311 sctp_set_iplen(sctp, pkt, fp->sf_ixa);
2312 (void) conn_ip_output(pkt, fp->sf_ixa);
2313 BUMP_LOCAL(sctp->sctp_opkts);
2314
2315 /* Check and see if there is more chunk to be retransmitted. */
2316 if (tot_wnd <= pkt_len || tot_wnd - pkt_len < fp->sf_pmss ||
2317 meta == NULL)
2318 return;
2319 if (mp == NULL)
2320 meta = meta->b_next;
2321 if (meta == NULL)
2322 return;
2323
2324 /* Retransmit another packet if the window allows. */
2325 for (tot_wnd -= pkt_len, burst = sctps->sctps_maxburst - 1;
2326 meta != NULL && burst > 0; meta = meta->b_next, burst--) {
2327 if (mp == NULL)
2328 mp = meta->b_cont;
2329 for (; mp != NULL; mp = mp->b_next) {
2330 /* Again, this may not be possible */
2331 if (!SCTP_CHUNK_ISSENT(mp))
2332 return;
2333 if (!SCTP_CHUNK_ISACKED(mp))
2334 goto found_msg;
2335 }
2336 }
2337 }
2338