associola.c 46.8 KB
Newer Older
1
/* SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
2
3
4
5
6
7
 * (C) Copyright IBM Corp. 2001, 2004
 * Copyright (c) 1999-2000 Cisco, Inc.
 * Copyright (c) 1999-2001 Motorola, Inc.
 * Copyright (c) 2001 Intel Corp.
 * Copyright (c) 2001 La Monte H.P. Yarroll
 *
8
 * This file is part of the SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
9
10
11
 *
 * This module provides the abstraction for an SCTP association.
 *
12
 * This SCTP implementation is free software;
Linus Torvalds's avatar
Linus Torvalds committed
13
14
15
16
17
 * 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.
 *
18
 * This SCTP implementation is distributed in the hope that it
Linus Torvalds's avatar
Linus Torvalds committed
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 * 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
 * along with GNU CC; see the file COPYING.  If not, write to
 * the Free Software Foundation, 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
 *    lksctp developers <lksctp-developers@lists.sourceforge.net>
 *
 * Or submit a bug report through the following website:
 *    http://www.sf.net/projects/lksctp
 *
 * Written or modified by:
 *    La Monte H.P. Yarroll <piggy@acm.org>
 *    Karl Knutson          <karl@athena.chicago.il.us>
 *    Jon Grimm             <jgrimm@us.ibm.com>
 *    Xingang Guo           <xingang.guo@intel.com>
 *    Hui Huang             <hui.huang@nokia.com>
 *    Sridhar Samudrala	    <sri@us.ibm.com>
 *    Daisy Chang	    <daisyc@us.ibm.com>
 *    Ryan Layer	    <rmlayer@us.ibm.com>
 *    Kevin Gao             <kevin.gao@intel.com>
 *
 * Any bugs reported given to us we will try to fix... any fixes shared will
 * be incorporated into the next SCTP release.
 */

51
52
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
57
58
59
60
61
62
63
64
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/poll.h>
#include <linux/init.h>

#include <linux/slab.h>
#include <linux/in.h>
#include <net/ipv6.h>
#include <net/sctp/sctp.h>
#include <net/sctp/sm.h>

/* Forward declarations for internal functions. */
David Howells's avatar
David Howells committed
65
static void sctp_assoc_bh_rcv(struct work_struct *work);
66
static void sctp_assoc_free_asconf_acks(struct sctp_association *asoc);
67
static void sctp_assoc_free_asconf_queue(struct sctp_association *asoc);
Linus Torvalds's avatar
Linus Torvalds committed
68
69
70
71
72
73
74
75

/* 1st Level Abstractions. */

/* Initialize a new association from provided memory. */
static struct sctp_association *sctp_association_init(struct sctp_association *asoc,
					  const struct sctp_endpoint *ep,
					  const struct sock *sk,
					  sctp_scope_t scope,
76
					  gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
77
{
78
	struct net *net = sock_net(sk);
Linus Torvalds's avatar
Linus Torvalds committed
79
80
	struct sctp_sock *sp;
	int i;
81
82
	sctp_paramhdr_t *p;
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
83
84
85
86
87
88
89

	/* Retrieve the SCTP per socket area.  */
	sp = sctp_sk((struct sock *)sk);

	/* Discarding const is appropriate here.  */
	asoc->ep = (struct sctp_endpoint *)ep;
	asoc->base.sk = (struct sock *)sk;
90
91

	sctp_endpoint_hold(asoc->ep);
Linus Torvalds's avatar
Linus Torvalds committed
92
93
94
95
96
97
98
	sock_hold(asoc->base.sk);

	/* Initialize the common base substructure.  */
	asoc->base.type = SCTP_EP_TYPE_ASSOCIATION;

	/* Initialize the object handling fields.  */
	atomic_set(&asoc->base.refcnt, 1);
99
	asoc->base.dead = false;
Linus Torvalds's avatar
Linus Torvalds committed
100
101
102
103
104
105
106
107
108
109
110
111
112

	/* Initialize the bind addr area.  */
	sctp_bind_addr_init(&asoc->base.bind_addr, ep->base.bind_addr.port);

	asoc->state = SCTP_STATE_CLOSED;

	/* Set these values from the socket values, a conversion between
	 * millsecons to seconds/microseconds must also be done.
	 */
	asoc->cookie_life.tv_sec = sp->assocparams.sasoc_cookie_life / 1000;
	asoc->cookie_life.tv_usec = (sp->assocparams.sasoc_cookie_life % 1000)
					* 1000;
	asoc->frag_point = 0;
113
	asoc->user_frag = sp->user_frag;
Linus Torvalds's avatar
Linus Torvalds committed
114
115
116
117
118

	/* Set the association max_retrans and RTO values from the
	 * socket values.
	 */
	asoc->max_retrans = sp->assocparams.sasoc_asocmaxrxt;
119
	asoc->pf_retrans  = net->sctp.pf_retrans;
120

Linus Torvalds's avatar
Linus Torvalds committed
121
122
123
124
125
126
	asoc->rto_initial = msecs_to_jiffies(sp->rtoinfo.srto_initial);
	asoc->rto_max = msecs_to_jiffies(sp->rtoinfo.srto_max);
	asoc->rto_min = msecs_to_jiffies(sp->rtoinfo.srto_min);

	asoc->overall_error_count = 0;

127
128
129
130
131
132
133
134
135
136
137
138
139
	/* Initialize the association's heartbeat interval based on the
	 * sock configured value.
	 */
	asoc->hbinterval = msecs_to_jiffies(sp->hbinterval);

	/* Initialize path max retrans value. */
	asoc->pathmaxrxt = sp->pathmaxrxt;

	/* Initialize default path MTU. */
	asoc->pathmtu = sp->pathmtu;

	/* Set association default SACK delay */
	asoc->sackdelay = msecs_to_jiffies(sp->sackdelay);
140
	asoc->sackfreq = sp->sackfreq;
141
142
143
144
145
146

	/* Set the association default flags controlling
	 * Heartbeat, SACK delay, and Path MTU Discovery.
	 */
	asoc->param_flags = sp->param_flags;

Linus Torvalds's avatar
Linus Torvalds committed
147
148
149
	/* Initialize the maximum mumber of new data packets that can be sent
	 * in a burst.
	 */
150
	asoc->max_burst = sp->max_burst;
Linus Torvalds's avatar
Linus Torvalds committed
151

152
153
154
155
156
157
158
159
160
161
162
163
	/* initialize association timers */
	asoc->timeouts[SCTP_EVENT_TIMEOUT_NONE] = 0;
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_COOKIE] = asoc->rto_initial;
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T1_INIT] = asoc->rto_initial;
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T2_SHUTDOWN] = asoc->rto_initial;
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T3_RTX] = 0;
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T4_RTO] = 0;

	/* sctpimpguide Section 2.12.2
	 * If the 'T5-shutdown-guard' timer is used, it SHOULD be set to the
	 * recommended value of 5 times 'RTO.Max'.
	 */
164
	asoc->timeouts[SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]
165
166
167
		= 5 * asoc->rto_max;

	asoc->timeouts[SCTP_EVENT_TIMEOUT_HEARTBEAT] = 0;
168
	asoc->timeouts[SCTP_EVENT_TIMEOUT_SACK] = asoc->sackdelay;
169
	asoc->timeouts[SCTP_EVENT_TIMEOUT_AUTOCLOSE] =
170
		min_t(unsigned long, sp->autoclose, net->sctp.max_autoclose) * HZ;
171

172
	/* Initializes the timers */
173
174
175
	for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i)
		setup_timer(&asoc->timers[i], sctp_timer_events[i],
				(unsigned long)asoc);
Linus Torvalds's avatar
Linus Torvalds committed
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

	/* Pull default initialization values from the sock options.
	 * Note: This assumes that the values have already been
	 * validated in the sock.
	 */
	asoc->c.sinit_max_instreams = sp->initmsg.sinit_max_instreams;
	asoc->c.sinit_num_ostreams  = sp->initmsg.sinit_num_ostreams;
	asoc->max_init_attempts	= sp->initmsg.sinit_max_attempts;

	asoc->max_init_timeo =
		 msecs_to_jiffies(sp->initmsg.sinit_max_init_timeo);

	/* Allocate storage for the ssnmap after the inbound and outbound
	 * streams have been negotiated during Init.
	 */
	asoc->ssnmap = NULL;

	/* Set the local window size for receive.
	 * This is also the rcvbuf space per association.
	 * RFC 6 - A SCTP receiver MUST be able to receive a minimum of
	 * 1500 bytes in one SCTP packet.
	 */
198
	if ((sk->sk_rcvbuf/2) < SCTP_DEFAULT_MINWINDOW)
Linus Torvalds's avatar
Linus Torvalds committed
199
200
		asoc->rwnd = SCTP_DEFAULT_MINWINDOW;
	else
201
		asoc->rwnd = sk->sk_rcvbuf/2;
Linus Torvalds's avatar
Linus Torvalds committed
202
203
204
205

	asoc->a_rwnd = asoc->rwnd;

	asoc->rwnd_over = 0;
206
	asoc->rwnd_press = 0;
Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
210
211
212
213

	/* Use my own max window until I learn something better.  */
	asoc->peer.rwnd = SCTP_DEFAULT_MAXWINDOW;

	/* Set the sndbuf size for transmit.  */
	asoc->sndbuf_used = 0;

214
215
216
	/* Initialize the receive memory counter */
	atomic_set(&asoc->rmem_alloc, 0);

Linus Torvalds's avatar
Linus Torvalds committed
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
	init_waitqueue_head(&asoc->wait);

	asoc->c.my_vtag = sctp_generate_tag(ep);
	asoc->peer.i.init_tag = 0;     /* INIT needs a vtag of 0. */
	asoc->c.peer_vtag = 0;
	asoc->c.my_ttag   = 0;
	asoc->c.peer_ttag = 0;
	asoc->c.my_port = ep->base.bind_addr.port;

	asoc->c.initial_tsn = sctp_generate_tsn(ep);

	asoc->next_tsn = asoc->c.initial_tsn;

	asoc->ctsn_ack_point = asoc->next_tsn - 1;
	asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
	asoc->highest_sacked = asoc->ctsn_ack_point;
	asoc->last_cwr_tsn = asoc->ctsn_ack_point;
	asoc->unack_data = 0;

	/* ADDIP Section 4.1 Asconf Chunk Procedures
	 *
	 * When an endpoint has an ASCONF signaled change to be sent to the
	 * remote endpoint it should do the following:
	 * ...
	 * A2) a serial number should be assigned to the chunk. The serial
	 * number SHOULD be a monotonically increasing number. The serial
	 * numbers SHOULD be initialized at the start of the
	 * association to the same value as the initial TSN.
	 */
	asoc->addip_serial = asoc->c.initial_tsn;

248
	INIT_LIST_HEAD(&asoc->addip_chunk_list);
249
	INIT_LIST_HEAD(&asoc->asconf_ack_list);
Linus Torvalds's avatar
Linus Torvalds committed
250
251
252

	/* Make an empty list of remote transport addresses.  */
	INIT_LIST_HEAD(&asoc->peer.transport_addr_list);
253
	asoc->peer.transport_count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
254
255
256
257
258
259
260
261
262
263
264
265
266

	/* RFC 2960 5.1 Normal Establishment of an Association
	 *
	 * After the reception of the first data chunk in an
	 * association the endpoint must immediately respond with a
	 * sack to acknowledge the data chunk.  Subsequent
	 * acknowledgements should be done as described in Section
	 * 6.2.
	 *
	 * [We implement this by telling a new association that it
	 * already received one packet.]
	 */
	asoc->peer.sack_needed = 1;
267
	asoc->peer.sack_cnt = 0;
268
	asoc->peer.sack_generation = 1;
Linus Torvalds's avatar
Linus Torvalds committed
269

270
271
272
273
	/* Assume that the peer will tell us if he recognizes ASCONF
	 * as part of INIT exchange.
	 * The sctp_addip_noauth option is there for backward compatibilty
	 * and will revert old behavior.
Linus Torvalds's avatar
Linus Torvalds committed
274
	 */
275
	asoc->peer.asconf_capable = 0;
276
	if (net->sctp.addip_noauth)
277
		asoc->peer.asconf_capable = 1;
278
279
	asoc->asconf_addr_del_pending = NULL;
	asoc->src_out_of_asoc_ok = 0;
280
	asoc->new_transport = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
281
282
283

	/* Create an input queue.  */
	sctp_inq_init(&asoc->base.inqueue);
David Howells's avatar
David Howells committed
284
	sctp_inq_set_th_handler(&asoc->base.inqueue, sctp_assoc_bh_rcv);
Linus Torvalds's avatar
Linus Torvalds committed
285
286
287
288
289
290
291

	/* Create an output queue.  */
	sctp_outq_init(asoc, &asoc->outqueue);

	if (!sctp_ulpq_init(&asoc->ulpq, asoc))
		goto fail_init;

292
	memset(&asoc->peer.tsn_map, 0, sizeof(struct sctp_tsnmap));
Linus Torvalds's avatar
Linus Torvalds committed
293
294
295
296
297
298
299
300
301

	asoc->need_ecne = 0;

	asoc->assoc_id = 0;

	/* Assume that peer would support both address types unless we are
	 * told otherwise.
	 */
	asoc->peer.ipv4_address = 1;
302
303
	if (asoc->base.sk->sk_family == PF_INET6)
		asoc->peer.ipv6_address = 1;
Linus Torvalds's avatar
Linus Torvalds committed
304
305
306
307
308
309
310
311
312
	INIT_LIST_HEAD(&asoc->asocs);

	asoc->autoclose = sp->autoclose;

	asoc->default_stream = sp->default_stream;
	asoc->default_ppid = sp->default_ppid;
	asoc->default_flags = sp->default_flags;
	asoc->default_context = sp->default_context;
	asoc->default_timetolive = sp->default_timetolive;
313
	asoc->default_rcv_context = sp->default_rcv_context;
Linus Torvalds's avatar
Linus Torvalds committed
314

315
316
317
	/* SCTP_GET_ASSOC_STATS COUNTERS */
	memset(&asoc->stats, 0, sizeof(struct sctp_priv_assoc_stats));

318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
	/* AUTH related initializations */
	INIT_LIST_HEAD(&asoc->endpoint_shared_keys);
	err = sctp_auth_asoc_copy_shkeys(ep, asoc, gfp);
	if (err)
		goto fail_init;

	asoc->active_key_id = ep->active_key_id;
	asoc->asoc_shared_key = NULL;

	asoc->default_hmac_id = 0;
	/* Save the hmacs and chunks list into this association */
	if (ep->auth_hmacs_list)
		memcpy(asoc->c.auth_hmacs, ep->auth_hmacs_list,
			ntohs(ep->auth_hmacs_list->param_hdr.length));
	if (ep->auth_chunk_list)
		memcpy(asoc->c.auth_chunks, ep->auth_chunk_list,
			ntohs(ep->auth_chunk_list->param_hdr.length));

	/* Get the AUTH random number for this association */
	p = (sctp_paramhdr_t *)asoc->c.auth_random;
	p->type = SCTP_PARAM_RANDOM;
	p->length = htons(sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH);
	get_random_bytes(p+1, SCTP_AUTH_RANDOM_LENGTH);

Linus Torvalds's avatar
Linus Torvalds committed
342
343
344
345
	return asoc;

fail_init:
	sock_put(asoc->base.sk);
346
	sctp_endpoint_put(asoc->ep);
Linus Torvalds's avatar
Linus Torvalds committed
347
348
349
350
351
352
	return NULL;
}

/* Allocate and initialize a new association */
struct sctp_association *sctp_association_new(const struct sctp_endpoint *ep,
					 const struct sock *sk,
Alexey Dobriyan's avatar
Alexey Dobriyan committed
353
					 sctp_scope_t scope,
354
					 gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
355
356
357
358
359
360
361
362
363
364
365
{
	struct sctp_association *asoc;

	asoc = t_new(struct sctp_association, gfp);
	if (!asoc)
		goto fail;

	if (!sctp_association_init(asoc, ep, sk, scope, gfp))
		goto fail_init;

	SCTP_DBG_OBJCNT_INC(assoc);
366
	SCTP_DEBUG_PRINTK("Created asoc %p\n", asoc);
Linus Torvalds's avatar
Linus Torvalds committed
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385

	return asoc;

fail_init:
	kfree(asoc);
fail:
	return NULL;
}

/* Free this association if possible.  There may still be users, so
 * the actual deallocation may be delayed.
 */
void sctp_association_free(struct sctp_association *asoc)
{
	struct sock *sk = asoc->base.sk;
	struct sctp_transport *transport;
	struct list_head *pos, *temp;
	int i;

386
387
388
389
390
391
392
393
394
395
396
397
	/* Only real associations count against the endpoint, so
	 * don't bother for if this is a temporary association.
	 */
	if (!asoc->temp) {
		list_del(&asoc->asocs);

		/* Decrement the backlog value for a TCP-style listening
		 * socket.
		 */
		if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
			sk->sk_ack_backlog--;
	}
Linus Torvalds's avatar
Linus Torvalds committed
398
399
400
401

	/* Mark as dead, so other users can know this structure is
	 * going away.
	 */
402
	asoc->base.dead = true;
Linus Torvalds's avatar
Linus Torvalds committed
403
404
405
406
407
408
409
410
411
412

	/* Dispose of any data lying around in the outqueue. */
	sctp_outq_free(&asoc->outqueue);

	/* Dispose of any pending messages for the upper layer. */
	sctp_ulpq_free(&asoc->ulpq);

	/* Dispose of any pending chunks on the inqueue. */
	sctp_inq_free(&asoc->base.inqueue);

413
414
	sctp_tsnmap_free(&asoc->peer.tsn_map);

Linus Torvalds's avatar
Linus Torvalds committed
415
416
417
418
419
420
421
422
423
424
425
426
	/* Free ssnmap storage. */
	sctp_ssnmap_free(asoc->ssnmap);

	/* Clean up the bound address list. */
	sctp_bind_addr_free(&asoc->base.bind_addr);

	/* Do we need to go through all of our timers and
	 * delete them?   To be safe we will try to delete all, but we
	 * should be able to go through and make a guess based
	 * on our state.
	 */
	for (i = SCTP_EVENT_TIMEOUT_NONE; i < SCTP_NUM_TIMEOUT_TYPES; ++i) {
427
		if (del_timer(&asoc->timers[i]))
Linus Torvalds's avatar
Linus Torvalds committed
428
429
430
431
			sctp_association_put(asoc);
	}

	/* Free peer's cached cookie. */
Jesper Juhl's avatar
Jesper Juhl committed
432
	kfree(asoc->peer.cookie);
433
434
435
	kfree(asoc->peer.peer_random);
	kfree(asoc->peer.peer_chunks);
	kfree(asoc->peer.peer_hmacs);
Linus Torvalds's avatar
Linus Torvalds committed
436
437
438
439

	/* Release the transport structures. */
	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
		transport = list_entry(pos, struct sctp_transport, transports);
440
		list_del_rcu(pos);
Linus Torvalds's avatar
Linus Torvalds committed
441
442
443
		sctp_transport_free(transport);
	}

444
445
	asoc->peer.transport_count = 0;

446
	sctp_asconf_queue_teardown(asoc);
Linus Torvalds's avatar
Linus Torvalds committed
447

448
449
450
451
	/* Free pending address space being deleted */
	if (asoc->asconf_addr_del_pending != NULL)
		kfree(asoc->asconf_addr_del_pending);

452
453
454
455
456
457
	/* AUTH - Free the endpoint shared keys */
	sctp_auth_destroy_keys(&asoc->endpoint_shared_keys);

	/* AUTH - Free the association shared key */
	sctp_auth_key_put(asoc->asoc_shared_key);

Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
	sctp_association_put(asoc);
}

/* Cleanup and free up an association. */
static void sctp_association_destroy(struct sctp_association *asoc)
{
	SCTP_ASSERT(asoc->base.dead, "Assoc is not dead", return);

	sctp_endpoint_put(asoc->ep);
	sock_put(asoc->base.sk);

	if (asoc->assoc_id != 0) {
		spin_lock_bh(&sctp_assocs_id_lock);
		idr_remove(&sctp_assocs_id, asoc->assoc_id);
		spin_unlock_bh(&sctp_assocs_id_lock);
	}

475
	WARN_ON(atomic_read(&asoc->rmem_alloc));
476

477
478
	kfree(asoc);
	SCTP_DBG_OBJCNT_DEC(assoc);
Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
482
483
484
}

/* Change the primary destination address for the peer. */
void sctp_assoc_set_primary(struct sctp_association *asoc,
			    struct sctp_transport *transport)
{
485
486
487
488
489
490
491
492
493
	int changeover = 0;

	/* it's a changeover only if we already have a primary path
	 * that we are changing
	 */
	if (asoc->peer.primary_path != NULL &&
	    asoc->peer.primary_path != transport)
		changeover = 1 ;

Linus Torvalds's avatar
Linus Torvalds committed
494
495
496
497
498
499
500
501
502
	asoc->peer.primary_path = transport;

	/* Set a default msg_name for events. */
	memcpy(&asoc->peer.primary_addr, &transport->ipaddr,
	       sizeof(union sctp_addr));

	/* If the primary path is changing, assume that the
	 * user wants to use this new path.
	 */
503
504
	if ((transport->state == SCTP_ACTIVE) ||
	    (transport->state == SCTP_UNKNOWN))
Linus Torvalds's avatar
Linus Torvalds committed
505
506
507
508
509
510
511
512
513
514
515
516
		asoc->peer.active_path = transport;

	/*
	 * SFR-CACC algorithm:
	 * Upon the receipt of a request to change the primary
	 * destination address, on the data structure for the new
	 * primary destination, the sender MUST do the following:
	 *
	 * 1) If CHANGEOVER_ACTIVE is set, then there was a switch
	 * to this destination address earlier. The sender MUST set
	 * CYCLING_CHANGEOVER to indicate that this switch is a
	 * double switch to the same destination address.
517
518
519
	 *
	 * Really, only bother is we have data queued or outstanding on
	 * the association.
Linus Torvalds's avatar
Linus Torvalds committed
520
	 */
521
522
523
	if (!asoc->outqueue.outstanding_bytes && !asoc->outqueue.out_qlen)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
524
	if (transport->cacc.changeover_active)
525
		transport->cacc.cycling_changeover = changeover;
Linus Torvalds's avatar
Linus Torvalds committed
526
527
528
529

	/* 2) The sender MUST set CHANGEOVER_ACTIVE to indicate that
	 * a changeover has occurred.
	 */
530
	transport->cacc.changeover_active = changeover;
Linus Torvalds's avatar
Linus Torvalds committed
531
532
533
534
535
536
537

	/* 3) The sender MUST store the next TSN to be sent in
	 * next_tsn_at_change.
	 */
	transport->cacc.next_tsn_at_change = asoc->next_tsn;
}

538
539
540
541
542
543
544
545
546
547
548
/* Remove a transport from an association.  */
void sctp_assoc_rm_peer(struct sctp_association *asoc,
			struct sctp_transport *peer)
{
	struct list_head	*pos;
	struct sctp_transport	*transport;

	SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_rm_peer:association %p addr: ",
				 " port: %d\n",
				 asoc,
				 (&peer->ipaddr),
549
				 ntohs(peer->ipaddr.v4.sin_port));
550
551
552
553
554
555
556
557

	/* If we are to remove the current retran_path, update it
	 * to the next peer before removing this peer from the list.
	 */
	if (asoc->peer.retran_path == peer)
		sctp_assoc_update_retran_path(asoc);

	/* Remove this peer from the list. */
558
	list_del_rcu(&peer->transports);
559
560
561
562
563
564
565
566
567
568

	/* Get the first transport of asoc. */
	pos = asoc->peer.transport_addr_list.next;
	transport = list_entry(pos, struct sctp_transport, transports);

	/* Update any entries that match the peer to be deleted. */
	if (asoc->peer.primary_path == peer)
		sctp_assoc_set_primary(asoc, transport);
	if (asoc->peer.active_path == peer)
		asoc->peer.active_path = transport;
569
570
	if (asoc->peer.retran_path == peer)
		asoc->peer.retran_path = transport;
571
572
573
574
575
576
577
578
579
580
581
	if (asoc->peer.last_data_from == peer)
		asoc->peer.last_data_from = transport;

	/* If we remove the transport an INIT was last sent to, set it to
	 * NULL. Combined with the update of the retran path above, this
	 * will cause the next INIT to be sent to the next available
	 * transport, maintaining the cycle.
	 */
	if (asoc->init_last_sent_to == peer)
		asoc->init_last_sent_to = NULL;

582
583
584
585
586
587
588
589
	/* If we remove the transport an SHUTDOWN was last sent to, set it
	 * to NULL. Combined with the update of the retran path above, this
	 * will cause the next SHUTDOWN to be sent to the next available
	 * transport, maintaining the cycle.
	 */
	if (asoc->shutdown_last_sent_to == peer)
		asoc->shutdown_last_sent_to = NULL;

590
591
592
593
594
595
596
	/* If we remove the transport an ASCONF was last sent to, set it to
	 * NULL.
	 */
	if (asoc->addip_last_asconf &&
	    asoc->addip_last_asconf->transport == peer)
		asoc->addip_last_asconf->transport = NULL;

597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
	/* If we have something on the transmitted list, we have to
	 * save it off.  The best place is the active path.
	 */
	if (!list_empty(&peer->transmitted)) {
		struct sctp_transport *active = asoc->peer.active_path;
		struct sctp_chunk *ch;

		/* Reset the transport of each chunk on this list */
		list_for_each_entry(ch, &peer->transmitted,
					transmitted_list) {
			ch->transport = NULL;
			ch->rtt_in_progress = 0;
		}

		list_splice_tail_init(&peer->transmitted,
					&active->transmitted);

		/* Start a T3 timer here in case it wasn't running so
		 * that these migrated packets have a chance to get
		 * retrnasmitted.
		 */
		if (!timer_pending(&active->T3_rtx_timer))
			if (!mod_timer(&active->T3_rtx_timer,
					jiffies + active->rto))
				sctp_transport_hold(active);
	}

624
625
626
627
628
	asoc->peer.transport_count--;

	sctp_transport_free(peer);
}

Linus Torvalds's avatar
Linus Torvalds committed
629
630
631
/* Add a transport address to an association.  */
struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *asoc,
					   const union sctp_addr *addr,
632
					   const gfp_t gfp,
633
					   const int peer_state)
Linus Torvalds's avatar
Linus Torvalds committed
634
{
635
	struct net *net = sock_net(asoc->base.sk);
Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639
640
641
642
	struct sctp_transport *peer;
	struct sctp_sock *sp;
	unsigned short port;

	sp = sctp_sk(asoc->base.sk);

	/* AF_INET and AF_INET6 share common port field. */
643
	port = ntohs(addr->v4.sin_port);
Linus Torvalds's avatar
Linus Torvalds committed
644

645
	SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_add_peer:association %p addr: ",
646
				 " port: %d state:%d\n",
647
648
				 asoc,
				 addr,
649
				 port,
650
				 peer_state);
651

Linus Torvalds's avatar
Linus Torvalds committed
652
653
654
655
656
657
	/* Set the port if it has not been set yet.  */
	if (0 == asoc->peer.port)
		asoc->peer.port = port;

	/* Check to see if this is a duplicate. */
	peer = sctp_assoc_lookup_paddr(asoc, addr);
658
	if (peer) {
659
660
661
662
		/* An UNKNOWN state is only set on transports added by
		 * user in sctp_connectx() call.  Such transports should be
		 * considered CONFIRMED per RFC 4960, Section 5.4.
		 */
663
		if (peer->state == SCTP_UNKNOWN) {
664
			peer->state = SCTP_ACTIVE;
665
		}
Linus Torvalds's avatar
Linus Torvalds committed
666
		return peer;
667
	}
Linus Torvalds's avatar
Linus Torvalds committed
668

669
	peer = sctp_transport_new(net, addr, gfp);
Linus Torvalds's avatar
Linus Torvalds committed
670
671
672
673
674
	if (!peer)
		return NULL;

	sctp_transport_set_owner(peer, asoc);

675
676
677
678
679
680
681
682
	/* Initialize the peer's heartbeat interval based on the
	 * association configured value.
	 */
	peer->hbinterval = asoc->hbinterval;

	/* Set the path max_retrans.  */
	peer->pathmaxrxt = asoc->pathmaxrxt;

683
684
685
	/* And the partial failure retrnas threshold */
	peer->pf_retrans = asoc->pf_retrans;

686
687
688
689
	/* Initialize the peer's SACK delay timeout based on the
	 * association configured value.
	 */
	peer->sackdelay = asoc->sackdelay;
690
	peer->sackfreq = asoc->sackfreq;
691
692
693
694
695
696

	/* Enable/disable heartbeat, SACK delay, and path MTU discovery
	 * based on association setting.
	 */
	peer->param_flags = asoc->param_flags;

697
698
	sctp_transport_route(peer, NULL, sp);

Linus Torvalds's avatar
Linus Torvalds committed
699
	/* Initialize the pmtu of the transport. */
700
701
702
703
704
705
	if (peer->param_flags & SPP_PMTUD_DISABLE) {
		if (asoc->pathmtu)
			peer->pathmtu = asoc->pathmtu;
		else
			peer->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
	}
Linus Torvalds's avatar
Linus Torvalds committed
706
707
708
709
710
711

	/* If this is the first transport addr on this association,
	 * initialize the association PMTU to the peer's PMTU.
	 * If not and the current association PMTU is higher than the new
	 * peer's PMTU, reset the association PMTU to the new peer's PMTU.
	 */
712
713
	if (asoc->pathmtu)
		asoc->pathmtu = min_t(int, peer->pathmtu, asoc->pathmtu);
Linus Torvalds's avatar
Linus Torvalds committed
714
	else
715
		asoc->pathmtu = peer->pathmtu;
Linus Torvalds's avatar
Linus Torvalds committed
716
717

	SCTP_DEBUG_PRINTK("sctp_assoc_add_peer:association %p PMTU set to "
718
			  "%d\n", asoc, asoc->pathmtu);
719
	peer->pmtu_pending = 0;
Linus Torvalds's avatar
Linus Torvalds committed
720

721
	asoc->frag_point = sctp_frag_point(asoc, asoc->pathmtu);
Linus Torvalds's avatar
Linus Torvalds committed
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738

	/* The asoc->peer.port might not be meaningful yet, but
	 * initialize the packet structure anyway.
	 */
	sctp_packet_init(&peer->packet, peer, asoc->base.bind_addr.port,
			 asoc->peer.port);

	/* 7.2.1 Slow-Start
	 *
	 * o The initial cwnd before DATA transmission or after a sufficiently
	 *   long idle period MUST be set to
	 *      min(4*MTU, max(2*MTU, 4380 bytes))
	 *
	 * o The initial value of ssthresh MAY be arbitrarily high
	 *   (for example, implementations MAY use the size of the
	 *   receiver advertised window).
	 */
739
	peer->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
Linus Torvalds's avatar
Linus Torvalds committed
740
741
742
743
744
745
746
747
748

	/* At this point, we may not have the receiver's advertised window,
	 * so initialize ssthresh to the default value and it will be set
	 * later when we process the INIT.
	 */
	peer->ssthresh = SCTP_DEFAULT_MAXWINDOW;

	peer->partial_bytes_acked = 0;
	peer->flight_size = 0;
749
	peer->burst_limited = 0;
Linus Torvalds's avatar
Linus Torvalds committed
750
751
752

	/* Set the transport's RTO.initial value */
	peer->rto = asoc->rto_initial;
753
	sctp_max_rto(asoc, peer);
Linus Torvalds's avatar
Linus Torvalds committed
754

755
756
757
	/* Set the peer's active state. */
	peer->state = peer_state;

Linus Torvalds's avatar
Linus Torvalds committed
758
	/* Attach the remote transport to our asoc.  */
759
	list_add_tail_rcu(&peer->transports, &asoc->peer.transport_addr_list);
760
	asoc->peer.transport_count++;
Linus Torvalds's avatar
Linus Torvalds committed
761
762
763
764
765
766
767

	/* If we do not yet have a primary path, set one.  */
	if (!asoc->peer.primary_path) {
		sctp_assoc_set_primary(asoc, peer);
		asoc->peer.retran_path = peer;
	}

768
769
	if (asoc->peer.active_path == asoc->peer.retran_path &&
	    peer->state != SCTP_UNCONFIRMED) {
Linus Torvalds's avatar
Linus Torvalds committed
770
		asoc->peer.retran_path = peer;
771
	}
Linus Torvalds's avatar
Linus Torvalds committed
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786

	return peer;
}

/* Delete a transport address from an association.  */
void sctp_assoc_del_peer(struct sctp_association *asoc,
			 const union sctp_addr *addr)
{
	struct list_head	*pos;
	struct list_head	*temp;
	struct sctp_transport	*transport;

	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
		transport = list_entry(pos, struct sctp_transport, transports);
		if (sctp_cmp_addr_exact(addr, &transport->ipaddr)) {
787
788
			/* Do book keeping for removing the peer and free it. */
			sctp_assoc_rm_peer(asoc, transport);
Linus Torvalds's avatar
Linus Torvalds committed
789
790
791
792
793
794
795
796
797
798
799
800
801
802
			break;
		}
	}
}

/* Lookup a transport by address. */
struct sctp_transport *sctp_assoc_lookup_paddr(
					const struct sctp_association *asoc,
					const union sctp_addr *address)
{
	struct sctp_transport *t;

	/* Cycle through all transports searching for a peer address. */

803
804
	list_for_each_entry(t, &asoc->peer.transport_addr_list,
			transports) {
Linus Torvalds's avatar
Linus Torvalds committed
805
806
807
808
809
810
811
		if (sctp_cmp_addr_exact(address, &t->ipaddr))
			return t;
	}

	return NULL;
}

812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
/* Remove all transports except a give one */
void sctp_assoc_del_nonprimary_peers(struct sctp_association *asoc,
				     struct sctp_transport *primary)
{
	struct sctp_transport	*temp;
	struct sctp_transport	*t;

	list_for_each_entry_safe(t, temp, &asoc->peer.transport_addr_list,
				 transports) {
		/* if the current transport is not the primary one, delete it */
		if (t != primary)
			sctp_assoc_rm_peer(asoc, t);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
827
828
829
830
831
832
833
834
835
836
837
838
839
/* Engage in transport control operations.
 * Mark the transport up or down and send a notification to the user.
 * Select and update the new active and retran paths.
 */
void sctp_assoc_control_transport(struct sctp_association *asoc,
				  struct sctp_transport *transport,
				  sctp_transport_cmd_t command,
				  sctp_sn_error_t error)
{
	struct sctp_transport *t = NULL;
	struct sctp_transport *first;
	struct sctp_transport *second;
	struct sctp_ulpevent *event;
840
	struct sockaddr_storage addr;
Linus Torvalds's avatar
Linus Torvalds committed
841
	int spc_state = 0;
842
	bool ulp_notify = true;
Linus Torvalds's avatar
Linus Torvalds committed
843
844
845
846

	/* Record the transition on the transport.  */
	switch (command) {
	case SCTP_TRANSPORT_UP:
847
848
849
850
851
852
853
854
855
		/* If we are moving from UNCONFIRMED state due
		 * to heartbeat success, report the SCTP_ADDR_CONFIRMED
		 * state to the user, otherwise report SCTP_ADDR_AVAILABLE.
		 */
		if (SCTP_UNCONFIRMED == transport->state &&
		    SCTP_HEARTBEAT_SUCCESS == error)
			spc_state = SCTP_ADDR_CONFIRMED;
		else
			spc_state = SCTP_ADDR_AVAILABLE;
856
857
858
859
860
861
862
863
		/* Don't inform ULP about transition from PF to
		 * active state and set cwnd to 1, see SCTP
		 * Quick failover draft section 5.1, point 5
		 */
		if (transport->state == SCTP_PF) {
			ulp_notify = false;
			transport->cwnd = 1;
		}
864
		transport->state = SCTP_ACTIVE;
Linus Torvalds's avatar
Linus Torvalds committed
865
866
867
		break;

	case SCTP_TRANSPORT_DOWN:
868
869
870
		/* If the transport was never confirmed, do not transition it
		 * to inactive state.  Also, release the cached route since
		 * there may be a better route next time.
871
872
873
		 */
		if (transport->state != SCTP_UNCONFIRMED)
			transport->state = SCTP_INACTIVE;
874
875
876
877
		else {
			dst_release(transport->dst);
			transport->dst = NULL;
		}
878

Linus Torvalds's avatar
Linus Torvalds committed
879
880
881
		spc_state = SCTP_ADDR_UNREACHABLE;
		break;

882
883
884
885
886
	case SCTP_TRANSPORT_PF:
		transport->state = SCTP_PF;
		ulp_notify = false;
		break;

Linus Torvalds's avatar
Linus Torvalds committed
887
888
	default:
		return;
889
	}
Linus Torvalds's avatar
Linus Torvalds committed
890
891
892
893

	/* Generate and send a SCTP_PEER_ADDR_CHANGE notification to the
	 * user.
	 */
894
895
896
897
898
899
900
901
902
	if (ulp_notify) {
		memset(&addr, 0, sizeof(struct sockaddr_storage));
		memcpy(&addr, &transport->ipaddr,
		       transport->af_specific->sockaddr_len);
		event = sctp_ulpevent_make_peer_addr_change(asoc, &addr,
					0, spc_state, error, GFP_ATOMIC);
		if (event)
			sctp_ulpq_tail_event(&asoc->ulpq, event);
	}
Linus Torvalds's avatar
Linus Torvalds committed
903
904
905
906
907
908
909
910
911
912
913

	/* Select new active and retran paths. */

	/* Look for the two most recently used active transports.
	 *
	 * This code produces the wrong ordering whenever jiffies
	 * rolls over, but we still get usable transports, so we don't
	 * worry about it.
	 */
	first = NULL; second = NULL;

914
915
	list_for_each_entry(t, &asoc->peer.transport_addr_list,
			transports) {
Linus Torvalds's avatar
Linus Torvalds committed
916

917
		if ((t->state == SCTP_INACTIVE) ||
918
919
		    (t->state == SCTP_UNCONFIRMED) ||
		    (t->state == SCTP_PF))
Linus Torvalds's avatar
Linus Torvalds committed
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
			continue;
		if (!first || t->last_time_heard > first->last_time_heard) {
			second = first;
			first = t;
		}
		if (!second || t->last_time_heard > second->last_time_heard)
			second = t;
	}

	/* RFC 2960 6.4 Multi-Homed SCTP Endpoints
	 *
	 * By default, an endpoint should always transmit to the
	 * primary path, unless the SCTP user explicitly specifies the
	 * destination transport address (and possibly source
	 * transport address) to use.
	 *
	 * [If the primary is active but not most recent, bump the most
	 * recently used transport.]
	 */
939
940
	if (((asoc->peer.primary_path->state == SCTP_ACTIVE) ||
	     (asoc->peer.primary_path->state == SCTP_UNKNOWN)) &&
Linus Torvalds's avatar
Linus Torvalds committed
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
	    first != asoc->peer.primary_path) {
		second = first;
		first = asoc->peer.primary_path;
	}

	/* If we failed to find a usable transport, just camp on the
	 * primary, even if it is inactive.
	 */
	if (!first) {
		first = asoc->peer.primary_path;
		second = asoc->peer.primary_path;
	}

	/* Set the active and retran transports.  */
	asoc->peer.active_path = first;
	asoc->peer.retran_path = second;
}

/* Hold a reference to an association. */
void sctp_association_hold(struct sctp_association *asoc)
{
	atomic_inc(&asoc->base.refcnt);
}

/* Release a reference to an association and cleanup
 * if there are no more references.
 */
void sctp_association_put(struct sctp_association *asoc)
{
	if (atomic_dec_and_test(&asoc->base.refcnt))
		sctp_association_destroy(asoc);
}

/* Allocate the next TSN, Transmission Sequence Number, for the given
 * association.
 */
__u32 sctp_association_get_next_tsn(struct sctp_association *asoc)
{
	/* From Section 1.6 Serial Number Arithmetic:
	 * Transmission Sequence Numbers wrap around when they reach
	 * 2**32 - 1.  That is, the next TSN a DATA chunk MUST use
	 * after transmitting TSN = 2*32 - 1 is TSN = 0.
	 */
	__u32 retval = asoc->next_tsn;
	asoc->next_tsn++;
	asoc->unack_data++;

	return retval;
}

/* Compare two addresses to see if they match.  Wildcard addresses
 * only match themselves.
 */
int sctp_cmp_addr_exact(const union sctp_addr *ss1,
			const union sctp_addr *ss2)
{
	struct sctp_af *af;

	af = sctp_get_af_specific(ss1->sa.sa_family);
	if (unlikely(!af))
		return 0;

	return af->cmp_addr(ss1, ss2);
}

/* Return an ecne chunk to get prepended to a packet.
 * Note:  We are sly and return a shared, prealloced chunk.  FIXME:
 * No we don't, but we could/should.
 */
struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc)
{
	struct sctp_chunk *chunk;

	/* Send ECNE if needed.
	 * Not being able to allocate a chunk here is not deadly.
	 */
	if (asoc->need_ecne)
		chunk = sctp_make_ecne(asoc, asoc->last_ecne_tsn);
	else
		chunk = NULL;

	return chunk;
}

/*
 * Find which transport this TSN was sent on.
 */
struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *asoc,
					     __u32 tsn)
{
	struct sctp_transport *active;
	struct sctp_transport *match;
	struct sctp_transport *transport;
	struct sctp_chunk *chunk;
1035
	__be32 key = htonl(tsn);
Linus Torvalds's avatar
Linus Torvalds committed
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055

	match = NULL;

	/*
	 * FIXME: In general, find a more efficient data structure for
	 * searching.
	 */

	/*
	 * The general strategy is to search each transport's transmitted
	 * list.   Return which transport this TSN lives on.
	 *
	 * Let's be hopeful and check the active_path first.
	 * Another optimization would be to know if there is only one
	 * outbound path and not have to look for the TSN at all.
	 *
	 */

	active = asoc->peer.active_path;

1056
1057
	list_for_each_entry(chunk, &active->transmitted,
			transmitted_list) {
Linus Torvalds's avatar
Linus Torvalds committed
1058
1059
1060
1061
1062
1063
1064
1065

		if (key == chunk->subh.data_hdr->tsn) {
			match = active;
			goto out;
		}
	}

	/* If not found, go search all the other transports. */
1066
1067
	list_for_each_entry(transport, &asoc->peer.transport_addr_list,
			transports) {
Linus Torvalds's avatar
Linus Torvalds committed
1068
1069

		if (transport == active)
1070
			continue;
1071
1072
		list_for_each_entry(chunk, &transport->transmitted,
				transmitted_list) {
Linus Torvalds's avatar
Linus Torvalds committed
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
			if (key == chunk->subh.data_hdr->tsn) {
				match = transport;
				goto out;
			}
		}
	}
out:
	return match;
}

/* Is this the association we are looking for? */
struct sctp_transport *sctp_assoc_is_match(struct sctp_association *asoc,
1085
					   struct net *net,
Linus Torvalds's avatar
Linus Torvalds committed
1086
1087
1088
1089
1090
					   const union sctp_addr *laddr,
					   const union sctp_addr *paddr)
{
	struct sctp_transport *transport;

1091
	if ((htons(asoc->base.bind_addr.port) == laddr->v4.sin_port) &&
1092
1093
	    (htons(asoc->peer.port) == paddr->v4.sin_port) &&
	    net_eq(sock_net(asoc->base.sk), net)) {
Linus Torvalds's avatar
Linus Torvalds committed
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
		transport = sctp_assoc_lookup_paddr(asoc, paddr);
		if (!transport)
			goto out;

		if (sctp_bind_addr_match(&asoc->base.bind_addr, laddr,
					 sctp_sk(asoc->base.sk)))
			goto out;
	}
	transport = NULL;

out:
	return transport;
}

/* Do delayed input processing.  This is scheduled by sctp_rcv(). */
David Howells's avatar
David Howells committed
1109
static void sctp_assoc_bh_rcv(struct work_struct *work)
Linus Torvalds's avatar
Linus Torvalds committed
1110
{
David Howells's avatar
David Howells committed
1111
1112
1113
	struct sctp_association *asoc =
		container_of(work, struct sctp_association,
			     base.inqueue.immediate);
1114
	struct net *net = sock_net(asoc->base.sk);
Linus Torvalds's avatar
Linus Torvalds committed
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
	struct sctp_endpoint *ep;
	struct sctp_chunk *chunk;
	struct sctp_inq *inqueue;
	int state;
	sctp_subtype_t subtype;
	int error = 0;

	/* The association should be held so we should be safe. */
	ep = asoc->ep;

	inqueue = &asoc->base.inqueue;
	sctp_association_hold(asoc);
	while (NULL != (chunk = sctp_inq_pop(inqueue))) {
		state = asoc->state;
		subtype = SCTP_ST_CHUNK(chunk->chunk_hdr->type);

1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
		/* SCTP-AUTH, Section 6.3:
		 *    The receiver has a list of chunk types which it expects
		 *    to be received only after an AUTH-chunk.  This list has
		 *    been sent to the peer during the association setup.  It
		 *    MUST silently discard these chunks if they are not placed
		 *    after an AUTH chunk in the packet.
		 */
		if (sctp_auth_recv_cid(subtype.chunk, asoc) && !chunk->auth)
			continue;

Linus Torvalds's avatar
Linus Torvalds committed
1141
1142
1143
1144
1145
		/* Remember where the last DATA chunk came from so we
		 * know where to send the SACK.
		 */
		if (sctp_chunk_is_data(chunk))
			asoc->peer.last_data_from = chunk->transport;
1146
		else {
1147
			SCTP_INC_STATS(net, SCTP_MIB_INCTRLCHUNKS);
1148
1149
1150
1151
			asoc->stats.ictrlchunks++;
			if (chunk->chunk_hdr->type == SCTP_CID_SACK)
				asoc->stats.isacks++;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1152
1153
1154
1155
1156

		if (chunk->transport)
			chunk->transport->last_time_heard = jiffies;

		/* Run through the state machine. */
1157
		error = sctp_do_sm(net, SCTP_EVENT_T_CHUNK, subtype,
Linus Torvalds's avatar
Linus Torvalds committed
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
				   state, ep, asoc, chunk, GFP_ATOMIC);

		/* Check to see if the association is freed in response to
		 * the incoming chunk.  If so, get out of the while loop.
		 */
		if (asoc->base.dead)
			break;

		/* If there is an error on chunk, discard this packet. */
		if (error && chunk)
			chunk->pdiscard = 1;
	}
	sctp_association_put(asoc);
}

/* This routine moves an association from its old sk to a new sk.  */
void sctp_assoc_migrate(struct sctp_association *assoc, struct sock *newsk)
{
	struct sctp_sock *newsp = sctp_sk(newsk);
	struct sock *oldsk = assoc->base.sk;

	/* Delete the association from the old endpoint's list of
	 * associations.
	 */
	list_del_init(&assoc->asocs);

	/* Decrement the backlog value for a TCP-style socket. */
	if (sctp_style(oldsk, TCP))
		oldsk->sk_ack_backlog--;

	/* Release references to the old endpoint and the sock.  */
	sctp_endpoint_put(assoc->ep);
	sock_put(assoc->base.sk);

	/* Get a reference to the new endpoint.  */
	assoc->ep = newsp->ep;
	sctp_endpoint_hold(assoc->ep);

	/* Get a reference to the new sock.  */
	assoc->base.sk = newsk;
	sock_hold(assoc->base.sk);

	/* Add the association to the new endpoint's list of associations.  */
	sctp_endpoint_add_asoc(newsp->ep, assoc);
}

/* Update an association (possibly from unexpected COOKIE-ECHO processing).  */
void sctp_assoc_update(struct sctp_association *asoc,
		       struct sctp_association *new)
{
	struct sctp_transport *trans;
	struct list_head *pos, *temp;

	/* Copy in new parameters of peer. */
	asoc->c = new->c;
	asoc->peer.rwnd = new->peer.rwnd;
	asoc->peer.sack_needed = new->peer.sack_needed;
	asoc->peer.i = new->peer.i;
1216
1217
	sctp_tsnmap_init(&asoc->peer.tsn_map, SCTP_TSN_MAP_INITIAL,
			 asoc->peer.i.initial_tsn, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1218
1219
1220
1221

	/* Remove any peer addresses not present in the new association. */
	list_for_each_safe(pos, temp, &asoc->peer.transport_addr_list) {
		trans = list_entry(pos, struct sctp_transport, transports);
1222
1223
1224
1225
		if (!sctp_assoc_lookup_paddr(new, &trans->ipaddr)) {
			sctp_assoc_rm_peer(asoc, trans);
			continue;
		}
1226
1227
1228

		if (asoc->state >= SCTP_STATE_ESTABLISHED)
			sctp_transport_reset(trans);
Linus Torvalds's avatar
Linus Torvalds committed
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
	}

	/* If the case is A (association restart), use
	 * initial_tsn as next_tsn. If the case is B, use
	 * current next_tsn in case data sent to peer
	 * has been discarded and needs retransmission.
	 */
	if (asoc->state >= SCTP_STATE_ESTABLISHED) {
		asoc->next_tsn = new->next_tsn;
		asoc->ctsn_ack_point = new->ctsn_ack_point;
		asoc->adv_peer_ack_point = new->adv_peer_ack_point;

		/* Reinitialize SSN for both local streams
		 * and peer's streams.
		 */
		sctp_ssnmap_clear(asoc->ssnmap);

1246
1247
1248
1249
1250
1251
		/* Flush the ULP reassembly and ordered queue.
		 * Any data there will now be stale and will
		 * cause problems.
		 */
		sctp_ulpq_flush(&asoc->ulpq);

1252
1253
1254
1255
1256
1257
		/* reset the overall association error count so
		 * that the restarted association doesn't get torn
		 * down on the next retransmission timer.
		 */
		asoc->overall_error_count = 0;

Linus Torvalds's avatar
Linus Torvalds committed
1258
1259
	} else {
		/* Add any peer addresses from the new association. */
1260
1261
		list_for_each_entry(trans, &new->peer.transport_addr_list,
				transports) {
Linus Torvalds's avatar
Linus Torvalds committed
1262
1263
			if (!sctp_assoc_lookup_paddr(asoc, &trans->ipaddr))
				sctp_assoc_add_peer(asoc, &trans->ipaddr,
1264
						    GFP_ATOMIC, trans->state);
Linus Torvalds's avatar
Linus Torvalds committed
1265
1266
1267
1268
1269
1270
1271
1272
1273
		}

		asoc->ctsn_ack_point = asoc->next_tsn - 1;
		asoc->adv_peer_ack_point = asoc->ctsn_ack_point;
		if (!asoc->ssnmap) {
			/* Move the ssnmap. */
			asoc->ssnmap = new->ssnmap;
			new->ssnmap = NULL;
		}
1274
1275
1276
1277
1278
1279
1280

		if (!asoc->assoc_id) {
			/* get a new association id since we don't have one
			 * yet.
			 */
			sctp_assoc_set_id(asoc, GFP_ATOMIC);
		}
Linus Torvalds's avatar
Linus Torvalds committed
1281
	}
1282

1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
	/* SCTP-AUTH: Save the peer parameters from the new assocaitions
	 * and also move the association shared keys over
	 */
	kfree(asoc->peer.peer_random);
	asoc->peer.peer_random = new->peer.peer_random;
	new->peer.peer_random = NULL;

	kfree(asoc->peer.peer_chunks);
	asoc->peer.peer_chunks = new->peer.peer_chunks;
	new->peer.peer_chunks = NULL;

	kfree(asoc->peer.peer_hmacs);
	asoc->peer.peer_hmacs = new->peer.peer_hmacs;
	new->peer.peer_hmacs = NULL;

	sctp_auth_key_put(asoc->asoc_shared_key);
	sctp_auth_asoc_init_active_key(asoc, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
}

/* Update the retran path for sending a retransmitted packet.
 * Round-robin through the active transports, else round-robin
 * through the inactive transports as this is the next best thing
 * we can try.
 */
void sctp_assoc_update_retran_path(struct sctp_association *asoc)
{
	struct sctp_transport *t, *next;
	struct list_head *head = &asoc->peer.transport_addr_list;
	struct list_head *pos;

1313
1314
1315
	if (asoc->peer.transport_count == 1)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
	/* Find the next transport in a round-robin fashion. */
	t = asoc->peer.retran_path;
	pos = &t->transports;
	next = NULL;

	while (1) {
		/* Skip the head. */
		if (pos->next == head)
			pos = head->next;
		else
			pos = pos->next;

		t = list_entry(pos, struct sctp_transport, transports);

1330
1331
1332
1333
1334
1335
1336
1337
1338
		/* We have exhausted the list, but didn't find any
		 * other active transports.  If so, use the next
		 * transport.
		 */
		if (t == asoc->peer.retran_path) {
			t = next;
			break;
		}

Linus Torvalds's avatar
Linus Torvalds committed
1339
1340
		/* Try to find an active transport. */

1341
1342
		if ((t->state == SCTP_ACTIVE) ||
		    (t->state == SCTP_UNKNOWN)) {
Linus Torvalds's avatar
Linus Torvalds committed
1343
1344
1345
1346
1347
			break;
		} else {
			/* Keep track of the next transport in case
			 * we don't find any active transport.
			 */
1348
			if (t->state != SCTP_UNCONFIRMED && !next)
Linus Torvalds's avatar
Linus Torvalds committed
1349
1350
1351
1352
				next = t;
		}
	}

1353
1354
	if (t)
		asoc->peer.retran_path = t;
1355
1356
	else
		t = asoc->peer.retran_path;
1357
1358
1359
1360
1361
1362

	SCTP_DEBUG_PRINTK_IPADDR("sctp_assoc_update_retran_path:association"
				 " %p addr: ",
				 " port: %d\n",
				 asoc,
				 (&t->ipaddr),
1363
				 ntohs(t->ipaddr.v4.sin_port));
1364
1365
}

1366
1367
1368
/* Choose the transport for sending retransmit packet.  */
struct sctp_transport *sctp_assoc_choose_alter_transport(
	struct sctp_association *asoc, struct sctp_transport *last_sent_to)
1369
{
1370
1371
	/* If this is the first time packet is sent, use the active path,
	 * else use the retran path. If the last packet was sent over the
1372
1373
	 * retran path, update the retran path and use it.
	 */
1374
	if (!last_sent_to)
Linus Torvalds's avatar
Linus Torvalds committed
1375
1376
		return asoc->peer.active_path;
	else {
1377
		if (last_sent_to == asoc->peer.retran_path)
Linus Torvalds's avatar
Linus Torvalds committed
1378
1379
1380
1381
1382
1383
1384
1385
			sctp_assoc_update_retran_path(asoc);
		return asoc->peer.retran_path;
	}
}

/* Update the association's pmtu and frag_point by going through all the
 * transports. This routine is called when a transport's PMTU has changed.
 */
1386
void sctp_assoc_sync_pmtu(struct sock *sk, struct sctp_association *asoc)
Linus Torvalds's avatar
Linus Torvalds committed
1387
1388
1389
1390
1391
1392
1393
1394
{
	struct sctp_transport *t;
	__u32 pmtu = 0;

	if (!asoc)
		return;

	/* Get the lowest pmtu of all the transports. */
1395
1396
	list_for_each_entry(t, &asoc->peer.transport_addr_list,
				transports) {
1397
		if (t->pmtu_pending && t->dst) {
1398
			sctp_transport_update_pmtu(sk, t, dst_mtu(t->dst));
1399
1400
			t->pmtu_pending = 0;
		}
1401
1402
		if (!pmtu || (t->pathmtu < pmtu))
			pmtu = t->pathmtu;
Linus Torvalds's avatar
Linus Torvalds committed
1403
1404
1405
	}

	if (pmtu) {
1406
		asoc->pathmtu = pmtu;
1407
		asoc->frag_point = sctp_frag_point(asoc, pmtu);
Linus Torvalds's avatar
Linus Torvalds committed
1408
1409
1410
	}

	SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n",
1411
			  __func__, asoc, asoc->pathmtu, asoc->frag_point);
Linus Torvalds's avatar
Linus Torvalds committed
1412
1413
1414
1415
1416
}

/* Should we send a SACK to update our peer? */
static inline int sctp_peer_needs_update(struct sctp_association *asoc)
{
1417
	struct net *net = sock_net(asoc->base.sk);
Linus Torvalds's avatar
Linus Torvalds committed
1418
1419
1420
1421
1422
1423
	switch (asoc->state) {
	case SCTP_STATE_ESTABLISHED:
	case SCTP_STATE_SHUTDOWN_PENDING:
	case SCTP_STATE_SHUTDOWN_RECEIVED:
	case SCTP_STATE_SHUTDOWN_SENT:
		if ((asoc->rwnd > asoc->a_rwnd) &&
1424
		    ((asoc->rwnd - asoc->a_rwnd) >= max_t(__u32,
1425
			   (asoc->base.sk->sk_rcvbuf >> net->sctp.rwnd_upd_shift),
1426
			   asoc->pathmtu)))
Linus Torvalds's avatar
Linus Torvalds committed
1427
1428
1429
1430
1431
1432
1433
1434
1435
			return 1;
		break;
	default:
		break;
	}
	return 0;
}

/* Increase asoc's rwnd by len and send any window update SACK if needed. */
1436
void sctp_assoc_rwnd_increase(struct sctp_association *asoc, unsigned int len)
Linus Torvalds's avatar
Linus Torvalds committed
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
{
	struct sctp_chunk *sack;
	struct timer_list *timer;

	if (asoc->rwnd_over) {
		if (asoc->rwnd_over >= len) {
			asoc->rwnd_over -= len;
		} else {
			asoc->rwnd += (len - asoc->rwnd_over);
			asoc->rwnd_over = 0;
		}
	} else {
		asoc->rwnd += len;
	}

1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
	/* If we had window pressure, start recovering it
	 * once our rwnd had reached the accumulated pressure
	 * threshold.  The idea is to recover slowly, but up
	 * to the initial advertised window.
	 */
	if (asoc->rwnd_press && asoc->rwnd >= asoc->rwnd_press) {
		int change = min(asoc->pathmtu, asoc->rwnd_press);
		asoc->rwnd += change;
		asoc->rwnd_press -= change;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1463
	SCTP_DEBUG_PRINTK("%s: asoc %p rwnd increased by %d to (%u, %u) "
1464
			  "- %u\n", __func__, asoc, len, asoc->rwnd,
Linus Torvalds's avatar
Linus Torvalds committed
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
			  asoc->rwnd_over, asoc->a_rwnd);

	/* Send a window update SACK if the rwnd has increased by at least the
	 * minimum of the association's PMTU and half of the receive buffer.
	 * The algorithm used is similar to the one described in
	 * Section 4.2.3.3 of RFC 1122.
	 */
	if (sctp_peer_needs_update(asoc)) {
		asoc->a_rwnd = asoc->rwnd;
		SCTP_DEBUG_PRINTK("%s: Sending window update SACK- asoc: %p "
1475
				  "rwnd: %u a_rwnd: %u\n", __func__,
Linus Torvalds's avatar
Linus Torvalds committed
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
				  asoc, asoc->rwnd, asoc->a_rwnd);
		sack = sctp_make_sack(asoc);
		if (!sack)
			return;

		asoc->peer.sack_needed = 0;

		sctp_outq_tail(&asoc->outqueue, sack);

		/* Stop the SACK timer.  */
		timer = &asoc->timers[SCTP_EVENT_TIMEOUT_SACK];
1487
		if (del_timer(timer))
Linus Torvalds's avatar
Linus Torvalds committed
1488
1489
1490
1491
1492
			sctp_association_put(asoc);
	}
}

/* Decrease asoc's rwnd by len. */
1493
void sctp_assoc_rwnd_decrease(struct sctp_association *asoc, unsigned int len)
Linus Torvalds's avatar
Linus Torvalds committed
1494
{
1495
1496
1497
	int rx_count;
	int over = 0;

Linus Torvalds's avatar
Linus Torvalds committed
1498
1499
	SCTP_ASSERT(asoc->rwnd, "rwnd zero", return);
	SCTP_ASSERT(!asoc->rwnd_over, "rwnd_over not zero", return);
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513

	if (asoc->ep->rcvbuf_policy)
		rx_count = atomic_read(&asoc->rmem_alloc);
	else
		rx_count = atomic_read(&asoc->base.sk->sk_rmem_alloc);

	/* If we've reached or overflowed our receive buffer, announce
	 * a 0 rwnd if rwnd would still be positive.  Store the
	 * the pottential pressure overflow so that the window can be restored
	 * back to original value.
	 */
	if (rx_count >= asoc->base.sk->sk_rcvbuf)
		over = 1;

Linus Torvalds's avatar
Linus Torvalds committed
1514
1515
	if (asoc->rwnd >= len) {
		asoc->rwnd -= len;
1516
		if (over) {
1517
			asoc->rwnd_press += asoc->rwnd;
1518
1519
			asoc->rwnd = 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1520
1521
1522
1523
	} else {
		asoc->rwnd_over = len - asoc->rwnd;
		asoc->rwnd = 0;
	}
1524
	SCTP_DEBUG_PRINTK("%s: asoc %p rwnd decreased by %d to (%u, %u, %u)\n",
1525
			  __func__, asoc, len, asoc->rwnd,
1526
			  asoc->rwnd_over, asoc->rwnd_press);
Linus Torvalds's avatar
Linus Torvalds committed
1527
1528
1529
1530
1531
}

/* Build the bind address list for the association based on info from the
 * local endpoint and the remote peer.
 */
Alexey Dobriyan's avatar
Alexey Dobriyan committed
1532
int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
1533
				     sctp_scope_t scope, gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
{
	int flags;

	/* Use scoping rules to determine the subset of addresses from
	 * the endpoint.
	 */
	flags = (PF_INET6 == asoc->base.sk->sk_family) ? SCTP_ADDR6_ALLOWED : 0;
	if (asoc->peer.ipv4_address)
		flags |= SCTP_ADDR4_PEERSUPP;
	if (asoc->peer.ipv6_address)
		flags |= SCTP_ADDR6_PEERSUPP;

1546
1547
	return sctp_bind_addr_copy(sock_net(asoc->base.sk),
				   &asoc->base.bind_addr,
Linus Torvalds's avatar
Linus Torvalds committed
1548
1549
1550
1551
1552
1553
				   &asoc->ep->base.bind_addr,
				   scope, gfp, flags);
}

/* Build the association's bind address list from the cookie.  */
int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *asoc,
Alexey Dobriyan's avatar
Alexey Dobriyan committed
1554
					 struct sctp_cookie *cookie,
1555
					 gfp_t gfp)