blob: 6d5944a745d4e3d709ef2660389638d65882a1bc [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * (C) Copyright IBM Corp. 2001, 2003
3 * Copyright (c) Cisco 1999,2000
4 * Copyright (c) Motorola 1999,2000,2001
5 * Copyright (c) La Monte H.P. Yarroll 2001
6 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05007 * This file is part of the SCTP kernel implementation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * A collection class to handle the storage of transport addresses.
10 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050011 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * you can redistribute it and/or modify it under the terms of
13 * the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
15 * any later version.
16 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050017 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
19 * ************************
20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
21 * See the GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with GNU CC; see the file COPYING. If not, write to
25 * the Free Software Foundation, 59 Temple Place - Suite 330,
26 * Boston, MA 02111-1307, USA.
27 *
28 * Please send any bug reports or fixes you make to the
29 * email address(es):
30 * lksctp developers <lksctp-developers@lists.sourceforge.net>
31 *
32 * Or submit a bug report through the following website:
33 * http://www.sf.net/projects/lksctp
34 *
35 * Written or modified by:
36 * La Monte H.P. Yarroll <piggy@acm.org>
37 * Karl Knutson <karl@athena.chicago.il.us>
38 * Jon Grimm <jgrimm@us.ibm.com>
39 * Daisy Chang <daisyc@us.ibm.com>
40 *
41 * Any bugs reported given to us we will try to fix... any fixes shared will
42 * be incorporated into the next SCTP release.
43 */
44
45#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <linux/in.h>
47#include <net/sock.h>
48#include <net/ipv6.h>
49#include <net/if_inet6.h>
50#include <net/sctp/sctp.h>
51#include <net/sctp/sm.h>
52
53/* Forward declarations for internal helpers. */
54static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *,
Al Virodd0fc662005-10-07 07:46:04 +010055 sctp_scope_t scope, gfp_t gfp,
Alexey Dobriyan3182cd82005-07-11 20:57:47 -070056 int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static void sctp_bind_addr_clean(struct sctp_bind_addr *);
58
59/* First Level Abstractions. */
60
61/* Copy 'src' to 'dest' taking 'scope' into account. Omit addresses
62 * in 'src' which have a broader scope than 'scope'.
63 */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +090064int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 const struct sctp_bind_addr *src,
Al Virodd0fc662005-10-07 07:46:04 +010066 sctp_scope_t scope, gfp_t gfp,
Alexey Dobriyan3182cd82005-07-11 20:57:47 -070067 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
69 struct sctp_sockaddr_entry *addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 int error = 0;
71
72 /* All addresses share the same port. */
73 dest->port = src->port;
74
75 /* Extract the addresses which are relevant for this scope. */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -070076 list_for_each_entry(addr, &src->address_list, list) {
Al Viro02a8a4d2006-11-20 17:12:07 -080077 error = sctp_copy_one_addr(dest, &addr->a, scope,
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 gfp, flags);
79 if (error < 0)
80 goto out;
81 }
82
83 /* If there are no addresses matching the scope and
84 * this is global scope, try to get a link scope address, with
85 * the assumption that we must be sitting behind a NAT.
86 */
87 if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -070088 list_for_each_entry(addr, &src->address_list, list) {
Al Viro02a8a4d2006-11-20 17:12:07 -080089 error = sctp_copy_one_addr(dest, &addr->a,
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 SCTP_SCOPE_LINK, gfp,
91 flags);
92 if (error < 0)
93 goto out;
94 }
95 }
96
97out:
98 if (error)
99 sctp_bind_addr_clean(dest);
100
101 return error;
102}
103
Vlad Yasevich8e71a112007-12-06 22:50:54 -0800104/* Exactly duplicate the address lists. This is necessary when doing
105 * peer-offs and accepts. We don't want to put all the current system
106 * addresses into the endpoint. That's useless. But we do want duplicat
107 * the list of bound addresses that the older endpoint used.
108 */
109int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
110 const struct sctp_bind_addr *src,
111 gfp_t gfp)
112{
113 struct sctp_sockaddr_entry *addr;
Vlad Yasevich8e71a112007-12-06 22:50:54 -0800114 int error = 0;
115
116 /* All addresses share the same port. */
117 dest->port = src->port;
118
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700119 list_for_each_entry(addr, &src->address_list, list) {
Vlad Yasevich8e71a112007-12-06 22:50:54 -0800120 error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
121 if (error < 0)
122 break;
123 }
124
125 return error;
126}
127
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128/* Initialize the SCTP_bind_addr structure for either an endpoint or
129 * an association.
130 */
131void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
132{
133 bp->malloced = 0;
134
135 INIT_LIST_HEAD(&bp->address_list);
136 bp->port = port;
137}
138
139/* Dispose of the address list. */
140static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
141{
142 struct sctp_sockaddr_entry *addr;
143 struct list_head *pos, *temp;
144
145 /* Empty the bind address list. */
146 list_for_each_safe(pos, temp, &bp->address_list) {
147 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
148 list_del(pos);
149 kfree(addr);
150 SCTP_DBG_OBJCNT_DEC(addr);
151 }
152}
153
154/* Dispose of an SCTP_bind_addr structure */
155void sctp_bind_addr_free(struct sctp_bind_addr *bp)
156{
157 /* Empty the bind address list. */
158 sctp_bind_addr_clean(bp);
159
160 if (bp->malloced) {
161 kfree(bp);
162 SCTP_DBG_OBJCNT_DEC(bind_addr);
163 }
164}
165
166/* Add an address to the bind address list in the SCTP_bind_addr structure. */
167int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800168 __u8 addr_state, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
170 struct sctp_sockaddr_entry *addr;
171
172 /* Add the address to the bind address list. */
173 addr = t_new(struct sctp_sockaddr_entry, gfp);
174 if (!addr)
175 return -ENOMEM;
176
Al Viro5ab7b852006-11-20 17:10:38 -0800177 memcpy(&addr->a, new, sizeof(*new));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 /* Fix up the port if it has not yet been set.
180 * Both v4 and v6 have the port at the same offset.
181 */
Al Viro5ab7b852006-11-20 17:10:38 -0800182 if (!addr->a.v4.sin_port)
183 addr->a.v4.sin_port = htons(bp->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800185 addr->state = addr_state;
Vlad Yasevich29303542007-09-16 16:02:12 -0700186 addr->valid = 1;
Sridhar Samudraladc022a92006-07-21 14:49:25 -0700187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 INIT_LIST_HEAD(&addr->list);
Vlad Yasevich29303542007-09-16 16:02:12 -0700189 INIT_RCU_HEAD(&addr->rcu);
Vlad Yasevich559cf712007-09-16 16:03:28 -0700190
191 /* We always hold a socket lock when calling this function,
192 * and that acts as a writer synchronizing lock.
193 */
194 list_add_tail_rcu(&addr->list, &bp->address_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 SCTP_DBG_OBJCNT_INC(addr);
196
197 return 0;
198}
199
200/* Delete an address from the bind address list in the SCTP_bind_addr
201 * structure.
202 */
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -0400203int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Vlad Yasevich559cf712007-09-16 16:03:28 -0700205 struct sctp_sockaddr_entry *addr, *temp;
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700206 int found = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Vlad Yasevich559cf712007-09-16 16:03:28 -0700208 /* We hold the socket lock when calling this function,
209 * and that acts as a writer synchronizing lock.
210 */
211 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
Al Viroc9a08502006-11-20 17:07:48 -0800212 if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 /* Found the exact match. */
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700214 found = 1;
Vlad Yasevich559cf712007-09-16 16:03:28 -0700215 addr->valid = 0;
216 list_del_rcu(&addr->list);
217 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 }
219 }
220
Chidambar 'ilLogict' Zinnoury22626212008-03-11 18:05:02 -0700221 if (found) {
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -0400222 call_rcu(&addr->rcu, sctp_local_addr_free);
Vlad Yasevich559cf712007-09-16 16:03:28 -0700223 SCTP_DBG_OBJCNT_DEC(addr);
Vlad Yasevich0ed90fb2007-10-24 16:10:00 -0400224 return 0;
Vlad Yasevich559cf712007-09-16 16:03:28 -0700225 }
226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return -EINVAL;
228}
229
230/* Create a network byte-order representation of all the addresses
231 * formated as SCTP parameters.
232 *
233 * The second argument is the return value for the length.
234 */
235union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
Alexey Dobriyan3182cd82005-07-11 20:57:47 -0700236 int *addrs_len,
Al Virodd0fc662005-10-07 07:46:04 +0100237 gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238{
239 union sctp_params addrparms;
240 union sctp_params retval;
241 int addrparms_len;
242 union sctp_addr_param rawaddr;
243 int len;
244 struct sctp_sockaddr_entry *addr;
245 struct list_head *pos;
246 struct sctp_af *af;
247
248 addrparms_len = 0;
249 len = 0;
250
251 /* Allocate enough memory at once. */
252 list_for_each(pos, &bp->address_list) {
253 len += sizeof(union sctp_addr_param);
254 }
255
256 /* Don't even bother embedding an address if there
257 * is only one.
258 */
259 if (len == sizeof(union sctp_addr_param)) {
260 retval.v = NULL;
261 goto end_raw;
262 }
263
264 retval.v = kmalloc(len, gfp);
265 if (!retval.v)
266 goto end_raw;
267
268 addrparms = retval;
269
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700270 list_for_each_entry(addr, &bp->address_list, list) {
Al Viro6244be42006-11-20 17:21:44 -0800271 af = sctp_get_af_specific(addr->a.v4.sin_family);
272 len = af->to_addr_param(&addr->a, &rawaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 memcpy(addrparms.v, &rawaddr, len);
274 addrparms.v += len;
275 addrparms_len += len;
276 }
277
278end_raw:
279 *addrs_len = addrparms_len;
280 return retval;
281}
282
283/*
284 * Create an address list out of the raw address list format (IPv4 and IPv6
285 * address parameters).
286 */
287int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
Al Virodd0fc662005-10-07 07:46:04 +0100288 int addrs_len, __u16 port, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 union sctp_addr_param *rawaddr;
291 struct sctp_paramhdr *param;
292 union sctp_addr addr;
293 int retval = 0;
294 int len;
295 struct sctp_af *af;
296
297 /* Convert the raw address to standard address format */
298 while (addrs_len) {
299 param = (struct sctp_paramhdr *)raw_addr_list;
300 rawaddr = (union sctp_addr_param *)raw_addr_list;
301
302 af = sctp_get_af_specific(param_type2af(param->type));
303 if (unlikely(!af)) {
304 retval = -EINVAL;
305 sctp_bind_addr_clean(bp);
306 break;
307 }
308
Al Virodd86d132006-11-20 17:11:13 -0800309 af->from_addr_param(&addr, rawaddr, htons(port), 0);
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800310 retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 if (retval) {
312 /* Can't finish building the list, clean up. */
313 sctp_bind_addr_clean(bp);
314 break;
315 }
316
317 len = ntohs(param->length);
318 addrs_len -= len;
319 raw_addr_list += len;
320 }
321
322 return retval;
323}
324
325/********************************************************************
326 * 2nd Level Abstractions
327 ********************************************************************/
328
329/* Does this contain a specified address? Allow wildcarding. */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900330int sctp_bind_addr_match(struct sctp_bind_addr *bp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 const union sctp_addr *addr,
332 struct sctp_sock *opt)
333{
334 struct sctp_sockaddr_entry *laddr;
Vlad Yasevich559cf712007-09-16 16:03:28 -0700335 int match = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Vlad Yasevich559cf712007-09-16 16:03:28 -0700337 rcu_read_lock();
338 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
339 if (!laddr->valid)
340 continue;
341 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
342 match = 1;
343 break;
344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 }
Vlad Yasevich559cf712007-09-16 16:03:28 -0700346 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Vlad Yasevich559cf712007-09-16 16:03:28 -0700348 return match;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
Vlad Yasevich7dab83d2008-07-18 23:05:40 -0700351/* Does the address 'addr' conflict with any addresses in
352 * the bp.
353 */
354int sctp_bind_addr_conflict(struct sctp_bind_addr *bp,
355 const union sctp_addr *addr,
356 struct sctp_sock *bp_sp,
357 struct sctp_sock *addr_sp)
358{
359 struct sctp_sockaddr_entry *laddr;
360 int conflict = 0;
361 struct sctp_sock *sp;
362
363 /* Pick the IPv6 socket as the basis of comparison
364 * since it's usually a superset of the IPv4.
365 * If there is no IPv6 socket, then default to bind_addr.
366 */
367 if (sctp_opt2sk(bp_sp)->sk_family == AF_INET6)
368 sp = bp_sp;
369 else if (sctp_opt2sk(addr_sp)->sk_family == AF_INET6)
370 sp = addr_sp;
371 else
372 sp = bp_sp;
373
374 rcu_read_lock();
375 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
376 if (!laddr->valid)
377 continue;
378
379 conflict = sp->pf->cmp_addr(&laddr->a, addr, sp);
380 if (conflict)
381 break;
382 }
383 rcu_read_unlock();
384
385 return conflict;
386}
387
Vlad Yasevich75205f42007-12-20 14:12:59 -0800388/* Get the state of the entry in the bind_addr_list */
389int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
390 const union sctp_addr *addr)
391{
392 struct sctp_sockaddr_entry *laddr;
393 struct sctp_af *af;
394 int state = -1;
395
396 af = sctp_get_af_specific(addr->sa.sa_family);
397 if (unlikely(!af))
398 return state;
399
400 rcu_read_lock();
401 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
402 if (!laddr->valid)
403 continue;
404 if (af->cmp_addr(&laddr->a, addr)) {
405 state = laddr->state;
406 break;
407 }
408 }
409 rcu_read_unlock();
410
411 return state;
412}
413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414/* Find the first address in the bind address list that is not present in
415 * the addrs packed array.
416 */
417union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
418 const union sctp_addr *addrs,
419 int addrcnt,
420 struct sctp_sock *opt)
421{
422 struct sctp_sockaddr_entry *laddr;
423 union sctp_addr *addr;
424 void *addr_buf;
425 struct sctp_af *af;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 int i;
427
Vlad Yasevich559cf712007-09-16 16:03:28 -0700428 /* This is only called sctp_send_asconf_del_ip() and we hold
429 * the socket lock in that code patch, so that address list
430 * can't change.
431 */
432 list_for_each_entry(laddr, &bp->address_list, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 addr_buf = (union sctp_addr *)addrs;
434 for (i = 0; i < addrcnt; i++) {
435 addr = (union sctp_addr *)addr_buf;
436 af = sctp_get_af_specific(addr->v4.sin_family);
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900437 if (!af)
Vlad Yasevich559cf712007-09-16 16:03:28 -0700438 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Al Viro5f242a12006-11-20 17:05:23 -0800440 if (opt->pf->cmp_addr(&laddr->a, addr, opt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 break;
442
443 addr_buf += af->sockaddr_len;
444 }
445 if (i == addrcnt)
Al Viro5ae955c2006-11-20 17:22:08 -0800446 return &laddr->a;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 }
448
449 return NULL;
450}
451
452/* Copy out addresses from the global local address list. */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900453static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 union sctp_addr *addr,
Al Virodd0fc662005-10-07 07:46:04 +0100455 sctp_scope_t scope, gfp_t gfp,
Alexey Dobriyan3182cd82005-07-11 20:57:47 -0700456 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457{
458 int error = 0;
459
Vlad Yasevich52cae8f2008-08-18 10:34:34 -0400460 if (sctp_is_any(NULL, addr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
462 } else if (sctp_in_scope(addr, scope)) {
463 /* Now that the address is in scope, check to see if
464 * the address type is supported by local sock as
465 * well as the remote peer.
466 */
467 if ((((AF_INET == addr->sa.sa_family) &&
468 (flags & SCTP_ADDR4_PEERSUPP))) ||
469 (((AF_INET6 == addr->sa.sa_family) &&
470 (flags & SCTP_ADDR6_ALLOWED) &&
471 (flags & SCTP_ADDR6_PEERSUPP))))
Vlad Yasevichf57d96b2007-12-20 14:12:24 -0800472 error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
473 gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 }
475
476 return error;
477}
478
479/* Is this a wildcard address? */
Vlad Yasevich52cae8f2008-08-18 10:34:34 -0400480int sctp_is_any(struct sock *sk, const union sctp_addr *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
Vlad Yasevich52cae8f2008-08-18 10:34:34 -0400482 unsigned short fam = 0;
483 struct sctp_af *af;
484
485 /* Try to get the right address family */
486 if (addr->sa.sa_family != AF_UNSPEC)
487 fam = addr->sa.sa_family;
488 else if (sk)
489 fam = sk->sk_family;
490
491 af = sctp_get_af_specific(fam);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 if (!af)
493 return 0;
Vlad Yasevich52cae8f2008-08-18 10:34:34 -0400494
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return af->is_any(addr);
496}
497
498/* Is 'addr' valid for 'scope'? */
499int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
500{
501 sctp_scope_t addr_scope = sctp_scope(addr);
502
503 /* The unusable SCTP addresses will not be considered with
504 * any defined scopes.
505 */
506 if (SCTP_SCOPE_UNUSABLE == addr_scope)
507 return 0;
508 /*
509 * For INIT and INIT-ACK address list, let L be the level of
510 * of requested destination address, sender and receiver
511 * SHOULD include all of its addresses with level greater
512 * than or equal to L.
513 */
514 if (addr_scope <= scope)
515 return 1;
516
517 return 0;
518}
519
520/********************************************************************
521 * 3rd Level Abstractions
522 ********************************************************************/
523
524/* What is the scope of 'addr'? */
525sctp_scope_t sctp_scope(const union sctp_addr *addr)
526{
527 struct sctp_af *af;
528
529 af = sctp_get_af_specific(addr->sa.sa_family);
530 if (!af)
531 return SCTP_SCOPE_UNUSABLE;
532
533 return af->scope((union sctp_addr *)addr);
534}