output.c 26.3 KB
Newer Older
1
/* SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
2
3
4
5
 * (C) Copyright IBM Corp. 2001, 2004
 * Copyright (c) 1999-2000 Cisco, Inc.
 * Copyright (c) 1999-2001 Motorola, Inc.
 *
6
 * This file is part of the SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
7
8
9
 *
 * These functions handle output processing.
 *
10
 * This SCTP implementation is free software;
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
15
 * you can redistribute it and/or modify it under the terms of
 * the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
16
 * This SCTP implementation is distributed in the hope that it
Linus Torvalds's avatar
Linus Torvalds committed
17
18
19
20
21
22
 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
 *                 ************************
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
23
24
 * along with GNU CC; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>.
Linus Torvalds's avatar
Linus Torvalds committed
25
26
27
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
28
 *    lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds's avatar
Linus Torvalds committed
29
30
31
32
33
34
35
36
 *
 * Written or modified by:
 *    La Monte H.P. Yarroll <piggy@acm.org>
 *    Karl Knutson          <karl@athena.chicago.il.us>
 *    Jon Grimm             <jgrimm@austin.ibm.com>
 *    Sridhar Samudrala     <sri@us.ibm.com>
 */

37
38
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
39
40
41
42
43
44
45
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/wait.h>
#include <linux/time.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/init.h>
46
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
47
#include <net/inet_ecn.h>
48
#include <net/ip.h>
Linus Torvalds's avatar
Linus Torvalds committed
49
#include <net/icmp.h>
50
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
51
52
53
54
55
56

#include <linux/socket.h> /* for sa_family_t */
#include <net/sock.h>

#include <net/sctp/sctp.h>
#include <net/sctp/sm.h>
57
#include <net/sctp/checksum.h>
Linus Torvalds's avatar
Linus Torvalds committed
58
59

/* Forward declarations for private helpers. */
60
61
static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
					      struct sctp_chunk *chunk);
62
static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
Linus Torvalds's avatar
Linus Torvalds committed
63
					   struct sctp_chunk *chunk);
64
65
66
67
68
static void sctp_packet_append_data(struct sctp_packet *packet,
					   struct sctp_chunk *chunk);
static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
					struct sctp_chunk *chunk,
					u16 chunk_len);
Linus Torvalds's avatar
Linus Torvalds committed
69

70
71
72
73
74
75
76
77
78
79
80
static void sctp_packet_reset(struct sctp_packet *packet)
{
	packet->size = packet->overhead;
	packet->has_cookie_echo = 0;
	packet->has_sack = 0;
	packet->has_data = 0;
	packet->has_auth = 0;
	packet->ipfragok = 0;
	packet->auth = NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
81
82
83
84
85
86
/* Config a packet.
 * This appears to be a followup set of initializations.
 */
struct sctp_packet *sctp_packet_config(struct sctp_packet *packet,
				       __u32 vtag, int ecn_capable)
{
87
88
	struct sctp_transport *tp = packet->transport;
	struct sctp_association *asoc = tp->asoc;
Linus Torvalds's avatar
Linus Torvalds committed
89

90
	pr_debug("%s: packet:%p vtag:0x%x\n", __func__, packet, vtag);
Linus Torvalds's avatar
Linus Torvalds committed
91
92
93

	packet->vtag = vtag;

94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
	if (asoc && tp->dst) {
		struct sock *sk = asoc->base.sk;

		rcu_read_lock();
		if (__sk_dst_get(sk) != tp->dst) {
			dst_hold(tp->dst);
			sk_setup_caps(sk, tp->dst);
		}

		if (sk_can_gso(sk)) {
			struct net_device *dev = tp->dst->dev;

			packet->max_size = dev->gso_max_size;
		} else {
			packet->max_size = asoc->pathmtu;
		}
		rcu_read_unlock();

	} else {
		packet->max_size = tp->pathmtu;
	}

Linus Torvalds's avatar
Linus Torvalds committed
116
	if (ecn_capable && sctp_packet_empty(packet)) {
117
		struct sctp_chunk *chunk;
Linus Torvalds's avatar
Linus Torvalds committed
118
119

		/* If there a is a prepend chunk stick it on the list before
120
121
		 * any other chunks get appended.
		 */
122
		chunk = sctp_get_ecne_prepend(asoc);
Linus Torvalds's avatar
Linus Torvalds committed
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
		if (chunk)
			sctp_packet_append_chunk(packet, chunk);
	}

	return packet;
}

/* Initialize the packet structure. */
struct sctp_packet *sctp_packet_init(struct sctp_packet *packet,
				     struct sctp_transport *transport,
				     __u16 sport, __u16 dport)
{
	struct sctp_association *asoc = transport->asoc;
	size_t overhead;

138
	pr_debug("%s: packet:%p transport:%p\n", __func__, packet, transport);
Linus Torvalds's avatar
Linus Torvalds committed
139
140
141
142

	packet->transport = transport;
	packet->source_port = sport;
	packet->destination_port = dport;
143
	INIT_LIST_HEAD(&packet->chunk_list);
Linus Torvalds's avatar
Linus Torvalds committed
144
	if (asoc) {
145
146
		struct sctp_sock *sp = sctp_sk(asoc->base.sk);
		overhead = sp->pf->af->net_header_len;
Linus Torvalds's avatar
Linus Torvalds committed
147
148
149
150
151
	} else {
		overhead = sizeof(struct ipv6hdr);
	}
	overhead += sizeof(struct sctphdr);
	packet->overhead = overhead;
152
	sctp_packet_reset(packet);
Linus Torvalds's avatar
Linus Torvalds committed
153
	packet->vtag = 0;
154

Linus Torvalds's avatar
Linus Torvalds committed
155
156
157
158
159
160
	return packet;
}

/* Free a packet.  */
void sctp_packet_free(struct sctp_packet *packet)
{
161
	struct sctp_chunk *chunk, *tmp;
Linus Torvalds's avatar
Linus Torvalds committed
162

163
	pr_debug("%s: packet:%p\n", __func__, packet);
Linus Torvalds's avatar
Linus Torvalds committed
164

165
166
	list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
		list_del_init(&chunk->list);
Linus Torvalds's avatar
Linus Torvalds committed
167
		sctp_chunk_free(chunk);
168
	}
Linus Torvalds's avatar
Linus Torvalds committed
169
170
171
172
173
174
175
176
177
178
}

/* This routine tries to append the chunk to the offered packet. If adding
 * the chunk causes the packet to exceed the path MTU and COOKIE_ECHO chunk
 * is not present in the packet, it transmits the input packet.
 * Data can be bundled with a packet containing a COOKIE_ECHO chunk as long
 * as it can fit in the packet, but any more data that does not fit in this
 * packet can be sent only after receiving the COOKIE_ACK.
 */
sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *packet,
179
				       struct sctp_chunk *chunk,
180
				       int one_packet, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
181
182
183
184
{
	sctp_xmit_t retval;
	int error = 0;

185
	pr_debug("%s: packet:%p size:%Zu chunk:%p size:%d\n", __func__,
186
		 packet, packet->size, chunk, chunk->skb ? chunk->skb->len : -1);
Linus Torvalds's avatar
Linus Torvalds committed
187
188
189
190

	switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
	case SCTP_XMIT_PMTU_FULL:
		if (!packet->has_cookie_echo) {
191
			error = sctp_packet_transmit(packet, gfp);
Linus Torvalds's avatar
Linus Torvalds committed
192
193
194
195
196
197
			if (error < 0)
				chunk->skb->sk->sk_err = -error;

			/* If we have an empty packet, then we can NOT ever
			 * return PMTU_FULL.
			 */
198
199
200
			if (!one_packet)
				retval = sctp_packet_append_chunk(packet,
								  chunk);
Linus Torvalds's avatar
Linus Torvalds committed
201
202
203
204
205
		}
		break;

	case SCTP_XMIT_RWND_FULL:
	case SCTP_XMIT_OK:
206
	case SCTP_XMIT_DELAY:
Linus Torvalds's avatar
Linus Torvalds committed
207
		break;
208
	}
Linus Torvalds's avatar
Linus Torvalds committed
209
210
211
212

	return retval;
}

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
/* Try to bundle an auth chunk into the packet. */
static sctp_xmit_t sctp_packet_bundle_auth(struct sctp_packet *pkt,
					   struct sctp_chunk *chunk)
{
	struct sctp_association *asoc = pkt->transport->asoc;
	struct sctp_chunk *auth;
	sctp_xmit_t retval = SCTP_XMIT_OK;

	/* if we don't have an association, we can't do authentication */
	if (!asoc)
		return retval;

	/* See if this is an auth chunk we are bundling or if
	 * auth is already bundled.
	 */
228
	if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth)
229
230
231
232
233
234
235
236
237
238
239
240
		return retval;

	/* if the peer did not request this chunk to be authenticated,
	 * don't do it
	 */
	if (!chunk->auth)
		return retval;

	auth = sctp_make_auth(asoc);
	if (!auth)
		return retval;

241
242
243
244
	retval = __sctp_packet_append_chunk(pkt, auth);

	if (retval != SCTP_XMIT_OK)
		sctp_chunk_free(auth);
245
246
247
248

	return retval;
}

Linus Torvalds's avatar
Linus Torvalds committed
249
250
251
252
253
254
255
256
257
258
259
260
/* Try to bundle a SACK with the packet. */
static sctp_xmit_t sctp_packet_bundle_sack(struct sctp_packet *pkt,
					   struct sctp_chunk *chunk)
{
	sctp_xmit_t retval = SCTP_XMIT_OK;

	/* If sending DATA and haven't aleady bundled a SACK, try to
	 * bundle one in to the packet.
	 */
	if (sctp_chunk_is_data(chunk) && !pkt->has_sack &&
	    !pkt->has_cookie_echo) {
		struct sctp_association *asoc;
Doug Graham's avatar
Doug Graham committed
261
		struct timer_list *timer;
Linus Torvalds's avatar
Linus Torvalds committed
262
		asoc = pkt->transport->asoc;
Doug Graham's avatar
Doug Graham committed
263
		timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
Linus Torvalds's avatar
Linus Torvalds committed
264

Doug Graham's avatar
Doug Graham committed
265
266
		/* If the SACK timer is running, we have a pending SACK */
		if (timer_pending(timer)) {
Linus Torvalds's avatar
Linus Torvalds committed
267
			struct sctp_chunk *sack;
268
269
270
271
272

			if (pkt->transport->sack_generation !=
			    pkt->transport->asoc->peer.sack_generation)
				return retval;

Linus Torvalds's avatar
Linus Torvalds committed
273
274
275
			asoc->a_rwnd = asoc->rwnd;
			sack = sctp_make_sack(asoc);
			if (sack) {
276
277
278
279
280
				retval = __sctp_packet_append_chunk(pkt, sack);
				if (retval != SCTP_XMIT_OK) {
					sctp_chunk_free(sack);
					goto out;
				}
Linus Torvalds's avatar
Linus Torvalds committed
281
				asoc->peer.sack_needed = 0;
Doug Graham's avatar
Doug Graham committed
282
				if (del_timer(timer))
Linus Torvalds's avatar
Linus Torvalds committed
283
284
285
286
					sctp_association_put(asoc);
			}
		}
	}
287
out:
Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
	return retval;
}

291

Linus Torvalds's avatar
Linus Torvalds committed
292
293
294
/* Append a chunk to the offered packet reporting back any inability to do
 * so.
 */
295
296
static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
					      struct sctp_chunk *chunk)
Linus Torvalds's avatar
Linus Torvalds committed
297
298
299
300
{
	sctp_xmit_t retval = SCTP_XMIT_OK;
	__u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));

301
302
303
304
	/* Check to see if this chunk will fit into the packet */
	retval = sctp_packet_will_fit(packet, chunk, chunk_len);
	if (retval != SCTP_XMIT_OK)
		goto finish;
Linus Torvalds's avatar
Linus Torvalds committed
305

306
	/* We believe that this chunk is OK to add to the packet */
307
	switch (chunk->chunk_hdr->type) {
308
	case SCTP_CID_DATA:
309
310
		/* Account for the data being in the packet */
		sctp_packet_append_data(packet, chunk);
Linus Torvalds's avatar
Linus Torvalds committed
311
312
		/* Disallow SACK bundling after DATA. */
		packet->has_sack = 1;
313
314
315
316
		/* Disallow AUTH bundling after DATA */
		packet->has_auth = 1;
		/* Let it be knows that packet has DATA in it */
		packet->has_data = 1;
317
318
		/* timestamp the chunk for rtx purposes */
		chunk->sent_at = jiffies;
Xin Long's avatar
Xin Long committed
319
320
		/* Mainly used for prsctp RTX policy */
		chunk->sent_count++;
321
		break;
322
	case SCTP_CID_COOKIE_ECHO:
Linus Torvalds's avatar
Linus Torvalds committed
323
		packet->has_cookie_echo = 1;
324
325
		break;

326
	case SCTP_CID_SACK:
Linus Torvalds's avatar
Linus Torvalds committed
327
		packet->has_sack = 1;
328
329
		if (chunk->asoc)
			chunk->asoc->stats.osacks++;
330
331
		break;

332
	case SCTP_CID_AUTH:
333
334
335
336
		packet->has_auth = 1;
		packet->auth = chunk;
		break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
337
338

	/* It is OK to send this chunk.  */
339
	list_add_tail(&chunk->list, &packet->chunk_list);
Linus Torvalds's avatar
Linus Torvalds committed
340
341
342
343
344
345
	packet->size += chunk_len;
	chunk->transport = packet->transport;
finish:
	return retval;
}

346
347
348
349
350
351
352
353
/* Append a chunk to the offered packet reporting back any inability to do
 * so.
 */
sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *packet,
				     struct sctp_chunk *chunk)
{
	sctp_xmit_t retval = SCTP_XMIT_OK;

354
	pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk);
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381

	/* Data chunks are special.  Before seeing what else we can
	 * bundle into this packet, check to see if we are allowed to
	 * send this DATA.
	 */
	if (sctp_chunk_is_data(chunk)) {
		retval = sctp_packet_can_append_data(packet, chunk);
		if (retval != SCTP_XMIT_OK)
			goto finish;
	}

	/* Try to bundle AUTH chunk */
	retval = sctp_packet_bundle_auth(packet, chunk);
	if (retval != SCTP_XMIT_OK)
		goto finish;

	/* Try to bundle SACK chunk */
	retval = sctp_packet_bundle_sack(packet, chunk);
	if (retval != SCTP_XMIT_OK)
		goto finish;

	retval = __sctp_packet_append_chunk(packet, chunk);

finish:
	return retval;
}

382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
static void sctp_packet_release_owner(struct sk_buff *skb)
{
	sk_free(skb->sk);
}

static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk)
{
	skb_orphan(skb);
	skb->sk = sk;
	skb->destructor = sctp_packet_release_owner;

	/*
	 * The data chunks have already been accounted for in sctp_sendmsg(),
	 * therefore only reserve a single byte to keep socket around until
	 * the packet has been transmitted.
	 */
	atomic_inc(&sk->sk_wmem_alloc);
}

Linus Torvalds's avatar
Linus Torvalds committed
401
402
403
404
405
/* All packets are sent to the network through this function from
 * sctp_outq_tail().
 *
 * The return value is a normal kernel error return value.
 */
406
int sctp_packet_transmit(struct sctp_packet *packet, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
407
408
409
410
{
	struct sctp_transport *tp = packet->transport;
	struct sctp_association *asoc = tp->asoc;
	struct sctphdr *sh;
411
	struct sk_buff *nskb = NULL, *head = NULL;
412
	struct sctp_chunk *chunk, *tmp;
Linus Torvalds's avatar
Linus Torvalds committed
413
414
415
	struct sock *sk;
	int err = 0;
	int padding;		/* How much padding do we need?  */
416
	int pkt_size;
Linus Torvalds's avatar
Linus Torvalds committed
417
	__u8 has_data = 0;
418
419
	int gso = 0;
	int pktcount = 0;
420
	struct dst_entry *dst;
421
	unsigned char *auth = NULL;	/* pointer to auth in skb data */
Linus Torvalds's avatar
Linus Torvalds committed
422

423
	pr_debug("%s: packet:%p\n", __func__, packet);
Linus Torvalds's avatar
Linus Torvalds committed
424
425

	/* Do NOT generate a chunkless packet. */
426
	if (list_empty(&packet->chunk_list))
Linus Torvalds's avatar
Linus Torvalds committed
427
428
429
		return err;

	/* Set up convenience variables... */
430
	chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list);
Linus Torvalds's avatar
Linus Torvalds committed
431
432
	sk = chunk->skb->sk;

433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
	/* Allocate the head skb, or main one if not in GSO */
	if (packet->size > tp->pathmtu && !packet->ipfragok) {
		if (sk_can_gso(sk)) {
			gso = 1;
			pkt_size = packet->overhead;
		} else {
			/* If this happens, we trash this packet and try
			 * to build a new one, hopefully correct this
			 * time. Application may notice this error.
			 */
			pr_err_once("Trying to GSO but underlying device doesn't support it.");
			goto nomem;
		}
	} else {
		pkt_size = packet->size;
	}
	head = alloc_skb(pkt_size + MAX_HEADER, gfp);
	if (!head)
Linus Torvalds's avatar
Linus Torvalds committed
451
		goto nomem;
452
453
454
455
	if (gso) {
		NAPI_GRO_CB(head)->last = head;
		skb_shinfo(head)->gso_type = sk->sk_gso_type;
	}
Linus Torvalds's avatar
Linus Torvalds committed
456
457

	/* Make sure the outbound skb has enough header room reserved. */
458
	skb_reserve(head, packet->overhead + MAX_HEADER);
Linus Torvalds's avatar
Linus Torvalds committed
459
460
461
462

	/* Set the owning socket so that we know where to get the
	 * destination IP address.
	 */
463
	sctp_packet_set_owner_w(head, sk);
Linus Torvalds's avatar
Linus Torvalds committed
464

465
	if (!sctp_transport_dst_check(tp)) {
466
467
		sctp_transport_route(tp, NULL, sctp_sk(sk));
		if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) {
468
			sctp_assoc_sync_pmtu(sk, asoc);
469
470
		}
	}
Eric Dumazet's avatar
Eric Dumazet committed
471
	dst = dst_clone(tp->dst);
472
	if (!dst)
473
		goto no_route;
474
	skb_dst_set(head, dst);
475

Linus Torvalds's avatar
Linus Torvalds committed
476
	/* Build the SCTP header.  */
477
478
	sh = (struct sctphdr *)skb_push(head, sizeof(struct sctphdr));
	skb_reset_transport_header(head);
Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
482
483
484
485
486
487
488
489
490
491
492
	sh->source = htons(packet->source_port);
	sh->dest   = htons(packet->destination_port);

	/* From 6.8 Adler-32 Checksum Calculation:
	 * After the packet is constructed (containing the SCTP common
	 * header and one or more control or DATA chunks), the
	 * transmitter shall:
	 *
	 * 1) Fill in the proper Verification Tag in the SCTP common
	 *    header and initialize the checksum field to 0's.
	 */
	sh->vtag     = htonl(packet->vtag);
	sh->checksum = 0;

493
494
	pr_debug("***sctp_transmit_packet***\n");

495
496
497
498
	do {
		/* Set up convenience variables... */
		chunk = list_entry(packet->chunk_list.next, struct sctp_chunk, list);
		pktcount++;
Linus Torvalds's avatar
Linus Torvalds committed
499

500
501
502
503
504
505
506
507
508
509
510
		/* Calculate packet size, so it fits in PMTU. Leave
		 * other chunks for the next packets.
		 */
		if (gso) {
			pkt_size = packet->overhead;
			list_for_each_entry(chunk, &packet->chunk_list, list) {
				int padded = WORD_ROUND(chunk->skb->len);

				if (pkt_size + padded > tp->pathmtu)
					break;
				pkt_size += padded;
511
			}
512

513
514
515
516
			/* Allocate a new skb. */
			nskb = alloc_skb(pkt_size + MAX_HEADER, gfp);
			if (!nskb)
				goto nomem;
Linus Torvalds's avatar
Linus Torvalds committed
517

518
519
520
521
522
523
524
			/* Make sure the outbound skb has enough header
			 * room reserved.
			 */
			skb_reserve(nskb, packet->overhead + MAX_HEADER);
		} else {
			nskb = head;
		}
Linus Torvalds's avatar
Linus Torvalds committed
525

526
527
528
529
530
531
532
533
534
535
536
		/**
		 * 3.2  Chunk Field Descriptions
		 *
		 * The total length of a chunk (including Type, Length and
		 * Value fields) MUST be a multiple of 4 bytes.  If the length
		 * of the chunk is not a multiple of 4 bytes, the sender MUST
		 * pad the chunk with all zero bytes and this padding is not
		 * included in the chunk length field.  The sender should
		 * never pad with more than 3 bytes.
		 *
		 * [This whole comment explains WORD_ROUND() below.]
537
538
		 */

539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
		pkt_size -= packet->overhead;
		list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
			list_del_init(&chunk->list);
			if (sctp_chunk_is_data(chunk)) {
				/* 6.3.1 C4) When data is in flight and when allowed
				 * by rule C5, a new RTT measurement MUST be made each
				 * round trip.  Furthermore, new RTT measurements
				 * SHOULD be made no more than once per round-trip
				 * for a given destination transport address.
				 */

				if (!chunk->resent && !tp->rto_pending) {
					chunk->rtt_in_progress = 1;
					tp->rto_pending = 1;
				}

				has_data = 1;
			}

			padding = WORD_ROUND(chunk->skb->len) - chunk->skb->len;
			if (padding)
				memset(skb_put(chunk->skb, padding), 0, padding);

			/* if this is the auth chunk that we are adding,
			 * store pointer where it will be added and put
			 * the auth into the packet.
			 */
			if (chunk == packet->auth)
				auth = skb_tail_pointer(nskb);

			memcpy(skb_put(nskb, chunk->skb->len),
570
			       chunk->skb->data, chunk->skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
571

572
573
574
575
576
577
578
579
580
581
582
583
584
585
			pr_debug("*** Chunk:%p[%s] %s 0x%x, length:%d, chunk->skb->len:%d, rtt_in_progress:%d\n",
				 chunk,
				 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)),
				 chunk->has_tsn ? "TSN" : "No TSN",
				 chunk->has_tsn ? ntohl(chunk->subh.data_hdr->tsn) : 0,
				 ntohs(chunk->chunk_hdr->length), chunk->skb->len,
				 chunk->rtt_in_progress);

			/* If this is a control chunk, this is our last
			 * reference. Free data chunks after they've been
			 * acknowledged or have failed.
			 * Re-queue auth chunks if needed.
			 */
			pkt_size -= WORD_ROUND(chunk->skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
586

587
			if (!sctp_chunk_is_data(chunk) && chunk != packet->auth)
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
				sctp_chunk_free(chunk);

			if (!pkt_size)
				break;
		}

		/* SCTP-AUTH, Section 6.2
		 *    The sender MUST calculate the MAC as described in RFC2104 [2]
		 *    using the hash function H as described by the MAC Identifier and
		 *    the shared association key K based on the endpoint pair shared key
		 *    described by the shared key identifier.  The 'data' used for the
		 *    computation of the AUTH-chunk is given by the AUTH chunk with its
		 *    HMAC field set to zero (as shown in Figure 6) followed by all
		 *    chunks that are placed after the AUTH chunk in the SCTP packet.
		 */
		if (auth)
			sctp_auth_calculate_hmac(asoc, nskb,
						 (struct sctp_auth_chunk *)auth,
						 gfp);

608
609
610
611
612
613
614
615
616
617
618
619
		if (packet->auth) {
			if (!list_empty(&packet->chunk_list)) {
				/* We will generate more packets, so re-queue
				 * auth chunk.
				 */
				list_add(&chunk->list, &packet->chunk_list);
			} else {
				sctp_chunk_free(packet->auth);
				packet->auth = NULL;
			}
		}

620
621
622
623
624
625
626
627
628
629
		if (!gso)
			break;

		if (skb_gro_receive(&head, nskb))
			goto nomem;
		nskb = NULL;
		if (WARN_ON_ONCE(skb_shinfo(head)->gso_segs >=
				 sk->sk_gso_max_segs))
			goto nomem;
	} while (!list_empty(&packet->chunk_list));
630
631
632
633
634
635
636

	/* 2) Calculate the Adler-32 checksum of the whole packet,
	 *    including the SCTP common header and all the
	 *    chunks.
	 *
	 * Note: Adler-32 is no longer applicable, as has been replaced
	 * by CRC32-C as described in <draft-ietf-tsvwg-sctpcsum-02.txt>.
637
638
	 *
	 * If it's a GSO packet, it's postponed to sctp_skb_segment.
639
	 */
640
641
642
643
	if (!sctp_checksum_disable || gso) {
		if (!gso && (!(dst->dev->features & NETIF_F_SCTP_CRC) ||
			     dst_xfrm(dst) || packet->ipfragok)) {
			sh->checksum = sctp_compute_cksum(head, 0);
644
		} else {
Lucas De Marchi's avatar
Lucas De Marchi committed
645
			/* no need to seed pseudo checksum for SCTP */
646
647
648
			head->ip_summed = CHECKSUM_PARTIAL;
			head->csum_start = skb_transport_header(head) - head->head;
			head->csum_offset = offsetof(struct sctphdr, checksum);
649
650
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
651
652
653
654
655
656
657
658
659
660
661
662
663

	/* IP layer ECN support
	 * From RFC 2481
	 *  "The ECN-Capable Transport (ECT) bit would be set by the
	 *   data sender to indicate that the end-points of the
	 *   transport protocol are ECN-capable."
	 *
	 * Now setting the ECT bit all the time, as it should not cause
	 * any problems protocol-wise even if our peer ignores it.
	 *
	 * Note: The works for IPv6 layer checks this bit too later
	 * in transmission.  See IP6_ECN_flow_xmit().
	 */
664
	tp->af_specific->ecn_capable(sk);
Linus Torvalds's avatar
Linus Torvalds committed
665
666
667
668
669
670
671

	/* Set up the IP options.  */
	/* BUG: not implemented
	 * For v4 this all lives somewhere in sk->sk_opt...
	 */

	/* Dump that on IP!  */
672
	if (asoc) {
673
		asoc->stats.opackets += pktcount;
674
675
676
677
678
		if (asoc->peer.last_sent_to != tp)
			/* Considering the multiple CPU scenario, this is a
			 * "correcter" place for last_sent_to.  --xguo
			 */
			asoc->peer.last_sent_to = tp;
Linus Torvalds's avatar
Linus Torvalds committed
679
680
681
682
683
684
685
	}

	if (has_data) {
		struct timer_list *timer;
		unsigned long timeout;

		/* Restart the AUTOCLOSE timer when sending data. */
686
687
		if (sctp_state(asoc, ESTABLISHED) &&
		    asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE]) {
Linus Torvalds's avatar
Linus Torvalds committed
688
689
690
691
692
693
694
695
			timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
			timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE];

			if (!mod_timer(timer, jiffies + timeout))
				sctp_association_hold(asoc);
		}
	}

696
697
698
699
700
701
	pr_debug("***sctp_transmit_packet*** skb->len:%d\n", head->len);

	if (gso) {
		/* Cleanup our debris for IP stacks */
		memset(head->cb, 0, max(sizeof(struct inet_skb_parm),
					sizeof(struct inet6_skb_parm)));
Linus Torvalds's avatar
Linus Torvalds committed
702

703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
		skb_shinfo(head)->gso_segs = pktcount;
		skb_shinfo(head)->gso_size = GSO_BY_FRAGS;

		/* We have to refresh this in case we are xmiting to
		 * more than one transport at a time
		 */
		rcu_read_lock();
		if (__sk_dst_get(sk) != tp->dst) {
			dst_hold(tp->dst);
			sk_setup_caps(sk, tp->dst);
		}
		rcu_read_unlock();
	}
	head->ignore_df = packet->ipfragok;
	tp->af_specific->sctp_xmit(head, tp);
Linus Torvalds's avatar
Linus Torvalds committed
718
719

out:
720
	sctp_packet_reset(packet);
Linus Torvalds's avatar
Linus Torvalds committed
721
722
	return err;
no_route:
723
724
725
	kfree_skb(head);
	if (nskb != head)
		kfree_skb(nskb);
726
727
728

	if (asoc)
		IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds's avatar
Linus Torvalds committed
729
730
731
732
733
734
735
736
737
738
739
740
741
742

	/* FIXME: Returning the 'err' will effect all the associations
	 * associated with a socket, although only one of the paths of the
	 * association is unreachable.
	 * The real failure of a transport or association can be passed on
	 * to the user via notifications. So setting this error may not be
	 * required.
	 */
	 /* err = -EHOSTUNREACH; */
err:
	/* Control chunks are unreliable so just drop them.  DATA chunks
	 * will get resent or dropped later.
	 */

743
744
	list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
		list_del_init(&chunk->list);
Linus Torvalds's avatar
Linus Torvalds committed
745
		if (!sctp_chunk_is_data(chunk))
746
			sctp_chunk_free(chunk);
Linus Torvalds's avatar
Linus Torvalds committed
747
748
749
	}
	goto out;
nomem:
750
751
	if (packet->auth && list_empty(&packet->auth->list))
		sctp_chunk_free(packet->auth);
Linus Torvalds's avatar
Linus Torvalds committed
752
753
754
755
756
757
758
759
	err = -ENOMEM;
	goto err;
}

/********************************************************************
 * 2nd Level Abstractions
 ********************************************************************/

760
761
/* This private function check to see if a chunk can be added */
static sctp_xmit_t sctp_packet_can_append_data(struct sctp_packet *packet,
Linus Torvalds's avatar
Linus Torvalds committed
762
763
					   struct sctp_chunk *chunk)
{
764
	size_t datasize, rwnd, inflight, flight_size;
Linus Torvalds's avatar
Linus Torvalds committed
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
	struct sctp_transport *transport = packet->transport;
	struct sctp_association *asoc = transport->asoc;
	struct sctp_outq *q = &asoc->outqueue;

	/* RFC 2960 6.1  Transmission of DATA Chunks
	 *
	 * A) At any given time, the data sender MUST NOT transmit new data to
	 * any destination transport address if its peer's rwnd indicates
	 * that the peer has no buffer space (i.e. rwnd is 0, see Section
	 * 6.2.1).  However, regardless of the value of rwnd (including if it
	 * is 0), the data sender can always have one DATA chunk in flight to
	 * the receiver if allowed by cwnd (see rule B below).  This rule
	 * allows the sender to probe for a change in rwnd that the sender
	 * missed due to the SACK having been lost in transit from the data
	 * receiver to the data sender.
	 */

	rwnd = asoc->peer.rwnd;
783
784
	inflight = q->outstanding_bytes;
	flight_size = transport->flight_size;
Linus Torvalds's avatar
Linus Torvalds committed
785
786
787

	datasize = sctp_data_size(chunk);

788
789
790
791
792
	if (datasize > rwnd && inflight > 0)
		/* We have (at least) one data chunk in flight,
		 * so we can't fall back to rule 6.1 B).
		 */
		return SCTP_XMIT_RWND_FULL;
Linus Torvalds's avatar
Linus Torvalds committed
793
794
795
796
797
798
799
800
801
802
803
804
805

	/* RFC 2960 6.1  Transmission of DATA Chunks
	 *
	 * B) At any given time, the sender MUST NOT transmit new data
	 * to a given transport address if it has cwnd or more bytes
	 * of data outstanding to that transport address.
	 */
	/* RFC 7.2.4 & the Implementers Guide 2.8.
	 *
	 * 3) ...
	 *    When a Fast Retransmit is being performed the sender SHOULD
	 *    ignore the value of cwnd and SHOULD NOT delay retransmission.
	 */
806
807
808
	if (chunk->fast_retransmit != SCTP_NEED_FRTX &&
	    flight_size >= transport->cwnd)
		return SCTP_XMIT_RWND_FULL;
Linus Torvalds's avatar
Linus Torvalds committed
809
810
811
812
813
814
815

	/* Nagle's algorithm to solve small-packet problem:
	 * Inhibit the sending of new chunks when new outgoing data arrives
	 * if any previously transmitted data on the connection remains
	 * unacknowledged.
	 */

816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
	if (sctp_sk(asoc->base.sk)->nodelay)
		/* Nagle disabled */
		return SCTP_XMIT_OK;

	if (!sctp_packet_empty(packet))
		/* Append to packet */
		return SCTP_XMIT_OK;

	if (inflight == 0)
		/* Nothing unacked */
		return SCTP_XMIT_OK;

	if (!sctp_state(asoc, ESTABLISHED))
		return SCTP_XMIT_OK;

	/* Check whether this chunk and all the rest of pending data will fit
	 * or delay in hopes of bundling a full sized packet.
	 */
834
835
	if (chunk->skb->len + q->out_qlen >
		transport->pathmtu - packet->overhead - sizeof(sctp_data_chunk_t) - 4)
836
837
838
839
840
841
842
843
		/* Enough data queued to fill a packet */
		return SCTP_XMIT_OK;

	/* Don't delay large message writes that may have been fragmented */
	if (!chunk->msg->can_delay)
		return SCTP_XMIT_OK;

	/* Defer until all data acked or packet full */
844
	return SCTP_XMIT_DELAY;
845
846
847
848
849
850
851
852
853
854
855
}

/* This private function does management things when adding DATA chunk */
static void sctp_packet_append_data(struct sctp_packet *packet,
				struct sctp_chunk *chunk)
{
	struct sctp_transport *transport = packet->transport;
	size_t datasize = sctp_data_size(chunk);
	struct sctp_association *asoc = transport->asoc;
	u32 rwnd = asoc->peer.rwnd;

Linus Torvalds's avatar
Linus Torvalds committed
856
857
858
859
860
861
	/* Keep track of how many bytes are in flight over this transport. */
	transport->flight_size += datasize;

	/* Keep track of how many bytes are in flight to the receiver. */
	asoc->outqueue.outstanding_bytes += datasize;

862
	/* Update our view of the receiver's rwnd. */
Linus Torvalds's avatar
Linus Torvalds committed
863
864
865
866
867
868
869
870
871
	if (datasize < rwnd)
		rwnd -= datasize;
	else
		rwnd = 0;

	asoc->peer.rwnd = rwnd;
	/* Has been accepted for transmission. */
	if (!asoc->peer.prsctp_capable)
		chunk->msg->can_abandon = 0;
872
873
	sctp_chunk_assign_tsn(chunk);
	sctp_chunk_assign_ssn(chunk);
874
875
876
877
878
879
}

static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
					struct sctp_chunk *chunk,
					u16 chunk_len)
{
880
	size_t psize, pmtu;
881
882
883
	sctp_xmit_t retval = SCTP_XMIT_OK;

	psize = packet->size;
884
885
886
887
	if (packet->transport->asoc)
		pmtu = packet->transport->asoc->pathmtu;
	else
		pmtu = packet->transport->pathmtu;
888
889

	/* Decide if we need to fragment or resubmit later. */
890
891
	if (psize + chunk_len > pmtu) {
		/* It's OK to fragment at IP level if any one of the following
892
		 * is true:
893
894
895
896
		 *	1. The packet is empty (meaning this chunk is greater
		 *	   the MTU)
		 *	2. The packet doesn't have any data in it yet and data
		 *	   requires authentication.
897
		 */
898
		if (sctp_packet_empty(packet) ||
899
900
901
902
903
904
		    (!packet->has_data && chunk->auth)) {
			/* We no longer do re-fragmentation.
			 * Just fragment at the IP layer, if we
			 * actually hit this condition
			 */
			packet->ipfragok = 1;
905
			goto out;
906
		}
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934

		/* It is also okay to fragment if the chunk we are
		 * adding is a control chunk, but only if current packet
		 * is not a GSO one otherwise it causes fragmentation of
		 * a large frame. So in this case we allow the
		 * fragmentation by forcing it to be in a new packet.
		 */
		if (!sctp_chunk_is_data(chunk) && packet->has_data)
			retval = SCTP_XMIT_PMTU_FULL;

		if (psize + chunk_len > packet->max_size)
			/* Hit GSO/PMTU limit, gotta flush */
			retval = SCTP_XMIT_PMTU_FULL;

		if (!packet->transport->burst_limited &&
		    psize + chunk_len > (packet->transport->cwnd >> 1))
			/* Do not allow a single GSO packet to use more
			 * than half of cwnd.
			 */
			retval = SCTP_XMIT_PMTU_FULL;

		if (packet->transport->burst_limited &&
		    psize + chunk_len > (packet->transport->burst_limited >> 1))
			/* Do not allow a single GSO packet to use more
			 * than half of original cwnd.
			 */
			retval = SCTP_XMIT_PMTU_FULL;
		/* Otherwise it will fit in the GSO packet */
935
	}
Linus Torvalds's avatar
Linus Torvalds committed
936

937
out:
Linus Torvalds's avatar
Linus Torvalds committed
938
939
	return retval;
}