1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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#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
54static int sctp_copy_one_addr(struct sctp_bind_addr *, union sctp_addr *,
55 sctp_scope_t scope, gfp_t gfp,
56 int flags);
57static void sctp_bind_addr_clean(struct sctp_bind_addr *);
58
59
60
61
62
63
64int 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 int error = 0;
71
72
73 dest->port = src->port;
74
75
76 list_for_each_entry(addr, &src->address_list, list) {
77 error = sctp_copy_one_addr(dest, &addr->a, scope,
78 gfp, flags);
79 if (error < 0)
80 goto out;
81 }
82
83
84
85
86
87 if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
88 list_for_each_entry(addr, &src->address_list, list) {
89 error = sctp_copy_one_addr(dest, &addr->a,
90 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
104
105
106
107
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;
114 int error = 0;
115
116
117 dest->port = src->port;
118
119 list_for_each_entry(addr, &src->address_list, list) {
120 error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
121 if (error < 0)
122 break;
123 }
124
125 return error;
126}
127
128
129
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
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
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
155void sctp_bind_addr_free(struct sctp_bind_addr *bp)
156{
157
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
167int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
168 __u8 addr_state, gfp_t gfp)
169{
170 struct sctp_sockaddr_entry *addr;
171
172
173 addr = t_new(struct sctp_sockaddr_entry, gfp);
174 if (!addr)
175 return -ENOMEM;
176
177 memcpy(&addr->a, new, sizeof(*new));
178
179
180
181
182 if (!addr->a.v4.sin_port)
183 addr->a.v4.sin_port = htons(bp->port);
184
185 addr->state = addr_state;
186 addr->valid = 1;
187
188 INIT_LIST_HEAD(&addr->list);
189 INIT_RCU_HEAD(&addr->rcu);
190
191
192
193
194 list_add_tail_rcu(&addr->list, &bp->address_list);
195 SCTP_DBG_OBJCNT_INC(addr);
196
197 return 0;
198}
199
200
201
202
203int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
204{
205 struct sctp_sockaddr_entry *addr, *temp;
206 int found = 0;
207
208
209
210
211 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
212 if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
213
214 found = 1;
215 addr->valid = 0;
216 list_del_rcu(&addr->list);
217 break;
218 }
219 }
220
221 if (found) {
222 call_rcu(&addr->rcu, sctp_local_addr_free);
223 SCTP_DBG_OBJCNT_DEC(addr);
224 return 0;
225 }
226
227 return -EINVAL;
228}
229
230
231
232
233
234
235union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
236 int *addrs_len,
237 gfp_t gfp)
238{
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
252 list_for_each(pos, &bp->address_list) {
253 len += sizeof(union sctp_addr_param);
254 }
255
256
257
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
270 list_for_each_entry(addr, &bp->address_list, list) {
271 af = sctp_get_af_specific(addr->a.v4.sin_family);
272 len = af->to_addr_param(&addr->a, &rawaddr);
273 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
285
286
287int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
288 int addrs_len, __u16 port, gfp_t gfp)
289{
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
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
309 af->from_addr_param(&addr, rawaddr, htons(port), 0);
310 retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
311 if (retval) {
312
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
327
328
329
330int sctp_bind_addr_match(struct sctp_bind_addr *bp,
331 const union sctp_addr *addr,
332 struct sctp_sock *opt)
333{
334 struct sctp_sockaddr_entry *laddr;
335 int match = 0;
336
337 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 }
345 }
346 rcu_read_unlock();
347
348 return match;
349}
350
351
352
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
364
365
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
388
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
414
415
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;
426 int i;
427
428
429
430
431
432 list_for_each_entry(laddr, &bp->address_list, list) {
433 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);
437 if (!af)
438 break;
439
440 if (opt->pf->cmp_addr(&laddr->a, addr, opt))
441 break;
442
443 addr_buf += af->sockaddr_len;
444 }
445 if (i == addrcnt)
446 return &laddr->a;
447 }
448
449 return NULL;
450}
451
452
453static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
454 union sctp_addr *addr,
455 sctp_scope_t scope, gfp_t gfp,
456 int flags)
457{
458 int error = 0;
459
460 if (sctp_is_any(NULL, addr)) {
461 error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
462 } else if (sctp_in_scope(addr, scope)) {
463
464
465
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))))
472 error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
473 gfp);
474 }
475
476 return error;
477}
478
479
480int sctp_is_any(struct sock *sk, const union sctp_addr *addr)
481{
482 unsigned short fam = 0;
483 struct sctp_af *af;
484
485
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);
492 if (!af)
493 return 0;
494
495 return af->is_any(addr);
496}
497
498
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
504
505
506 if (SCTP_SCOPE_UNUSABLE == addr_scope)
507 return 0;
508
509
510
511
512
513
514
515
516
517 switch (sctp_scope_policy) {
518 case SCTP_SCOPE_POLICY_DISABLE:
519 return 1;
520 case SCTP_SCOPE_POLICY_ENABLE:
521 if (addr_scope <= scope)
522 return 1;
523 break;
524 case SCTP_SCOPE_POLICY_PRIVATE:
525 if (addr_scope <= scope || SCTP_SCOPE_PRIVATE == addr_scope)
526 return 1;
527 break;
528 case SCTP_SCOPE_POLICY_LINK:
529 if (addr_scope <= scope || SCTP_SCOPE_LINK == addr_scope)
530 return 1;
531 break;
532 default:
533 break;
534 }
535
536 return 0;
537}
538
539
540
541
542
543
544sctp_scope_t sctp_scope(const union sctp_addr *addr)
545{
546 struct sctp_af *af;
547
548 af = sctp_get_af_specific(addr->sa.sa_family);
549 if (!af)
550 return SCTP_SCOPE_UNUSABLE;
551
552 return af->scope((union sctp_addr *)addr);
553}
554