output.c 22.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
87
88
/* 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)
{
	struct sctp_chunk *chunk = NULL;

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

	packet->vtag = vtag;

	if (ecn_capable && sctp_packet_empty(packet)) {
		chunk = sctp_get_ecne_prepend(packet->transport->asoc);

		/* If there a is a prepend chunk stick it on the list before
97
98
		 * any other chunks get appended.
		 */
Linus Torvalds's avatar
Linus Torvalds committed
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
		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;

114
	pr_debug("%s: packet:%p transport:%p\n", __func__, packet, transport);
Linus Torvalds's avatar
Linus Torvalds committed
115
116
117
118

	packet->transport = transport;
	packet->source_port = sport;
	packet->destination_port = dport;
119
	INIT_LIST_HEAD(&packet->chunk_list);
Linus Torvalds's avatar
Linus Torvalds committed
120
	if (asoc) {
121
122
		struct sctp_sock *sp = sctp_sk(asoc->base.sk);
		overhead = sp->pf->af->net_header_len;
Linus Torvalds's avatar
Linus Torvalds committed
123
124
125
126
127
	} else {
		overhead = sizeof(struct ipv6hdr);
	}
	overhead += sizeof(struct sctphdr);
	packet->overhead = overhead;
128
	sctp_packet_reset(packet);
Linus Torvalds's avatar
Linus Torvalds committed
129
	packet->vtag = 0;
130

Linus Torvalds's avatar
Linus Torvalds committed
131
132
133
134
135
136
	return packet;
}

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

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

141
142
	list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
		list_del_init(&chunk->list);
Linus Torvalds's avatar
Linus Torvalds committed
143
		sctp_chunk_free(chunk);
144
	}
Linus Torvalds's avatar
Linus Torvalds committed
145
146
147
148
149
150
151
152
153
154
}

/* 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,
155
				       struct sctp_chunk *chunk,
156
				       int one_packet, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
157
158
159
160
{
	sctp_xmit_t retval;
	int error = 0;

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

	switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
	case SCTP_XMIT_PMTU_FULL:
		if (!packet->has_cookie_echo) {
166
			error = sctp_packet_transmit(packet, gfp);
Linus Torvalds's avatar
Linus Torvalds committed
167
168
169
170
171
172
			if (error < 0)
				chunk->skb->sk->sk_err = -error;

			/* If we have an empty packet, then we can NOT ever
			 * return PMTU_FULL.
			 */
173
174
175
			if (!one_packet)
				retval = sctp_packet_append_chunk(packet,
								  chunk);
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
		}
		break;

	case SCTP_XMIT_RWND_FULL:
	case SCTP_XMIT_OK:
181
	case SCTP_XMIT_DELAY:
Linus Torvalds's avatar
Linus Torvalds committed
182
		break;
183
	}
Linus Torvalds's avatar
Linus Torvalds committed
184
185
186
187

	return retval;
}

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
/* 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.
	 */
203
	if (chunk->chunk_hdr->type == SCTP_CID_AUTH || pkt->has_auth)
204
205
206
207
208
209
210
211
212
213
214
215
		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;

216
217
218
219
	retval = __sctp_packet_append_chunk(pkt, auth);

	if (retval != SCTP_XMIT_OK)
		sctp_chunk_free(auth);
220
221
222
223

	return retval;
}

Linus Torvalds's avatar
Linus Torvalds committed
224
225
226
227
228
229
230
231
232
233
234
235
/* 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
236
		struct timer_list *timer;
Linus Torvalds's avatar
Linus Torvalds committed
237
		asoc = pkt->transport->asoc;
Doug Graham's avatar
Doug Graham committed
238
		timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
Linus Torvalds's avatar
Linus Torvalds committed
239

Doug Graham's avatar
Doug Graham committed
240
241
		/* If the SACK timer is running, we have a pending SACK */
		if (timer_pending(timer)) {
Linus Torvalds's avatar
Linus Torvalds committed
242
			struct sctp_chunk *sack;
243
244
245
246
247

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

Linus Torvalds's avatar
Linus Torvalds committed
248
249
250
			asoc->a_rwnd = asoc->rwnd;
			sack = sctp_make_sack(asoc);
			if (sack) {
251
252
253
254
255
				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
256
				asoc->peer.sack_needed = 0;
Doug Graham's avatar
Doug Graham committed
257
				if (del_timer(timer))
Linus Torvalds's avatar
Linus Torvalds committed
258
259
260
261
					sctp_association_put(asoc);
			}
		}
	}
262
out:
Linus Torvalds's avatar
Linus Torvalds committed
263
264
265
	return retval;
}

266

Linus Torvalds's avatar
Linus Torvalds committed
267
268
269
/* Append a chunk to the offered packet reporting back any inability to do
 * so.
 */
270
271
static sctp_xmit_t __sctp_packet_append_chunk(struct sctp_packet *packet,
					      struct sctp_chunk *chunk)
Linus Torvalds's avatar
Linus Torvalds committed
272
273
274
275
{
	sctp_xmit_t retval = SCTP_XMIT_OK;
	__u16 chunk_len = WORD_ROUND(ntohs(chunk->chunk_hdr->length));

276
277
278
279
	/* 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
280

281
	/* We believe that this chunk is OK to add to the packet */
282
	switch (chunk->chunk_hdr->type) {
283
	case SCTP_CID_DATA:
284
285
		/* Account for the data being in the packet */
		sctp_packet_append_data(packet, chunk);
Linus Torvalds's avatar
Linus Torvalds committed
286
287
		/* Disallow SACK bundling after DATA. */
		packet->has_sack = 1;
288
289
290
291
		/* Disallow AUTH bundling after DATA */
		packet->has_auth = 1;
		/* Let it be knows that packet has DATA in it */
		packet->has_data = 1;
292
293
		/* timestamp the chunk for rtx purposes */
		chunk->sent_at = jiffies;
294
		break;
295
	case SCTP_CID_COOKIE_ECHO:
Linus Torvalds's avatar
Linus Torvalds committed
296
		packet->has_cookie_echo = 1;
297
298
		break;

299
	case SCTP_CID_SACK:
Linus Torvalds's avatar
Linus Torvalds committed
300
		packet->has_sack = 1;
301
302
		if (chunk->asoc)
			chunk->asoc->stats.osacks++;
303
304
		break;

305
	case SCTP_CID_AUTH:
306
307
308
309
		packet->has_auth = 1;
		packet->auth = chunk;
		break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
310
311

	/* It is OK to send this chunk.  */
312
	list_add_tail(&chunk->list, &packet->chunk_list);
Linus Torvalds's avatar
Linus Torvalds committed
313
314
315
316
317
318
	packet->size += chunk_len;
	chunk->transport = packet->transport;
finish:
	return retval;
}

319
320
321
322
323
324
325
326
/* 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;

327
	pr_debug("%s: packet:%p chunk:%p\n", __func__, packet, chunk);
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354

	/* 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;
}

355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
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
374
375
376
377
378
/* All packets are sent to the network through this function from
 * sctp_outq_tail().
 *
 * The return value is a normal kernel error return value.
 */
379
int sctp_packet_transmit(struct sctp_packet *packet, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
380
381
382
383
384
{
	struct sctp_transport *tp = packet->transport;
	struct sctp_association *asoc = tp->asoc;
	struct sctphdr *sh;
	struct sk_buff *nskb;
385
	struct sctp_chunk *chunk, *tmp;
Linus Torvalds's avatar
Linus Torvalds committed
386
387
388
389
	struct sock *sk;
	int err = 0;
	int padding;		/* How much padding do we need?  */
	__u8 has_data = 0;
390
	struct dst_entry *dst;
391
	unsigned char *auth = NULL;	/* pointer to auth in skb data */
Linus Torvalds's avatar
Linus Torvalds committed
392

393
	pr_debug("%s: packet:%p\n", __func__, packet);
Linus Torvalds's avatar
Linus Torvalds committed
394
395

	/* Do NOT generate a chunkless packet. */
396
	if (list_empty(&packet->chunk_list))
Linus Torvalds's avatar
Linus Torvalds committed
397
398
399
		return err;

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

	/* Allocate the new skb.  */
404
	nskb = alloc_skb(packet->size + MAX_HEADER, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
408
	if (!nskb)
		goto nomem;

	/* Make sure the outbound skb has enough header room reserved. */
409
	skb_reserve(nskb, packet->overhead + MAX_HEADER);
Linus Torvalds's avatar
Linus Torvalds committed
410
411
412
413

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

416
	if (!sctp_transport_dst_check(tp)) {
417
418
		sctp_transport_route(tp, NULL, sctp_sk(sk));
		if (asoc && (asoc->param_flags & SPP_PMTUD_ENABLE)) {
419
			sctp_assoc_sync_pmtu(sk, asoc);
420
421
		}
	}
Eric Dumazet's avatar
Eric Dumazet committed
422
	dst = dst_clone(tp->dst);
423
	if (!dst)
424
		goto no_route;
425
	skb_dst_set(nskb, dst);
426

Linus Torvalds's avatar
Linus Torvalds committed
427
428
	/* Build the SCTP header.  */
	sh = (struct sctphdr *)skb_push(nskb, sizeof(struct sctphdr));
429
	skb_reset_transport_header(nskb);
Linus Torvalds's avatar
Linus Torvalds committed
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
	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;

	/**
	 * 6.10 Bundling
	 *
	 *    An endpoint bundles chunks by simply including multiple
	 *    chunks in one outbound SCTP packet.  ...
	 */

	/**
	 * 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.]
	 */
463
464
465

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

466
467
	list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
		list_del_init(&chunk->list);
Linus Torvalds's avatar
Linus Torvalds committed
468
		if (sctp_chunk_is_data(chunk)) {
469
470
471
472
473
474
			/* 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.
			 */
Linus Torvalds's avatar
Linus Torvalds committed
475

476
			if (!chunk->resent && !tp->rto_pending) {
477
478
				chunk->rtt_in_progress = 1;
				tp->rto_pending = 1;
479
			}
480

Linus Torvalds's avatar
Linus Torvalds committed
481
482
483
484
485
486
487
			has_data = 1;
		}

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

488
489
490
491
492
493
494
495
		/* 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),
496
			       chunk->skb->data, chunk->skb->len);
Linus Torvalds's avatar
Linus Torvalds committed
497

498
499
500
501
502
503
504
		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);
Linus Torvalds's avatar
Linus Torvalds committed
505
506
507
508
509
510
511

		/*
		 * If this is a control chunk, this is our last
		 * reference. Free data chunks after they've been
		 * acknowledged or have failed.
		 */
		if (!sctp_chunk_is_data(chunk))
512
			sctp_chunk_free(chunk);
Linus Torvalds's avatar
Linus Torvalds committed
513
514
	}

515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
	/* 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_ATOMIC);

	/* 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>.
	 */
536
	if (!sctp_checksum_disable) {
537
		if (!(dst->dev->features & NETIF_F_SCTP_CRC) ||
538
		    (dst_xfrm(dst) != NULL) || packet->ipfragok) {
539
			sh->checksum = sctp_compute_cksum(nskb, 0);
540
		} else {
Lucas De Marchi's avatar
Lucas De Marchi committed
541
			/* no need to seed pseudo checksum for SCTP */
542
			nskb->ip_summed = CHECKSUM_PARTIAL;
543
			nskb->csum_start = skb_transport_header(nskb) - nskb->head;
544
545
546
			nskb->csum_offset = offsetof(struct sctphdr, checksum);
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
547
548
549
550
551
552
553
554
555
556
557
558
559

	/* 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().
	 */
560
	tp->af_specific->ecn_capable(nskb->sk);
Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
564
565
566
567

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

	/* Dump that on IP!  */
568
569
570
571
572
573
574
	if (asoc) {
		asoc->stats.opackets++;
		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
575
576
577
578
579
580
581
	}

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

		/* Restart the AUTOCLOSE timer when sending data. */
582
583
		if (sctp_state(asoc, ESTABLISHED) &&
		    asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE]) {
Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
588
589
590
591
			timer = &asoc->timers[SCTP_EVENT_TIMEOUT_AUTOCLOSE];
			timeout = asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE];

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

592
	pr_debug("***sctp_transmit_packet*** skb->len:%d\n", nskb->len);
Linus Torvalds's avatar
Linus Torvalds committed
593

WANG Cong's avatar
WANG Cong committed
594
	nskb->ignore_df = packet->ipfragok;
595
	tp->af_specific->sctp_xmit(nskb, tp);
Linus Torvalds's avatar
Linus Torvalds committed
596
597

out:
598
	sctp_packet_reset(packet);
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
	return err;
no_route:
	kfree_skb(nskb);
602
603
604

	if (asoc)
		IP_INC_STATS(sock_net(asoc->base.sk), IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds's avatar
Linus Torvalds committed
605
606
607
608
609
610
611
612
613
614
615
616
617
618

	/* 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.
	 */

619
620
	list_for_each_entry_safe(chunk, tmp, &packet->chunk_list, list) {
		list_del_init(&chunk->list);
Linus Torvalds's avatar
Linus Torvalds committed
621
		if (!sctp_chunk_is_data(chunk))
622
			sctp_chunk_free(chunk);
Linus Torvalds's avatar
Linus Torvalds committed
623
624
625
626
627
628
629
630
631
632
633
	}
	goto out;
nomem:
	err = -ENOMEM;
	goto err;
}

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

634
635
/* 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
636
637
					   struct sctp_chunk *chunk)
{
638
	size_t datasize, rwnd, inflight, flight_size;
Linus Torvalds's avatar
Linus Torvalds committed
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
	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;
657
658
	inflight = q->outstanding_bytes;
	flight_size = transport->flight_size;
Linus Torvalds's avatar
Linus Torvalds committed
659
660
661

	datasize = sctp_data_size(chunk);

662
663
664
665
666
	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
667
668
669
670
671
672
673
674
675
676
677
678
679

	/* 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.
	 */
680
681
682
	if (chunk->fast_retransmit != SCTP_NEED_FRTX &&
	    flight_size >= transport->cwnd)
		return SCTP_XMIT_RWND_FULL;
Linus Torvalds's avatar
Linus Torvalds committed
683
684
685
686
687
688
689

	/* 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.
	 */

690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
	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.
	 */
	if (chunk->skb->len + q->out_qlen >= transport->pathmtu - packet->overhead)
		/* 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 */
717
	return SCTP_XMIT_DELAY;
718
719
720
721
722
723
724
725
726
727
728
}

/* 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
729
730
731
732
733
734
	/* 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;

735
	/* Update our view of the receiver's rwnd. */
Linus Torvalds's avatar
Linus Torvalds committed
736
737
738
739
740
741
742
743
744
	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;
745
746
	sctp_chunk_assign_tsn(chunk);
	sctp_chunk_assign_ssn(chunk);
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
}

static sctp_xmit_t sctp_packet_will_fit(struct sctp_packet *packet,
					struct sctp_chunk *chunk,
					u16 chunk_len)
{
	size_t psize;
	size_t pmtu;
	int too_big;
	sctp_xmit_t retval = SCTP_XMIT_OK;

	psize = packet->size;
	pmtu  = ((packet->transport->asoc) ?
		(packet->transport->asoc->pathmtu) :
		(packet->transport->pathmtu));

	too_big = (psize + chunk_len > pmtu);

	/* Decide if we need to fragment or resubmit later. */
	if (too_big) {
		/* It's OK to fragmet at IP level if any one of the following
		 * is true:
		 * 	1. The packet is empty (meaning this chunk is greater
		 * 	   the MTU)
		 * 	2. The chunk we are adding is a control chunk
		 * 	3. The packet doesn't have any data in it yet and data
		 * 	requires authentication.
		 */
		if (sctp_packet_empty(packet) || !sctp_chunk_is_data(chunk) ||
		    (!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;
		} else {
			retval = SCTP_XMIT_PMTU_FULL;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
786
787
788

	return retval;
}