1/* SCTP kernel implementation
   2 * (C) Copyright IBM Corp. 2001, 2004
   3 * Copyright (c) 1999-2000 Cisco, Inc.
   4 * Copyright (c) 1999-2001 Motorola, Inc.
   5 * Copyright (c) 2001-2003 Intel Corp.
   6 *
   7 * This file is part of the SCTP kernel implementation
   8 *
   9 * These functions implement the sctp_outq class.   The outqueue handles
  10 * bundling and queueing of outgoing SCTP chunks.
  11 *
  12 * This SCTP implementation is free software;
  13 * you can redistribute it and/or modify it under the terms of
  14 * the GNU General Public License as published by
  15 * the Free Software Foundation; either version 2, or (at your option)
  16 * any later version.
  17 *
  18 * This SCTP implementation is distributed in the hope that it
  19 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  20 *                 ************************
  21 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22 * See the GNU General Public License for more details.
  23 *
  24 * You should have received a copy of the GNU General Public License
  25 * along with GNU CC; see the file COPYING.  If not, see
  26 * <http://www.gnu.org/licenses/>.
  27 *
  28 * Please send any bug reports or fixes you make to the
  29 * email address(es):
  30 *    lksctp developers <linux-sctp@vger.kernel.org>
  31 *
  32 * Written or modified by:
  33 *    La Monte H.P. Yarroll <piggy@acm.org>
  34 *    Karl Knutson          <karl@athena.chicago.il.us>
  35 *    Perry Melange         <pmelange@null.cc.uic.edu>
  36 *    Xingang Guo           <xingang.guo@intel.com>
  37 *    Hui Huang 	    <hui.huang@nokia.com>
  38 *    Sridhar Samudrala     <sri@us.ibm.com>
  39 *    Jon Grimm             <jgrimm@us.ibm.com>
  40 */
  41
  42#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  43
  44#include <linux/types.h>
  45#include <linux/list.h>   /* For struct list_head */
  46#include <linux/socket.h>
  47#include <linux/ip.h>
  48#include <linux/slab.h>
  49#include <net/sock.h>	  /* For skb_set_owner_w */
  50
  51#include <net/sctp/sctp.h>
  52#include <net/sctp/sm.h>
  53
  54/* Declare internal functions here.  */
  55static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
  56static void sctp_check_transmitted(struct sctp_outq *q,
  57				   struct list_head *transmitted_queue,
  58				   struct sctp_transport *transport,
  59				   union sctp_addr *saddr,
  60				   struct sctp_sackhdr *sack,
  61				   __u32 *highest_new_tsn);
  62
  63static void sctp_mark_missing(struct sctp_outq *q,
  64			      struct list_head *transmitted_queue,
  65			      struct sctp_transport *transport,
  66			      __u32 highest_new_tsn,
  67			      int count_of_newacks);
  68
  69static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
  70
  71static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
  72
  73/* Add data to the front of the queue. */
  74static inline void sctp_outq_head_data(struct sctp_outq *q,
  75					struct sctp_chunk *ch)
  76{
  77	list_add(&ch->list, &q->out_chunk_list);
  78	q->out_qlen += ch->skb->len;
  79}
  80
  81/* Take data from the front of the queue. */
  82static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
  83{
  84	struct sctp_chunk *ch = NULL;
  85
  86	if (!list_empty(&q->out_chunk_list)) {
  87		struct list_head *entry = q->out_chunk_list.next;
  88
  89		ch = list_entry(entry, struct sctp_chunk, list);
  90		list_del_init(entry);
  91		q->out_qlen -= ch->skb->len;
  92	}
  93	return ch;
  94}
  95/* Add data chunk to the end of the queue. */
  96static inline void sctp_outq_tail_data(struct sctp_outq *q,
  97				       struct sctp_chunk *ch)
  98{
  99	list_add_tail(&ch->list, &q->out_chunk_list);
 100	q->out_qlen += ch->skb->len;
 101}
 102
 103/*
 104 * SFR-CACC algorithm:
 105 * D) If count_of_newacks is greater than or equal to 2
 106 * and t was not sent to the current primary then the
 107 * sender MUST NOT increment missing report count for t.
 108 */
 109static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
 110				       struct sctp_transport *transport,
 111				       int count_of_newacks)
 112{
 113	if (count_of_newacks >= 2 && transport != primary)
 114		return 1;
 115	return 0;
 116}
 117
 118/*
 119 * SFR-CACC algorithm:
 120 * F) If count_of_newacks is less than 2, let d be the
 121 * destination to which t was sent. If cacc_saw_newack
 122 * is 0 for destination d, then the sender MUST NOT
 123 * increment missing report count for t.
 124 */
 125static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
 126				       int count_of_newacks)
 127{
 128	if (count_of_newacks < 2 &&
 129			(transport && !transport->cacc.cacc_saw_newack))
 130		return 1;
 131	return 0;
 132}
 133
 134/*
 135 * SFR-CACC algorithm:
 136 * 3.1) If CYCLING_CHANGEOVER is 0, the sender SHOULD
 137 * execute steps C, D, F.
 138 *
 139 * C has been implemented in sctp_outq_sack
 140 */
 141static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary,
 142				     struct sctp_transport *transport,
 143				     int count_of_newacks)
 144{
 145	if (!primary->cacc.cycling_changeover) {
 146		if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks))
 147			return 1;
 148		if (sctp_cacc_skip_3_1_f(transport, count_of_newacks))
 149			return 1;
 150		return 0;
 151	}
 152	return 0;
 153}
 154
 155/*
 156 * SFR-CACC algorithm:
 157 * 3.2) Else if CYCLING_CHANGEOVER is 1, and t is less
 158 * than next_tsn_at_change of the current primary, then
 159 * the sender MUST NOT increment missing report count
 160 * for t.
 161 */
 162static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn)
 163{
 164	if (primary->cacc.cycling_changeover &&
 165	    TSN_lt(tsn, primary->cacc.next_tsn_at_change))
 166		return 1;
 167	return 0;
 168}
 169
 170/*
 171 * SFR-CACC algorithm:
 172 * 3) If the missing report count for TSN t is to be
 173 * incremented according to [RFC2960] and
 174 * [SCTP_STEWART-2002], and CHANGEOVER_ACTIVE is set,
 175 * then the sender MUST further execute steps 3.1 and
 176 * 3.2 to determine if the missing report count for
 177 * TSN t SHOULD NOT be incremented.
 178 *
 179 * 3.3) If 3.1 and 3.2 do not dictate that the missing
 180 * report count for t should not be incremented, then
 181 * the sender SHOULD increment missing report count for
 182 * t (according to [RFC2960] and [SCTP_STEWART_2002]).
 183 */
 184static inline int sctp_cacc_skip(struct sctp_transport *primary,
 185				 struct sctp_transport *transport,
 186				 int count_of_newacks,
 187				 __u32 tsn)
 188{
 189	if (primary->cacc.changeover_active &&
 190	    (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
 191	     sctp_cacc_skip_3_2(primary, tsn)))
 192		return 1;
 193	return 0;
 194}
 195
 196/* Initialize an existing sctp_outq.  This does the boring stuff.
 197 * You still need to define handlers if you really want to DO
 198 * something with this structure...
 199 */
 200void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
 201{
 202	memset(q, 0, sizeof(struct sctp_outq));
 203
 204	q->asoc = asoc;
 205	INIT_LIST_HEAD(&q->out_chunk_list);
 206	INIT_LIST_HEAD(&q->control_chunk_list);
 207	INIT_LIST_HEAD(&q->retransmit);
 208	INIT_LIST_HEAD(&q->sacked);
 209	INIT_LIST_HEAD(&q->abandoned);
 210}
 211
 212/* Free the outqueue structure and any related pending chunks.
 213 */
 214static void __sctp_outq_teardown(struct sctp_outq *q)
 215{
 216	struct sctp_transport *transport;
 217	struct list_head *lchunk, *temp;
 218	struct sctp_chunk *chunk, *tmp;
 219
 220	/* Throw away unacknowledged chunks. */
 221	list_for_each_entry(transport, &q->asoc->peer.transport_addr_list,
 222			transports) {
 223		while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) {
 224			chunk = list_entry(lchunk, struct sctp_chunk,
 225					   transmitted_list);
 226			/* Mark as part of a failed message. */
 227			sctp_chunk_fail(chunk, q->error);
 228			sctp_chunk_free(chunk);
 229		}
 230	}
 231
 232	/* Throw away chunks that have been gap ACKed.  */
 233	list_for_each_safe(lchunk, temp, &q->sacked) {
 234		list_del_init(lchunk);
 235		chunk = list_entry(lchunk, struct sctp_chunk,
 236				   transmitted_list);
 237		sctp_chunk_fail(chunk, q->error);
 238		sctp_chunk_free(chunk);
 239	}
 240
 241	/* Throw away any chunks in the retransmit queue. */
 242	list_for_each_safe(lchunk, temp, &q->retransmit) {
 243		list_del_init(lchunk);
 244		chunk = list_entry(lchunk, struct sctp_chunk,
 245				   transmitted_list);
 246		sctp_chunk_fail(chunk, q->error);
 247		sctp_chunk_free(chunk);
 248	}
 249
 250	/* Throw away any chunks that are in the abandoned queue. */
 251	list_for_each_safe(lchunk, temp, &q->abandoned) {
 252		list_del_init(lchunk);
 253		chunk = list_entry(lchunk, struct sctp_chunk,
 254				   transmitted_list);
 255		sctp_chunk_fail(chunk, q->error);
 256		sctp_chunk_free(chunk);
 257	}
 258
 259	/* Throw away any leftover data chunks. */
 260	while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
 261
 262		/* Mark as send failure. */
 263		sctp_chunk_fail(chunk, q->error);
 264		sctp_chunk_free(chunk);
 265	}
 266
 267	/* Throw away any leftover control chunks. */
 268	list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
 269		list_del_init(&chunk->list);
 270		sctp_chunk_free(chunk);
 271	}
 272}
 273
 274void sctp_outq_teardown(struct sctp_outq *q)
 275{
 276	__sctp_outq_teardown(q);
 277	sctp_outq_init(q->asoc, q);
 278}
 279
 280/* Free the outqueue structure and any related pending chunks.  */
 281void sctp_outq_free(struct sctp_outq *q)
 282{
 283	/* Throw away leftover chunks. */
 284	__sctp_outq_teardown(q);
 285}
 286
 287/* Put a new chunk in an sctp_outq.  */
 288int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)
 289{
 290	struct net *net = sock_net(q->asoc->base.sk);
 291	int error = 0;
 292
 293	pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,
 294		 chunk && chunk->chunk_hdr ?
 295		 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
 296		 "illegal chunk");
 297
 298	/* If it is data, queue it up, otherwise, send it
 299	 * immediately.
 300	 */
 301	if (sctp_chunk_is_data(chunk)) {
 302		/* Is it OK to queue data chunks?  */
 303		/* From 9. Termination of Association
 304		 *
 305		 * When either endpoint performs a shutdown, the
 306		 * association on each peer will stop accepting new
 307		 * data from its user and only deliver data in queue
 308		 * at the time of sending or receiving the SHUTDOWN
 309		 * chunk.
 310		 */
 311		switch (q->asoc->state) {
 312		case SCTP_STATE_CLOSED:
 313		case SCTP_STATE_SHUTDOWN_PENDING:
 314		case SCTP_STATE_SHUTDOWN_SENT:
 315		case SCTP_STATE_SHUTDOWN_RECEIVED:
 316		case SCTP_STATE_SHUTDOWN_ACK_SENT:
 317			/* Cannot send after transport endpoint shutdown */
 318			error = -ESHUTDOWN;
 319			break;
 320
 321		default:
 322			pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n",
 323				 __func__, q, chunk, chunk && chunk->chunk_hdr ?
 324				 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
 325				 "illegal chunk");
 326
 327			sctp_chunk_hold(chunk);
 328			sctp_outq_tail_data(q, chunk);
 329			if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
 330				SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS);
 331			else
 332				SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS);
 333			break;
 334		}
 335	} else {
 336		list_add_tail(&chunk->list, &q->control_chunk_list);
 337		SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS);
 338	}
 339
 340	if (error < 0)
 341		return error;
 342
 343	if (!q->cork)
 344		error = sctp_outq_flush(q, 0, gfp);
 345
 346	return error;
 347}
 348
 349/* Insert a chunk into the sorted list based on the TSNs.  The retransmit list
 350 * and the abandoned list are in ascending order.
 351 */
 352static void sctp_insert_list(struct list_head *head, struct list_head *new)
 353{
 354	struct list_head *pos;
 355	struct sctp_chunk *nchunk, *lchunk;
 356	__u32 ntsn, ltsn;
 357	int done = 0;
 358
 359	nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
 360	ntsn = ntohl(nchunk->subh.data_hdr->tsn);
 361
 362	list_for_each(pos, head) {
 363		lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
 364		ltsn = ntohl(lchunk->subh.data_hdr->tsn);
 365		if (TSN_lt(ntsn, ltsn)) {
 366			list_add(new, pos->prev);
 367			done = 1;
 368			break;
 369		}
 370	}
 371	if (!done)
 372		list_add_tail(new, head);
 373}
 374
 375/* Mark all the eligible packets on a transport for retransmission.  */
 376void sctp_retransmit_mark(struct sctp_outq *q,
 377			  struct sctp_transport *transport,
 378			  __u8 reason)
 379{
 380	struct list_head *lchunk, *ltemp;
 381	struct sctp_chunk *chunk;
 382
 383	/* Walk through the specified transmitted queue.  */
 384	list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
 385		chunk = list_entry(lchunk, struct sctp_chunk,
 386				   transmitted_list);
 387
 388		/* If the chunk is abandoned, move it to abandoned list. */
 389		if (sctp_chunk_abandoned(chunk)) {
 390			list_del_init(lchunk);
 391			sctp_insert_list(&q->abandoned, lchunk);
 392
 393			/* If this chunk has not been previousely acked,
 394			 * stop considering it 'outstanding'.  Our peer
 395			 * will most likely never see it since it will
 396			 * not be retransmitted
 397			 */
 398			if (!chunk->tsn_gap_acked) {
 399				if (chunk->transport)
 400					chunk->transport->flight_size -=
 401							sctp_data_size(chunk);
 402				q->outstanding_bytes -= sctp_data_size(chunk);
 403				q->asoc->peer.rwnd += sctp_data_size(chunk);
 404			}
 405			continue;
 406		}
 407
 408		/* If we are doing  retransmission due to a timeout or pmtu
 409		 * discovery, only the  chunks that are not yet acked should
 410		 * be added to the retransmit queue.
 411		 */
 412		if ((reason == SCTP_RTXR_FAST_RTX  &&
 413			    (chunk->fast_retransmit == SCTP_NEED_FRTX)) ||
 414		    (reason != SCTP_RTXR_FAST_RTX  && !chunk->tsn_gap_acked)) {
 415			/* RFC 2960 6.2.1 Processing a Received SACK
 416			 *
 417			 * C) Any time a DATA chunk is marked for
 418			 * retransmission (via either T3-rtx timer expiration
 419			 * (Section 6.3.3) or via fast retransmit
 420			 * (Section 7.2.4)), add the data size of those
 421			 * chunks to the rwnd.
 422			 */
 423			q->asoc->peer.rwnd += sctp_data_size(chunk);
 424			q->outstanding_bytes -= sctp_data_size(chunk);
 425			if (chunk->transport)
 426				transport->flight_size -= sctp_data_size(chunk);
 427
 428			/* sctpimpguide-05 Section 2.8.2
 429			 * M5) If a T3-rtx timer expires, the
 430			 * 'TSN.Missing.Report' of all affected TSNs is set
 431			 * to 0.
 432			 */
 433			chunk->tsn_missing_report = 0;
 434
 435			/* If a chunk that is being used for RTT measurement
 436			 * has to be retransmitted, we cannot use this chunk
 437			 * anymore for RTT measurements. Reset rto_pending so
 438			 * that a new RTT measurement is started when a new
 439			 * data chunk is sent.
 440			 */
 441			if (chunk->rtt_in_progress) {
 442				chunk->rtt_in_progress = 0;
 443				transport->rto_pending = 0;
 444			}
 445
 446			chunk->resent = 1;
 447
 448			/* Move the chunk to the retransmit queue. The chunks
 449			 * on the retransmit queue are always kept in order.
 450			 */
 451			list_del_init(lchunk);
 452			sctp_insert_list(&q->retransmit, lchunk);
 453		}
 454	}
 455
 456	pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, "
 457		 "flight_size:%d, pba:%d\n", __func__, transport, reason,
 458		 transport->cwnd, transport->ssthresh, transport->flight_size,
 459		 transport->partial_bytes_acked);
 460}
 461
 462/* Mark all the eligible packets on a transport for retransmission and force
 463 * one packet out.
 464 */
 465void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
 466		     sctp_retransmit_reason_t reason)
 467{
 468	struct net *net = sock_net(q->asoc->base.sk);
 469	int error = 0;
 470
 471	switch (reason) {
 472	case SCTP_RTXR_T3_RTX:
 473		SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS);
 474		sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
 475		/* Update the retran path if the T3-rtx timer has expired for
 476		 * the current retran path.
 477		 */
 478		if (transport == transport->asoc->peer.retran_path)
 479			sctp_assoc_update_retran_path(transport->asoc);
 480		transport->asoc->rtx_data_chunks +=
 481			transport->asoc->unack_data;
 482		break;
 483	case SCTP_RTXR_FAST_RTX:
 484		SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS);
 485		sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
 486		q->fast_rtx = 1;
 487		break;
 488	case SCTP_RTXR_PMTUD:
 489		SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS);
 490		break;
 491	case SCTP_RTXR_T1_RTX:
 492		SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS);
 493		transport->asoc->init_retries++;
 494		break;
 495	default:
 496		BUG();
 497	}
 498
 499	sctp_retransmit_mark(q, transport, reason);
 500
 501	/* PR-SCTP A5) Any time the T3-rtx timer expires, on any destination,
 502	 * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by
 503	 * following the procedures outlined in C1 - C5.
 504	 */
 505	if (reason == SCTP_RTXR_T3_RTX)
 506		sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
 507
 508	/* Flush the queues only on timeout, since fast_rtx is only
 509	 * triggered during sack processing and the queue
 510	 * will be flushed at the end.
 511	 */
 512	if (reason != SCTP_RTXR_FAST_RTX)
 513		error = sctp_outq_flush(q, /* rtx_timeout */ 1, GFP_ATOMIC);
 514
 515	if (error)
 516		q->asoc->base.sk->sk_err = -error;
 517}
 518
 519/*
 520 * Transmit DATA chunks on the retransmit queue.  Upon return from
 521 * sctp_outq_flush_rtx() the packet 'pkt' may contain chunks which
 522 * need to be transmitted by the caller.
 523 * We assume that pkt->transport has already been set.
 524 *
 525 * The return value is a normal kernel error return value.
 526 */
 527static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
 528			       int rtx_timeout, int *start_timer)
 529{
 530	struct list_head *lqueue;
 531	struct sctp_transport *transport = pkt->transport;
 532	sctp_xmit_t status;
 533	struct sctp_chunk *chunk, *chunk1;
 534	int fast_rtx;
 535	int error = 0;
 536	int timer = 0;
 537	int done = 0;
 538
 539	lqueue = &q->retransmit;
 540	fast_rtx = q->fast_rtx;
 541
 542	/* This loop handles time-out retransmissions, fast retransmissions,
 543	 * and retransmissions due to opening of whindow.
 544	 *
 545	 * RFC 2960 6.3.3 Handle T3-rtx Expiration
 546	 *
 547	 * E3) Determine how many of the earliest (i.e., lowest TSN)
 548	 * outstanding DATA chunks for the address for which the
 549	 * T3-rtx has expired will fit into a single packet, subject
 550	 * to the MTU constraint for the path corresponding to the
 551	 * destination transport address to which the retransmission
 552	 * is being sent (this may be different from the address for
 553	 * which the timer expires [see Section 6.4]). Call this value
 554	 * K. Bundle and retransmit those K DATA chunks in a single
 555	 * packet to the destination endpoint.
 556	 *
 557	 * [Just to be painfully clear, if we are retransmitting
 558	 * because a timeout just happened, we should send only ONE
 559	 * packet of retransmitted data.]
 560	 *
 561	 * For fast retransmissions we also send only ONE packet.  However,
 562	 * if we are just flushing the queue due to open window, we'll
 563	 * try to send as much as possible.
 564	 */
 565	list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
 566		/* If the chunk is abandoned, move it to abandoned list. */
 567		if (sctp_chunk_abandoned(chunk)) {
 568			list_del_init(&chunk->transmitted_list);
 569			sctp_insert_list(&q->abandoned,
 570					 &chunk->transmitted_list);
 571			continue;
 572		}
 573
 574		/* Make sure that Gap Acked TSNs are not retransmitted.  A
 575		 * simple approach is just to move such TSNs out of the
 576		 * way and into a 'transmitted' queue and skip to the
 577		 * next chunk.
 578		 */
 579		if (chunk->tsn_gap_acked) {
 580			list_move_tail(&chunk->transmitted_list,
 581				       &transport->transmitted);
 582			continue;
 583		}
 584
 585		/* If we are doing fast retransmit, ignore non-fast_rtransmit
 586		 * chunks
 587		 */
 588		if (fast_rtx && !chunk->fast_retransmit)
 589			continue;
 590
 591redo:
 592		/* Attempt to append this chunk to the packet. */
 593		status = sctp_packet_append_chunk(pkt, chunk);
 594
 595		switch (status) {
 596		case SCTP_XMIT_PMTU_FULL:
 597			if (!pkt->has_data && !pkt->has_cookie_echo) {
 598				/* If this packet did not contain DATA then
 599				 * retransmission did not happen, so do it
 600				 * again.  We'll ignore the error here since
 601				 * control chunks are already freed so there
 602				 * is nothing we can do.
 603				 */
 604				sctp_packet_transmit(pkt, GFP_ATOMIC);
 605				goto redo;
 606			}
 607
 608			/* Send this packet.  */
 609			error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 610
 611			/* If we are retransmitting, we should only
 612			 * send a single packet.
 613			 * Otherwise, try appending this chunk again.
 614			 */
 615			if (rtx_timeout || fast_rtx)
 616				done = 1;
 617			else
 618				goto redo;
 619
 620			/* Bundle next chunk in the next round.  */
 621			break;
 622
 623		case SCTP_XMIT_RWND_FULL:
 624			/* Send this packet. */
 625			error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 626
 627			/* Stop sending DATA as there is no more room
 628			 * at the receiver.
 629			 */
 630			done = 1;
 631			break;
 632
 633		case SCTP_XMIT_DELAY:
 634			/* Send this packet. */
 635			error = sctp_packet_transmit(pkt, GFP_ATOMIC);
 636
 637			/* Stop sending DATA because of nagle delay. */
 638			done = 1;
 639			break;
 640
 641		default:
 642			/* The append was successful, so add this chunk to
 643			 * the transmitted list.
 644			 */
 645			list_move_tail(&chunk->transmitted_list,
 646				       &transport->transmitted);
 647
 648			/* Mark the chunk as ineligible for fast retransmit
 649			 * after it is retransmitted.
 650			 */
 651			if (chunk->fast_retransmit == SCTP_NEED_FRTX)
 652				chunk->fast_retransmit = SCTP_DONT_FRTX;
 653
 654			q->asoc->stats.rtxchunks++;
 655			break;
 656		}
 657
 658		/* Set the timer if there were no errors */
 659		if (!error && !timer)
 660			timer = 1;
 661
 662		if (done)
 663			break;
 664	}
 665
 666	/* If we are here due to a retransmit timeout or a fast
 667	 * retransmit and if there are any chunks left in the retransmit
 668	 * queue that could not fit in the PMTU sized packet, they need
 669	 * to be marked as ineligible for a subsequent fast retransmit.
 670	 */
 671	if (rtx_timeout || fast_rtx) {
 672		list_for_each_entry(chunk1, lqueue, transmitted_list) {
 673			if (chunk1->fast_retransmit == SCTP_NEED_FRTX)
 674				chunk1->fast_retransmit = SCTP_DONT_FRTX;
 675		}
 676	}
 677
 678	*start_timer = timer;
 679
 680	/* Clear fast retransmit hint */
 681	if (fast_rtx)
 682		q->fast_rtx = 0;
 683
 684	return error;
 685}
 686
 687/* Cork the outqueue so queued chunks are really queued. */
 688int sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp)
 689{
 690	if (q->cork)
 691		q->cork = 0;
 692
 693	return sctp_outq_flush(q, 0, gfp);
 694}
 695
 696
 697/*
 698 * Try to flush an outqueue.
 699 *
 700 * Description: Send everything in q which we legally can, subject to
 701 * congestion limitations.
 702 * * Note: This function can be called from multiple contexts so appropriate
 703 * locking concerns must be made.  Today we use the sock lock to protect
 704 * this function.
 705 */
 706static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
 707{
 708	struct sctp_packet *packet;
 709	struct sctp_packet singleton;
 710	struct sctp_association *asoc = q->asoc;
 711	__u16 sport = asoc->base.bind_addr.port;
 712	__u16 dport = asoc->peer.port;
 713	__u32 vtag = asoc->peer.i.init_tag;
 714	struct sctp_transport *transport = NULL;
 715	struct sctp_transport *new_transport;
 716	struct sctp_chunk *chunk, *tmp;
 717	sctp_xmit_t status;
 718	int error = 0;
 719	int start_timer = 0;
 720	int one_packet = 0;
 721
 722	/* These transports have chunks to send. */
 723	struct list_head transport_list;
 724	struct list_head *ltransport;
 725
 726	INIT_LIST_HEAD(&transport_list);
 727	packet = NULL;
 728
 729	/*
 730	 * 6.10 Bundling
 731	 *   ...
 732	 *   When bundling control chunks with DATA chunks, an
 733	 *   endpoint MUST place control chunks first in the outbound
 734	 *   SCTP packet.  The transmitter MUST transmit DATA chunks
 735	 *   within a SCTP packet in increasing order of TSN.
 736	 *   ...
 737	 */
 738
 739	list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
 740		/* RFC 5061, 5.3
 741		 * F1) This means that until such time as the ASCONF
 742		 * containing the add is acknowledged, the sender MUST
 743		 * NOT use the new IP address as a source for ANY SCTP
 744		 * packet except on carrying an ASCONF Chunk.
 745		 */
 746		if (asoc->src_out_of_asoc_ok &&
 747		    chunk->chunk_hdr->type != SCTP_CID_ASCONF)
 748			continue;
 749
 750		list_del_init(&chunk->list);
 751
 752		/* Pick the right transport to use. */
 753		new_transport = chunk->transport;
 754
 755		if (!new_transport) {
 756			/*
 757			 * If we have a prior transport pointer, see if
 758			 * the destination address of the chunk
 759			 * matches the destination address of the
 760			 * current transport.  If not a match, then
 761			 * try to look up the transport with a given
 762			 * destination address.  We do this because
 763			 * after processing ASCONFs, we may have new
 764			 * transports created.
 765			 */
 766			if (transport &&
 767			    sctp_cmp_addr_exact(&chunk->dest,
 768						&transport->ipaddr))
 769					new_transport = transport;
 770			else
 771				new_transport = sctp_assoc_lookup_paddr(asoc,
 772								&chunk->dest);
 773
 774			/* if we still don't have a new transport, then
 775			 * use the current active path.
 776			 */
 777			if (!new_transport)
 778				new_transport = asoc->peer.active_path;
 779		} else if ((new_transport->state == SCTP_INACTIVE) ||
 780			   (new_transport->state == SCTP_UNCONFIRMED) ||
 781			   (new_transport->state == SCTP_PF)) {
 782			/* If the chunk is Heartbeat or Heartbeat Ack,
 783			 * send it to chunk->transport, even if it's
 784			 * inactive.
 785			 *
 786			 * 3.3.6 Heartbeat Acknowledgement:
 787			 * ...
 788			 * A HEARTBEAT ACK is always sent to the source IP
 789			 * address of the IP datagram containing the
 790			 * HEARTBEAT chunk to which this ack is responding.
 791			 * ...
 792			 *
 793			 * ASCONF_ACKs also must be sent to the source.
 794			 */
 795			if (chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT &&
 796			    chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT_ACK &&
 797			    chunk->chunk_hdr->type != SCTP_CID_ASCONF_ACK)
 798				new_transport = asoc->peer.active_path;
 799		}
 800
 801		/* Are we switching transports?
 802		 * Take care of transport locks.
 803		 */
 804		if (new_transport != transport) {
 805			transport = new_transport;
 806			if (list_empty(&transport->send_ready)) {
 807				list_add_tail(&transport->send_ready,
 808					      &transport_list);
 809			}
 810			packet = &transport->packet;
 811			sctp_packet_config(packet, vtag,
 812					   asoc->peer.ecn_capable);
 813		}
 814
 815		switch (chunk->chunk_hdr->type) {
 816		/*
 817		 * 6.10 Bundling
 818		 *   ...
 819		 *   An endpoint MUST NOT bundle INIT, INIT ACK or SHUTDOWN
 820		 *   COMPLETE with any other chunks.  [Send them immediately.]
 821		 */
 822		case SCTP_CID_INIT:
 823		case SCTP_CID_INIT_ACK:
 824		case SCTP_CID_SHUTDOWN_COMPLETE:
 825			sctp_packet_init(&singleton, transport, sport, dport);
 826			sctp_packet_config(&singleton, vtag, 0);
 827			sctp_packet_append_chunk(&singleton, chunk);
 828			error = sctp_packet_transmit(&singleton, gfp);
 829			if (error < 0)
 830				return error;
 831			break;
 832
 833		case SCTP_CID_ABORT:
 834			if (sctp_test_T_bit(chunk)) {
 835				packet->vtag = asoc->c.my_vtag;
 836			}
 837		/* The following chunks are "response" chunks, i.e.
 838		 * they are generated in response to something we
 839		 * received.  If we are sending these, then we can
 840		 * send only 1 packet containing these chunks.
 841		 */
 842		case SCTP_CID_HEARTBEAT_ACK:
 843		case SCTP_CID_SHUTDOWN_ACK:
 844		case SCTP_CID_COOKIE_ACK:
 845		case SCTP_CID_COOKIE_ECHO:
 846		case SCTP_CID_ERROR:
 847		case SCTP_CID_ECN_CWR:
 848		case SCTP_CID_ASCONF_ACK:
 849			one_packet = 1;
 850			/* Fall through */
 851
 852		case SCTP_CID_SACK:
 853		case SCTP_CID_HEARTBEAT:
 854		case SCTP_CID_SHUTDOWN:
 855		case SCTP_CID_ECN_ECNE:
 856		case SCTP_CID_ASCONF:
 857		case SCTP_CID_FWD_TSN:
 858			status = sctp_packet_transmit_chunk(packet, chunk,
 859							    one_packet, gfp);
 860			if (status  != SCTP_XMIT_OK) {
 861				/* put the chunk back */
 862				list_add(&chunk->list, &q->control_chunk_list);
 863			} else {
 864				asoc->stats.octrlchunks++;
 865				/* PR-SCTP C5) If a FORWARD TSN is sent, the
 866				 * sender MUST assure that at least one T3-rtx
 867				 * timer is running.
 868				 */
 869				if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN) {
 870					sctp_transport_reset_t3_rtx(transport);
 871					transport->last_time_sent = jiffies;
 872				}
 873			}
 874			break;
 875
 876		default:
 877			/* We built a chunk with an illegal type! */
 878			BUG();
 879		}
 880	}
 881
 882	if (q->asoc->src_out_of_asoc_ok)
 883		goto sctp_flush_out;
 884
 885	/* Is it OK to send data chunks?  */
 886	switch (asoc->state) {
 887	case SCTP_STATE_COOKIE_ECHOED:
 888		/* Only allow bundling when this packet has a COOKIE-ECHO
 889		 * chunk.
 890		 */
 891		if (!packet || !packet->has_cookie_echo)
 892			break;
 893
 894		/* fallthru */
 895	case SCTP_STATE_ESTABLISHED:
 896	case SCTP_STATE_SHUTDOWN_PENDING:
 897	case SCTP_STATE_SHUTDOWN_RECEIVED:
 898		/*
 899		 * RFC 2960 6.1  Transmission of DATA Chunks
 900		 *
 901		 * C) When the time comes for the sender to transmit,
 902		 * before sending new DATA chunks, the sender MUST
 903		 * first transmit any outstanding DATA chunks which
 904		 * are marked for retransmission (limited by the
 905		 * current cwnd).
 906		 */
 907		if (!list_empty(&q->retransmit)) {
 908			if (asoc->peer.retran_path->state == SCTP_UNCONFIRMED)
 909				goto sctp_flush_out;
 910			if (transport == asoc->peer.retran_path)
 911				goto retran;
 912
 913			/* Switch transports & prepare the packet.  */
 914
 915			transport = asoc->peer.retran_path;
 916
 917			if (list_empty(&transport->send_ready)) {
 918				list_add_tail(&transport->send_ready,
 919					      &transport_list);
 920			}
 921
 922			packet = &transport->packet;
 923			sctp_packet_config(packet, vtag,
 924					   asoc->peer.ecn_capable);
 925		retran:
 926			error = sctp_outq_flush_rtx(q, packet,
 927						    rtx_timeout, &start_timer);
 928
 929			if (start_timer) {
 930				sctp_transport_reset_t3_rtx(transport);
 931				transport->last_time_sent = jiffies;
 932			}
 933
 934			/* This can happen on COOKIE-ECHO resend.  Only
 935			 * one chunk can get bundled with a COOKIE-ECHO.
 936			 */
 937			if (packet->has_cookie_echo)
 938				goto sctp_flush_out;
 939
 940			/* Don't send new data if there is still data
 941			 * waiting to retransmit.
 942			 */
 943			if (!list_empty(&q->retransmit))
 944				goto sctp_flush_out;
 945		}
 946
 947		/* Apply Max.Burst limitation to the current transport in
 948		 * case it will be used for new data.  We are going to
 949		 * rest it before we return, but we want to apply the limit
 950		 * to the currently queued data.
 951		 */
 952		if (transport)
 953			sctp_transport_burst_limited(transport);
 954
 955		/* Finally, transmit new packets.  */
 956		while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
 957			/* RFC 2960 6.5 Every DATA chunk MUST carry a valid
 958			 * stream identifier.
 959			 */
 960			if (chunk->sinfo.sinfo_stream >=
 961			    asoc->c.sinit_num_ostreams) {
 962
 963				/* Mark as failed send. */
 964				sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
 965				sctp_chunk_free(chunk);
 966				continue;
 967			}
 968
 969			/* Has this chunk expired? */
 970			if (sctp_chunk_abandoned(chunk)) {
 971				sctp_chunk_fail(chunk, 0);
 972				sctp_chunk_free(chunk);
 973				continue;
 974			}
 975
 976			/* If there is a specified transport, use it.
 977			 * Otherwise, we want to use the active path.
 978			 */
 979			new_transport = chunk->transport;
 980			if (!new_transport ||
 981			    ((new_transport->state == SCTP_INACTIVE) ||
 982			     (new_transport->state == SCTP_UNCONFIRMED) ||
 983			     (new_transport->state == SCTP_PF)))
 984				new_transport = asoc->peer.active_path;
 985			if (new_transport->state == SCTP_UNCONFIRMED) {
 986				WARN_ONCE(1, "Atempt to send packet on unconfirmed path.");
 987				sctp_chunk_fail(chunk, 0);
 988				sctp_chunk_free(chunk);
 989				continue;
 990			}
 991
 992			/* Change packets if necessary.  */
 993			if (new_transport != transport) {
 994				transport = new_transport;
 995
 996				/* Schedule to have this transport's
 997				 * packet flushed.
 998				 */
 999				if (list_empty(&transport->send_ready)) {
1000					list_add_tail(&transport->send_ready,
1001						      &transport_list);
1002				}
1003
1004				packet = &transport->packet;
1005				sctp_packet_config(packet, vtag,
1006						   asoc->peer.ecn_capable);
1007				/* We've switched transports, so apply the
1008				 * Burst limit to the new transport.
1009				 */
1010				sctp_transport_burst_limited(transport);
1011			}
1012
1013			pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p "
1014				 "skb->users:%d\n",
1015				 __func__, q, chunk, chunk && chunk->chunk_hdr ?
1016				 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
1017				 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn),
1018				 chunk->skb ? chunk->skb->head : NULL, chunk->skb ?
1019				 atomic_read(&chunk->skb->users) : -1);
1020
1021			/* Add the chunk to the packet.  */
1022			status = sctp_packet_transmit_chunk(packet, chunk, 0, gfp);
1023
1024			switch (status) {
1025			case SCTP_XMIT_PMTU_FULL:
1026			case SCTP_XMIT_RWND_FULL:
1027			case SCTP_XMIT_DELAY:
1028				/* We could not append this chunk, so put
1029				 * the chunk back on the output queue.
1030				 */
1031				pr_debug("%s: could not transmit tsn:0x%x, status:%d\n",
1032					 __func__, ntohl(chunk->subh.data_hdr->tsn),
1033					 status);
1034
1035				sctp_outq_head_data(q, chunk);
1036				goto sctp_flush_out;
 
1037
1038			case SCTP_XMIT_OK:
1039				/* The sender is in the SHUTDOWN-PENDING state,
1040				 * The sender MAY set the I-bit in the DATA
1041				 * chunk header.
1042				 */
1043				if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING)
1044					chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;
1045				if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1046					asoc->stats.ouodchunks++;
1047				else
1048					asoc->stats.oodchunks++;
1049
1050				break;
1051
1052			default:
1053				BUG();
1054			}
1055
1056			/* BUG: We assume that the sctp_packet_transmit()
1057			 * call below will succeed all the time and add the
1058			 * chunk to the transmitted list and restart the
1059			 * timers.
1060			 * It is possible that the call can fail under OOM
1061			 * conditions.
1062			 *
1063			 * Is this really a problem?  Won't this behave
1064			 * like a lost TSN?
1065			 */
1066			list_add_tail(&chunk->transmitted_list,
1067				      &transport->transmitted);
1068
1069			sctp_transport_reset_t3_rtx(transport);
1070			transport->last_time_sent = jiffies;
1071
1072			/* Only let one DATA chunk get bundled with a
1073			 * COOKIE-ECHO chunk.
1074			 */
1075			if (packet->has_cookie_echo)
1076				goto sctp_flush_out;
1077		}
1078		break;
1079
1080	default:
1081		/* Do nothing.  */
1082		break;
1083	}
1084
1085sctp_flush_out:
1086
1087	/* Before returning, examine all the transports touched in
1088	 * this call.  Right now, we bluntly force clear all the
1089	 * transports.  Things might change after we implement Nagle.
1090	 * But such an examination is still required.
1091	 *
1092	 * --xguo
1093	 */
1094	while ((ltransport = sctp_list_dequeue(&transport_list)) != NULL) {
1095		struct sctp_transport *t = list_entry(ltransport,
1096						      struct sctp_transport,
1097						      send_ready);
1098		packet = &t->packet;
1099		if (!sctp_packet_empty(packet))
1100			error = sctp_packet_transmit(packet, gfp);
1101
1102		/* Clear the burst limited state, if any */
1103		sctp_transport_burst_reset(t);
1104	}
1105
1106	return error;
1107}
1108
1109/* Update unack_data based on the incoming SACK chunk */
1110static void sctp_sack_update_unack_data(struct sctp_association *assoc,
1111					struct sctp_sackhdr *sack)
1112{
1113	sctp_sack_variable_t *frags;
1114	__u16 unack_data;
1115	int i;
1116
1117	unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
1118
1119	frags = sack->variable;
1120	for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
1121		unack_data -= ((ntohs(frags[i].gab.end) -
1122				ntohs(frags[i].gab.start) + 1));
1123	}
1124
1125	assoc->unack_data = unack_data;
1126}
1127
1128/* This is where we REALLY process a SACK.
1129 *
1130 * Process the SACK against the outqueue.  Mostly, this just frees
1131 * things off the transmitted queue.
1132 */
1133int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)
1134{
1135	struct sctp_association *asoc = q->asoc;
1136	struct sctp_sackhdr *sack = chunk->subh.sack_hdr;
1137	struct sctp_transport *transport;
1138	struct sctp_chunk *tchunk = NULL;
1139	struct list_head *lchunk, *transport_list, *temp;
1140	sctp_sack_variable_t *frags = sack->variable;
1141	__u32 sack_ctsn, ctsn, tsn;
1142	__u32 highest_tsn, highest_new_tsn;
1143	__u32 sack_a_rwnd;
1144	unsigned int outstanding;
1145	struct sctp_transport *primary = asoc->peer.primary_path;
1146	int count_of_newacks = 0;
1147	int gap_ack_blocks;
1148	u8 accum_moved = 0;
1149
1150	/* Grab the association's destination address list. */
1151	transport_list = &asoc->peer.transport_addr_list;
1152
1153	sack_ctsn = ntohl(sack->cum_tsn_ack);
1154	gap_ack_blocks = ntohs(sack->num_gap_ack_blocks);
1155	asoc->stats.gapcnt += gap_ack_blocks;
1156	/*
1157	 * SFR-CACC algorithm:
1158	 * On receipt of a SACK the sender SHOULD execute the
1159	 * following statements.
1160	 *
1161	 * 1) If the cumulative ack in the SACK passes next tsn_at_change
1162	 * on the current primary, the CHANGEOVER_ACTIVE flag SHOULD be
1163	 * cleared. The CYCLING_CHANGEOVER flag SHOULD also be cleared for
1164	 * all destinations.
1165	 * 2) If the SACK contains gap acks and the flag CHANGEOVER_ACTIVE
1166	 * is set the receiver of the SACK MUST take the following actions:
1167	 *
1168	 * A) Initialize the cacc_saw_newack to 0 for all destination
1169	 * addresses.
1170	 *
1171	 * Only bother if changeover_active is set. Otherwise, this is
1172	 * totally suboptimal to do on every SACK.
1173	 */
1174	if (primary->cacc.changeover_active) {
1175		u8 clear_cycling = 0;
1176
1177		if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
1178			primary->cacc.changeover_active = 0;
1179			clear_cycling = 1;
1180		}
1181
1182		if (clear_cycling || gap_ack_blocks) {
1183			list_for_each_entry(transport, transport_list,
1184					transports) {
1185				if (clear_cycling)
1186					transport->cacc.cycling_changeover = 0;
1187				if (gap_ack_blocks)
1188					transport->cacc.cacc_saw_newack = 0;
1189			}
1190		}
1191	}
1192
1193	/* Get the highest TSN in the sack. */
1194	highest_tsn = sack_ctsn;
1195	if (gap_ack_blocks)
1196		highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
1197
1198	if (TSN_lt(asoc->highest_sacked, highest_tsn))
1199		asoc->highest_sacked = highest_tsn;
1200
1201	highest_new_tsn = sack_ctsn;
1202
1203	/* Run through the retransmit queue.  Credit bytes received
1204	 * and free those chunks that we can.
1205	 */
1206	sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn);
1207
1208	/* Run through the transmitted queue.
1209	 * Credit bytes received and free those chunks which we can.
1210	 *
1211	 * This is a MASSIVE candidate for optimization.
1212	 */
1213	list_for_each_entry(transport, transport_list, transports) {
1214		sctp_check_transmitted(q, &transport->transmitted,
1215				       transport, &chunk->source, sack,
1216				       &highest_new_tsn);
1217		/*
1218		 * SFR-CACC algorithm:
1219		 * C) Let count_of_newacks be the number of
1220		 * destinations for which cacc_saw_newack is set.
1221		 */
1222		if (transport->cacc.cacc_saw_newack)
1223			count_of_newacks++;
1224	}
1225
1226	/* Move the Cumulative TSN Ack Point if appropriate.  */
1227	if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
1228		asoc->ctsn_ack_point = sack_ctsn;
1229		accum_moved = 1;
1230	}
1231
1232	if (gap_ack_blocks) {
1233
1234		if (asoc->fast_recovery && accum_moved)
1235			highest_new_tsn = highest_tsn;
1236
1237		list_for_each_entry(transport, transport_list, transports)
1238			sctp_mark_missing(q, &transport->transmitted, transport,
1239					  highest_new_tsn, count_of_newacks);
1240	}
1241
1242	/* Update unack_data field in the assoc. */
1243	sctp_sack_update_unack_data(asoc, sack);
1244
1245	ctsn = asoc->ctsn_ack_point;
1246
1247	/* Throw away stuff rotting on the sack queue.  */
1248	list_for_each_safe(lchunk, temp, &q->sacked) {
1249		tchunk = list_entry(lchunk, struct sctp_chunk,
1250				    transmitted_list);
1251		tsn = ntohl(tchunk->subh.data_hdr->tsn);
1252		if (TSN_lte(tsn, ctsn)) {
1253			list_del_init(&tchunk->transmitted_list);
1254			sctp_chunk_free(tchunk);
1255		}
1256	}
1257
1258	/* ii) Set rwnd equal to the newly received a_rwnd minus the
1259	 *     number of bytes still outstanding after processing the
1260	 *     Cumulative TSN Ack and the Gap Ack Blocks.
1261	 */
1262
1263	sack_a_rwnd = ntohl(sack->a_rwnd);
1264	asoc->peer.zero_window_announced = !sack_a_rwnd;
1265	outstanding = q->outstanding_bytes;
1266
1267	if (outstanding < sack_a_rwnd)
1268		sack_a_rwnd -= outstanding;
1269	else
1270		sack_a_rwnd = 0;
1271
1272	asoc->peer.rwnd = sack_a_rwnd;
1273
1274	sctp_generate_fwdtsn(q, sack_ctsn);
1275
1276	pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn);
1277	pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, "
1278		 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn,
1279		 asoc->adv_peer_ack_point);
1280
1281	return sctp_outq_is_empty(q);
1282}
1283
1284/* Is the outqueue empty?
1285 * The queue is empty when we have not pending data, no in-flight data
1286 * and nothing pending retransmissions.
1287 */
1288int sctp_outq_is_empty(const struct sctp_outq *q)
1289{
1290	return q->out_qlen == 0 && q->outstanding_bytes == 0 &&
1291	       list_empty(&q->retransmit);
1292}
1293
1294/********************************************************************
1295 * 2nd Level Abstractions
1296 ********************************************************************/
1297
1298/* Go through a transport's transmitted list or the association's retransmit
1299 * list and move chunks that are acked by the Cumulative TSN Ack to q->sacked.
1300 * The retransmit list will not have an associated transport.
1301 *
1302 * I added coherent debug information output.	--xguo
1303 *
1304 * Instead of printing 'sacked' or 'kept' for each TSN on the
1305 * transmitted_queue, we print a range: SACKED: TSN1-TSN2, TSN3, TSN4-TSN5.
1306 * KEPT TSN6-TSN7, etc.
1307 */
1308static void sctp_check_transmitted(struct sctp_outq *q,
1309				   struct list_head *transmitted_queue,
1310				   struct sctp_transport *transport,
1311				   union sctp_addr *saddr,
1312				   struct sctp_sackhdr *sack,
1313				   __u32 *highest_new_tsn_in_sack)
1314{
1315	struct list_head *lchunk;
1316	struct sctp_chunk *tchunk;
1317	struct list_head tlist;
1318	__u32 tsn;
1319	__u32 sack_ctsn;
1320	__u32 rtt;
1321	__u8 restart_timer = 0;
1322	int bytes_acked = 0;
1323	int migrate_bytes = 0;
1324	bool forward_progress = false;
1325
1326	sack_ctsn = ntohl(sack->cum_tsn_ack);
1327
1328	INIT_LIST_HEAD(&tlist);
1329
1330	/* The while loop will skip empty transmitted queues. */
1331	while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
1332		tchunk = list_entry(lchunk, struct sctp_chunk,
1333				    transmitted_list);
1334
1335		if (sctp_chunk_abandoned(tchunk)) {
1336			/* Move the chunk to abandoned list. */
1337			sctp_insert_list(&q->abandoned, lchunk);
1338
1339			/* If this chunk has not been acked, stop
1340			 * considering it as 'outstanding'.
1341			 */
1342			if (!tchunk->tsn_gap_acked) {
1343				if (tchunk->transport)
1344					tchunk->transport->flight_size -=
1345							sctp_data_size(tchunk);
1346				q->outstanding_bytes -= sctp_data_size(tchunk);
1347			}
1348			continue;
1349		}
1350
1351		tsn = ntohl(tchunk->subh.data_hdr->tsn);
1352		if (sctp_acked(sack, tsn)) {
1353			/* If this queue is the retransmit queue, the
1354			 * retransmit timer has already reclaimed
1355			 * the outstanding bytes for this chunk, so only
1356			 * count bytes associated with a transport.
1357			 */
1358			if (transport) {
1359				/* If this chunk is being used for RTT
1360				 * measurement, calculate the RTT and update
1361				 * the RTO using this value.
1362				 *
1363				 * 6.3.1 C5) Karn's algorithm: RTT measurements
1364				 * MUST NOT be made using packets that were
1365				 * retransmitted (and thus for which it is
1366				 * ambiguous whether the reply was for the
1367				 * first instance of the packet or a later
1368				 * instance).
1369				 */
1370				if (!tchunk->tsn_gap_acked &&
1371				    !tchunk->resent &&
1372				    tchunk->rtt_in_progress) {
1373					tchunk->rtt_in_progress = 0;
1374					rtt = jiffies - tchunk->sent_at;
1375					sctp_transport_update_rto(transport,
1376								  rtt);
1377				}
1378			}
1379
1380			/* If the chunk hasn't been marked as ACKED,
1381			 * mark it and account bytes_acked if the
1382			 * chunk had a valid transport (it will not
1383			 * have a transport if ASCONF had deleted it
1384			 * while DATA was outstanding).
1385			 */
1386			if (!tchunk->tsn_gap_acked) {
1387				tchunk->tsn_gap_acked = 1;
1388				if (TSN_lt(*highest_new_tsn_in_sack, tsn))
1389					*highest_new_tsn_in_sack = tsn;
1390				bytes_acked += sctp_data_size(tchunk);
1391				if (!tchunk->transport)
1392					migrate_bytes += sctp_data_size(tchunk);
1393				forward_progress = true;
1394			}
1395
1396			if (TSN_lte(tsn, sack_ctsn)) {
1397				/* RFC 2960  6.3.2 Retransmission Timer Rules
1398				 *
1399				 * R3) Whenever a SACK is received
1400				 * that acknowledges the DATA chunk
1401				 * with the earliest outstanding TSN
1402				 * for that address, restart T3-rtx
1403				 * timer for that address with its
1404				 * current RTO.
1405				 */
1406				restart_timer = 1;
1407				forward_progress = true;
1408
1409				if (!tchunk->tsn_gap_acked) {
1410					/*
1411					 * SFR-CACC algorithm:
1412					 * 2) If the SACK contains gap acks
1413					 * and the flag CHANGEOVER_ACTIVE is
1414					 * set the receiver of the SACK MUST
1415					 * take the following action:
1416					 *
1417					 * B) For each TSN t being acked that
1418					 * has not been acked in any SACK so
1419					 * far, set cacc_saw_newack to 1 for
1420					 * the destination that the TSN was
1421					 * sent to.
1422					 */
1423					if (transport &&
1424					    sack->num_gap_ack_blocks &&
1425					    q->asoc->peer.primary_path->cacc.
1426					    changeover_active)
1427						transport->cacc.cacc_saw_newack
1428							= 1;
1429				}
1430
1431				list_add_tail(&tchunk->transmitted_list,
1432					      &q->sacked);
1433			} else {
1434				/* RFC2960 7.2.4, sctpimpguide-05 2.8.2
1435				 * M2) Each time a SACK arrives reporting
1436				 * 'Stray DATA chunk(s)' record the highest TSN
1437				 * reported as newly acknowledged, call this
1438				 * value 'HighestTSNinSack'. A newly
1439				 * acknowledged DATA chunk is one not
1440				 * previously acknowledged in a SACK.
1441				 *
1442				 * When the SCTP sender of data receives a SACK
1443				 * chunk that acknowledges, for the first time,
1444				 * the receipt of a DATA chunk, all the still
1445				 * unacknowledged DATA chunks whose TSN is
1446				 * older than that newly acknowledged DATA
1447				 * chunk, are qualified as 'Stray DATA chunks'.
1448				 */
1449				list_add_tail(lchunk, &tlist);
1450			}
1451		} else {
1452			if (tchunk->tsn_gap_acked) {
1453				pr_debug("%s: receiver reneged on data TSN:0x%x\n",
1454					 __func__, tsn);
1455
1456				tchunk->tsn_gap_acked = 0;
1457
1458				if (tchunk->transport)
1459					bytes_acked -= sctp_data_size(tchunk);
1460
1461				/* RFC 2960 6.3.2 Retransmission Timer Rules
1462				 *
1463				 * R4) Whenever a SACK is received missing a
1464				 * TSN that was previously acknowledged via a
1465				 * Gap Ack Block, start T3-rtx for the
1466				 * destination address to which the DATA
1467				 * chunk was originally
1468				 * transmitted if it is not already running.
1469				 */
1470				restart_timer = 1;
1471			}
1472
1473			list_add_tail(lchunk, &tlist);
1474		}
1475	}
1476
1477	if (transport) {
1478		if (bytes_acked) {
1479			struct sctp_association *asoc = transport->asoc;
1480
1481			/* We may have counted DATA that was migrated
1482			 * to this transport due to DEL-IP operation.
1483			 * Subtract those bytes, since the were never
1484			 * send on this transport and shouldn't be
1485			 * credited to this transport.
1486			 */
1487			bytes_acked -= migrate_bytes;
1488
1489			/* 8.2. When an outstanding TSN is acknowledged,
1490			 * the endpoint shall clear the error counter of
1491			 * the destination transport address to which the
1492			 * DATA chunk was last sent.
1493			 * The association's overall error counter is
1494			 * also cleared.
1495			 */
1496			transport->error_count = 0;
1497			transport->asoc->overall_error_count = 0;
1498			forward_progress = true;
1499
1500			/*
1501			 * While in SHUTDOWN PENDING, we may have started
1502			 * the T5 shutdown guard timer after reaching the
1503			 * retransmission limit. Stop that timer as soon
1504			 * as the receiver acknowledged any data.
1505			 */
1506			if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&
1507			    del_timer(&asoc->timers
1508				[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]))
1509					sctp_association_put(asoc);
1510
1511			/* Mark the destination transport address as
1512			 * active if it is not so marked.
1513			 */
1514			if ((transport->state == SCTP_INACTIVE ||
1515			     transport->state == SCTP_UNCONFIRMED) &&
1516			    sctp_cmp_addr_exact(&transport->ipaddr, saddr)) {
1517				sctp_assoc_control_transport(
1518					transport->asoc,
1519					transport,
1520					SCTP_TRANSPORT_UP,
1521					SCTP_RECEIVED_SACK);
1522			}
1523
1524			sctp_transport_raise_cwnd(transport, sack_ctsn,
1525						  bytes_acked);
1526
1527			transport->flight_size -= bytes_acked;
1528			if (transport->flight_size == 0)
1529				transport->partial_bytes_acked = 0;
1530			q->outstanding_bytes -= bytes_acked + migrate_bytes;
1531		} else {
1532			/* RFC 2960 6.1, sctpimpguide-06 2.15.2
1533			 * When a sender is doing zero window probing, it
1534			 * should not timeout the association if it continues
1535			 * to receive new packets from the receiver. The
1536			 * reason is that the receiver MAY keep its window
1537			 * closed for an indefinite time.
1538			 * A sender is doing zero window probing when the
1539			 * receiver's advertised window is zero, and there is
1540			 * only one data chunk in flight to the receiver.
1541			 *
1542			 * Allow the association to timeout while in SHUTDOWN
1543			 * PENDING or SHUTDOWN RECEIVED in case the receiver
1544			 * stays in zero window mode forever.
1545			 */
1546			if (!q->asoc->peer.rwnd &&
1547			    !list_empty(&tlist) &&
1548			    (sack_ctsn+2 == q->asoc->next_tsn) &&
1549			    q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) {
1550				pr_debug("%s: sack received for zero window "
1551					 "probe:%u\n", __func__, sack_ctsn);
1552
1553				q->asoc->overall_error_count = 0;
1554				transport->error_count = 0;
1555			}
1556		}
1557
1558		/* RFC 2960 6.3.2 Retransmission Timer Rules
1559		 *
1560		 * R2) Whenever all outstanding data sent to an address have
1561		 * been acknowledged, turn off the T3-rtx timer of that
1562		 * address.
1563		 */
1564		if (!transport->flight_size) {
1565			if (del_timer(&transport->T3_rtx_timer))
1566				sctp_transport_put(transport);
1567		} else if (restart_timer) {
1568			if (!mod_timer(&transport->T3_rtx_timer,
1569				       jiffies + transport->rto))
1570				sctp_transport_hold(transport);
1571		}
1572
1573		if (forward_progress) {
1574			if (transport->dst)
1575				dst_confirm(transport->dst);
1576		}
1577	}
1578
1579	list_splice(&tlist, transmitted_queue);
1580}
1581
1582/* Mark chunks as missing and consequently may get retransmitted. */
1583static void sctp_mark_missing(struct sctp_outq *q,
1584			      struct list_head *transmitted_queue,
1585			      struct sctp_transport *transport,
1586			      __u32 highest_new_tsn_in_sack,
1587			      int count_of_newacks)
1588{
1589	struct sctp_chunk *chunk;
1590	__u32 tsn;
1591	char do_fast_retransmit = 0;
1592	struct sctp_association *asoc = q->asoc;
1593	struct sctp_transport *primary = asoc->peer.primary_path;
1594
1595	list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
1596
1597		tsn = ntohl(chunk->subh.data_hdr->tsn);
1598
1599		/* RFC 2960 7.2.4, sctpimpguide-05 2.8.2 M3) Examine all
1600		 * 'Unacknowledged TSN's', if the TSN number of an
1601		 * 'Unacknowledged TSN' is smaller than the 'HighestTSNinSack'
1602		 * value, increment the 'TSN.Missing.Report' count on that
1603		 * chunk if it has NOT been fast retransmitted or marked for
1604		 * fast retransmit already.
1605		 */
1606		if (chunk->fast_retransmit == SCTP_CAN_FRTX &&
1607		    !chunk->tsn_gap_acked &&
1608		    TSN_lt(tsn, highest_new_tsn_in_sack)) {
1609
1610			/* SFR-CACC may require us to skip marking
1611			 * this chunk as missing.
1612			 */
1613			if (!transport || !sctp_cacc_skip(primary,
1614						chunk->transport,
1615						count_of_newacks, tsn)) {
1616				chunk->tsn_missing_report++;
1617
1618				pr_debug("%s: tsn:0x%x missing counter:%d\n",
1619					 __func__, tsn, chunk->tsn_missing_report);
1620			}
1621		}
1622		/*
1623		 * M4) If any DATA chunk is found to have a
1624		 * 'TSN.Missing.Report'
1625		 * value larger than or equal to 3, mark that chunk for
1626		 * retransmission and start the fast retransmit procedure.
1627		 */
1628
1629		if (chunk->tsn_missing_report >= 3) {
1630			chunk->fast_retransmit = SCTP_NEED_FRTX;
1631			do_fast_retransmit = 1;
1632		}
1633	}
1634
1635	if (transport) {
1636		if (do_fast_retransmit)
1637			sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
1638
1639		pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, "
1640			 "flight_size:%d, pba:%d\n",  __func__, transport,
1641			 transport->cwnd, transport->ssthresh,
1642			 transport->flight_size, transport->partial_bytes_acked);
1643	}
1644}
1645
1646/* Is the given TSN acked by this packet?  */
1647static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
1648{
1649	int i;
1650	sctp_sack_variable_t *frags;
1651	__u16 gap;
1652	__u32 ctsn = ntohl(sack->cum_tsn_ack);
1653
1654	if (TSN_lte(tsn, ctsn))
1655		goto pass;
1656
1657	/* 3.3.4 Selective Acknowledgement (SACK) (3):
1658	 *
1659	 * Gap Ack Blocks:
1660	 *  These fields contain the Gap Ack Blocks. They are repeated
1661	 *  for each Gap Ack Block up to the number of Gap Ack Blocks
1662	 *  defined in the Number of Gap Ack Blocks field. All DATA
1663	 *  chunks with TSNs greater than or equal to (Cumulative TSN
1664	 *  Ack + Gap Ack Block Start) and less than or equal to
1665	 *  (Cumulative TSN Ack + Gap Ack Block End) of each Gap Ack
1666	 *  Block are assumed to have been received correctly.
1667	 */
1668
1669	frags = sack->variable;
1670	gap = tsn - ctsn;
1671	for (i = 0; i < ntohs(sack->num_gap_ack_blocks); ++i) {
1672		if (TSN_lte(ntohs(frags[i].gab.start), gap) &&
1673		    TSN_lte(gap, ntohs(frags[i].gab.end)))
1674			goto pass;
1675	}
1676
1677	return 0;
1678pass:
1679	return 1;
1680}
1681
1682static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
1683				    int nskips, __be16 stream)
1684{
1685	int i;
1686
1687	for (i = 0; i < nskips; i++) {
1688		if (skiplist[i].stream == stream)
1689			return i;
1690	}
1691	return i;
1692}
1693
1694/* Create and add a fwdtsn chunk to the outq's control queue if needed. */
1695static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
1696{
1697	struct sctp_association *asoc = q->asoc;
1698	struct sctp_chunk *ftsn_chunk = NULL;
1699	struct sctp_fwdtsn_skip ftsn_skip_arr[10];
1700	int nskips = 0;
1701	int skip_pos = 0;
1702	__u32 tsn;
1703	struct sctp_chunk *chunk;
1704	struct list_head *lchunk, *temp;
1705
1706	if (!asoc->peer.prsctp_capable)
1707		return;
1708
1709	/* PR-SCTP C1) Let SackCumAck be the Cumulative TSN ACK carried in the
1710	 * received SACK.
1711	 *
1712	 * If (Advanced.Peer.Ack.Point < SackCumAck), then update
1713	 * Advanced.Peer.Ack.Point to be equal to SackCumAck.
1714	 */
1715	if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1716		asoc->adv_peer_ack_point = ctsn;
1717
1718	/* PR-SCTP C2) Try to further advance the "Advanced.Peer.Ack.Point"
1719	 * locally, that is, to move "Advanced.Peer.Ack.Point" up as long as
1720	 * the chunk next in the out-queue space is marked as "abandoned" as
1721	 * shown in the following example:
1722	 *
1723	 * Assuming that a SACK arrived with the Cumulative TSN ACK 102
1724	 * and the Advanced.Peer.Ack.Point is updated to this value:
1725	 *
1726	 *   out-queue at the end of  ==>   out-queue after Adv.Ack.Point
1727	 *   normal SACK processing           local advancement
1728	 *                ...                           ...
1729	 *   Adv.Ack.Pt-> 102 acked                     102 acked
1730	 *                103 abandoned                 103 abandoned
1731	 *                104 abandoned     Adv.Ack.P-> 104 abandoned
1732	 *                105                           105
1733	 *                106 acked                     106 acked
1734	 *                ...                           ...
1735	 *
1736	 * In this example, the data sender successfully advanced the
1737	 * "Advanced.Peer.Ack.Point" from 102 to 104 locally.
1738	 */
1739	list_for_each_safe(lchunk, temp, &q->abandoned) {
1740		chunk = list_entry(lchunk, struct sctp_chunk,
1741					transmitted_list);
1742		tsn = ntohl(chunk->subh.data_hdr->tsn);
1743
1744		/* Remove any chunks in the abandoned queue that are acked by
1745		 * the ctsn.
1746		 */
1747		if (TSN_lte(tsn, ctsn)) {
1748			list_del_init(lchunk);
1749			sctp_chunk_free(chunk);
1750		} else {
1751			if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
1752				asoc->adv_peer_ack_point = tsn;
1753				if (chunk->chunk_hdr->flags &
1754					 SCTP_DATA_UNORDERED)
1755					continue;
1756				skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
1757						nskips,
1758						chunk->subh.data_hdr->stream);
1759				ftsn_skip_arr[skip_pos].stream =
1760					chunk->subh.data_hdr->stream;
1761				ftsn_skip_arr[skip_pos].ssn =
1762					 chunk->subh.data_hdr->ssn;
1763				if (skip_pos == nskips)
1764					nskips++;
1765				if (nskips == 10)
1766					break;
1767			} else
1768				break;
1769		}
1770	}
1771
1772	/* PR-SCTP C3) If, after step C1 and C2, the "Advanced.Peer.Ack.Point"
1773	 * is greater than the Cumulative TSN ACK carried in the received
1774	 * SACK, the data sender MUST send the data receiver a FORWARD TSN
1775	 * chunk containing the latest value of the
1776	 * "Advanced.Peer.Ack.Point".
1777	 *
1778	 * C4) For each "abandoned" TSN the sender of the FORWARD TSN SHOULD
1779	 * list each stream and sequence number in the forwarded TSN. This
1780	 * information will enable the receiver to easily find any
1781	 * stranded TSN's waiting on stream reorder queues. Each stream
1782	 * SHOULD only be reported once; this means that if multiple
1783	 * abandoned messages occur in the same stream then only the
1784	 * highest abandoned stream sequence number is reported. If the
1785	 * total size of the FORWARD TSN does NOT fit in a single MTU then
1786	 * the sender of the FORWARD TSN SHOULD lower the
1787	 * Advanced.Peer.Ack.Point to the last TSN that will fit in a
1788	 * single MTU.
1789	 */
1790	if (asoc->adv_peer_ack_point > ctsn)
1791		ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
1792					      nskips, &ftsn_skip_arr[0]);
1793
1794	if (ftsn_chunk) {
1795		list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
1796		SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS);
1797	}
1798}