1 /* SCTP kernel implementation
2 * (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 *
7 * This file is part of the SCTP kernel implementation.
8 *
9 * A collection class to handle the storage of transport addresses.
10 *
11 * This SCTP implementation is free software;
12 * 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 *
17 * This SCTP implementation is distributed in the hope that it
18 * 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>
46 #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. */
54 static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *,
55 sctp_scope_t scope, gfp_t gfp,
56 int flags);
57 static 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 */
64 int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
65 const struct sctp_bind_addr *src,
66 sctp_scope_t scope, gfp_t gfp,
67 int flags)
68 {
69 struct sctp_sockaddr_entry *addr;
70 struct list_head *pos;
71 int error = 0;
72
73 /* All addresses share the same port. */
74 dest->port = src->port;
75
76 /* Extract the addresses which are relevant for this scope. */
77 list_for_each(pos, &src->address_list) {
78 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
79 error = sctp_copy_one_addr(dest, &addr->a, scope,
80 gfp, flags);
81 if (error < 0)
82 goto out;
83 }
84
85 /* If there are no addresses matching the scope and
86 * this is global scope, try to get a link scope address, with
87 * the assumption that we must be sitting behind a NAT.
88 */
89 if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
90 list_for_each(pos, &src->address_list) {
91 addr = list_entry(pos, struct sctp_sockaddr_entry,
92 list);
93 error = sctp_copy_one_addr(dest, &addr->a,
94 SCTP_SCOPE_LINK, gfp,
95 flags);
96 if (error < 0)
97 goto out;
98 }
99 }
100
101 out:
102 if (error)
103 sctp_bind_addr_clean(dest);
104
105 return error;
106 }
107
108 /* Exactly duplicate the address lists. This is necessary when doing
109 * peer-offs and accepts. We don't want to put all the current system
110 * addresses into the endpoint. That's useless. But we do want duplicat
111 * the list of bound addresses that the older endpoint used.
112 */
113 int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
114 const struct sctp_bind_addr *src,
115 gfp_t gfp)
116 {
117 struct sctp_sockaddr_entry *addr;
118 struct list_head *pos;
119 int error = 0;
120
121 /* All addresses share the same port. */
122 dest->port = src->port;
123
124 list_for_each(pos, &src->address_list) {
125 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
126 error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
127 if (error < 0)
128 break;
129 }
130
131 return error;
132 }
133
134 /* Initialize the SCTP_bind_addr structure for either an endpoint or
135 * an association.
136 */
137 void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
138 {
139 bp->malloced = 0;
140
141 INIT_LIST_HEAD(&bp->address_list);
142 bp->port = port;
143 }
144
145 /* Dispose of the address list. */
146 static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
147 {
148 struct sctp_sockaddr_entry *addr;
149 struct list_head *pos, *temp;
150
151 /* Empty the bind address list. */
152 list_for_each_safe(pos, temp, &bp->address_list) {
153 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
154 list_del(pos);
155 kfree(addr);
156 SCTP_DBG_OBJCNT_DEC(addr);
157 }
158 }
159
160 /* Dispose of an SCTP_bind_addr structure */
161 void sctp_bind_addr_free(struct sctp_bind_addr *bp)
162 {
163 /* Empty the bind address list. */
164 sctp_bind_addr_clean(bp);
165
166 if (bp->malloced) {
167 kfree(bp);
168 SCTP_DBG_OBJCNT_DEC(bind_addr);
169 }
170 }
171
172 /* Add an address to the bind address list in the SCTP_bind_addr structure. */
173 int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
174 __u8 addr_state, gfp_t gfp)
175 {
176 struct sctp_sockaddr_entry *addr;
177
178 /* Add the address to the bind address list. */
179 addr = t_new(struct sctp_sockaddr_entry, gfp);
180 if (!addr)
181 return -ENOMEM;
182
183 memcpy(&addr->a, new, sizeof(*new));
184
185 /* Fix up the port if it has not yet been set.
186 * Both v4 and v6 have the port at the same offset.
187 */
188 if (!addr->a.v4.sin_port)
189 addr->a.v4.sin_port = htons(bp->port);
190
191 addr->state = addr_state;
192 addr->valid = 1;
193
194 INIT_LIST_HEAD(&addr->list);
195 INIT_RCU_HEAD(&addr->rcu);
196
197 /* We always hold a socket lock when calling this function,
198 * and that acts as a writer synchronizing lock.
199 */
200 list_add_tail_rcu(&addr->list, &bp->address_list);
201 SCTP_DBG_OBJCNT_INC(addr);
202
203 return 0;
204 }
205
206 /* Delete an address from the bind address list in the SCTP_bind_addr
207 * structure.
208 */
209 int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
210 {
211 struct sctp_sockaddr_entry *addr, *temp;
212 int found = 0;
213
214 /* We hold the socket lock when calling this function,
215 * and that acts as a writer synchronizing lock.
216 */
217 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
218 if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
219 /* Found the exact match. */
220 found = 1;
221 addr->valid = 0;
222 list_del_rcu(&addr->list);
223 break;
224 }
225 }
226
227 if (found) {
228 call_rcu(&addr->rcu, sctp_local_addr_free);
229 SCTP_DBG_OBJCNT_DEC(addr);
230 return 0;
231 }
232
233 return -EINVAL;
234 }
235
236 /* Create a network byte-order representation of all the addresses
237 * formated as SCTP parameters.
238 *
239 * The second argument is the return value for the length.
240 */
241 union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
242 int *addrs_len,
243 gfp_t gfp)
244 {
245 union sctp_params addrparms;
246 union sctp_params retval;
247 int addrparms_len;
248 union sctp_addr_param rawaddr;
249 int len;
250 struct sctp_sockaddr_entry *addr;
251 struct list_head *pos;
252 struct sctp_af *af;
253
254 addrparms_len = 0;
255 len = 0;
256
257 /* Allocate enough memory at once. */
258 list_for_each(pos, &bp->address_list) {
259 len += sizeof(union sctp_addr_param);
260 }
261
262 /* Don't even bother embedding an address if there
263 * is only one.
264 */
265 if (len == sizeof(union sctp_addr_param)) {
266 retval.v = NULL;
267 goto end_raw;
268 }
269
270 retval.v = kmalloc(len, gfp);
271 if (!retval.v)
272 goto end_raw;
273
274 addrparms = retval;
275
276 list_for_each(pos, &bp->address_list) {
277 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
278 af = sctp_get_af_specific(addr->a.v4.sin_family);
279 len = af->to_addr_param(&addr->a, &rawaddr);
280 memcpy(addrparms.v, &rawaddr, len);
281 addrparms.v += len;
282 addrparms_len += len;
283 }
284
285 end_raw:
286 *addrs_len = addrparms_len;
287 return retval;
288 }
289
290 /*
291 * Create an address list out of the raw address list format (IPv4 and IPv6
292 * address parameters).
293 */
294 int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
295 int addrs_len, __u16 port, gfp_t gfp)
296 {
297 union sctp_addr_param *rawaddr;
298 struct sctp_paramhdr *param;
299 union sctp_addr addr;
300 int retval = 0;
301 int len;
302 struct sctp_af *af;
303
304 /* Convert the raw address to standard address format */
305 while (addrs_len) {
306 param = (struct sctp_paramhdr *)raw_addr_list;
307 rawaddr = (union sctp_addr_param *)raw_addr_list;
308
309 af = sctp_get_af_specific(param_type2af(param->type));
310 if (unlikely(!af)) {
311 retval = -EINVAL;
312 sctp_bind_addr_clean(bp);
313 break;
314 }
315
316 af->from_addr_param(&addr, rawaddr, htons(port), 0);
317 retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
318 if (retval) {
319 /* Can't finish building the list, clean up. */
320 sctp_bind_addr_clean(bp);
321 break;
322 }
323
324 len = ntohs(param->length);
325 addrs_len -= len;
326 raw_addr_list += len;
327 }
328
329 return retval;
330 }
331
332 /********************************************************************
333 * 2nd Level Abstractions
334 ********************************************************************/
335
336 /* Does this contain a specified address? Allow wildcarding. */
337 int sctp_bind_addr_match(struct sctp_bind_addr *bp,
338 const union sctp_addr *addr,
339 struct sctp_sock *opt)
340 {
341 struct sctp_sockaddr_entry *laddr;
342 int match = 0;
343
344 rcu_read_lock();
345 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
346 if (!laddr->valid)
347 continue;
348 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
349 match = 1;
350 break;
351 }
352 }
353 rcu_read_unlock();
354
355 return match;
356 }
357
358 /* Get the state of the entry in the bind_addr_list */
359 int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
360 const union sctp_addr *addr)
361 {
362 struct sctp_sockaddr_entry *laddr;
363 struct sctp_af *af;
364 int state = -1;
365
366 af = sctp_get_af_specific(addr->sa.sa_family);
367 if (unlikely(!af))
368 return state;
369
370 rcu_read_lock();
371 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
372 if (!laddr->valid)
373 continue;
374 if (af->cmp_addr(&laddr->a, addr)) {
375 state = laddr->state;
376 break;
377 }
378 }
379 rcu_read_unlock();
380
381 return state;
382 }
383
384 /* Find the first address in the bind address list that is not present in
385 * the addrs packed array.
386 */
387 union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
388 const union sctp_addr *addrs,
389 int addrcnt,
390 struct sctp_sock *opt)
391 {
392 struct sctp_sockaddr_entry *laddr;
393 union sctp_addr *addr;
394 void *addr_buf;
395 struct sctp_af *af;
396 int i;
397
398 /* This is only called sctp_send_asconf_del_ip() and we hold
399 * the socket lock in that code patch, so that address list
400 * can't change.
401 */
402 list_for_each_entry(laddr, &bp->address_list, list) {
403 addr_buf = (union sctp_addr *)addrs;
404 for (i = 0; i < addrcnt; i++) {
405 addr = (union sctp_addr *)addr_buf;
406 af = sctp_get_af_specific(addr->v4.sin_family);
407 if (!af)
408 break;
409
410 if (opt->pf->cmp_addr(&laddr->a, addr, opt))
411 break;
412
413 addr_buf += af->sockaddr_len;
414 }
415 if (i == addrcnt)
416 return &laddr->a;
417 }
418
419 return NULL;
420 }
421
422 /* Copy out addresses from the global local address list. */
423 static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
424 union sctp_addr *addr,
425 sctp_scope_t scope, gfp_t gfp,
426 int flags)
427 {
428 int error = 0;
429
430 if (sctp_is_any(addr)) {
431 error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
432 } else if (sctp_in_scope(addr, scope)) {
433 /* Now that the address is in scope, check to see if
434 * the address type is supported by local sock as
435 * well as the remote peer.
436 */
437 if ((((AF_INET == addr->sa.sa_family) &&
438 (flags & SCTP_ADDR4_PEERSUPP))) ||
439 (((AF_INET6 == addr->sa.sa_family) &&
440 (flags & SCTP_ADDR6_ALLOWED) &&
441 (flags & SCTP_ADDR6_PEERSUPP))))
442 error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
443 gfp);
444 }
445
446 return error;
447 }
448
449 /* Is this a wildcard address? */
450 int sctp_is_any(const union sctp_addr *addr)
451 {
452 struct sctp_af *af = sctp_get_af_specific(addr->sa.sa_family);
453 if (!af)
454 return 0;
455 return af->is_any(addr);
456 }
457
458 /* Is 'addr' valid for 'scope'? */
459 int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
460 {
461 sctp_scope_t addr_scope = sctp_scope(addr);
462
463 /* The unusable SCTP addresses will not be considered with
464 * any defined scopes.
465 */
466 if (SCTP_SCOPE_UNUSABLE == addr_scope)
467 return 0;
468 /*
469 * For INIT and INIT-ACK address list, let L be the level of
470 * of requested destination address, sender and receiver
471 * SHOULD include all of its addresses with level greater
472 * than or equal to L.
473 */
474 if (addr_scope <= scope)
475 return 1;
476
477 return 0;
478 }
479
480 /********************************************************************
481 * 3rd Level Abstractions
482 ********************************************************************/
483
484 /* What is the scope of 'addr'? */
485 sctp_scope_t sctp_scope(const union sctp_addr *addr)
486 {
487 struct sctp_af *af;
488
489 af = sctp_get_af_specific(addr->sa.sa_family);
490 if (!af)
491 return SCTP_SCOPE_UNUSABLE;
492
493 return af->scope((union sctp_addr *)addr);
494 }
495
|
This page was automatically generated by the
LXR engine.
|