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/slab.h>
47#include <linux/in.h>
48#include <net/sock.h>
49#include <net/ipv6.h>
50#include <net/if_inet6.h>
51#include <net/sctp/sctp.h>
52#include <net/sctp/sm.h>
53
54
55static int sctp_copy_one_addr(struct net *, struct sctp_bind_addr *,
56 union sctp_addr *, sctp_scope_t scope, gfp_t gfp,
57 int flags);
58static void sctp_bind_addr_clean(struct sctp_bind_addr *);
59
60
61
62
63
64
65int sctp_bind_addr_copy(struct net *net, struct sctp_bind_addr *dest,
66 const struct sctp_bind_addr *src,
67 sctp_scope_t scope, gfp_t gfp,
68 int flags)
69{
70 struct sctp_sockaddr_entry *addr;
71 int error = 0;
72
73
74 dest->port = src->port;
75
76
77 list_for_each_entry(addr, &src->address_list, list) {
78 error = sctp_copy_one_addr(net, dest, &addr->a, scope,
79 gfp, flags);
80 if (error < 0)
81 goto out;
82 }
83
84
85
86
87
88 if (list_empty(&dest->address_list) && (SCTP_SCOPE_GLOBAL == scope)) {
89 list_for_each_entry(addr, &src->address_list, list) {
90 error = sctp_copy_one_addr(net, dest, &addr->a,
91 SCTP_SCOPE_LINK, gfp,
92 flags);
93 if (error < 0)
94 goto out;
95 }
96 }
97
98out:
99 if (error)
100 sctp_bind_addr_clean(dest);
101
102 return error;
103}
104
105
106
107
108
109
110int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
111 const struct sctp_bind_addr *src,
112 gfp_t gfp)
113{
114 struct sctp_sockaddr_entry *addr;
115 int error = 0;
116
117
118 dest->port = src->port;
119
120 list_for_each_entry(addr, &src->address_list, list) {
121 error = sctp_add_bind_addr(dest, &addr->a, 1, gfp);
122 if (error < 0)
123 break;
124 }
125
126 return error;
127}
128
129
130
131
132void sctp_bind_addr_init(struct sctp_bind_addr *bp, __u16 port)
133{
134 INIT_LIST_HEAD(&bp->address_list);
135 bp->port = port;
136}
137
138
139static void sctp_bind_addr_clean(struct sctp_bind_addr *bp)
140{
141 struct sctp_sockaddr_entry *addr, *temp;
142
143
144 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
145 list_del_rcu(&addr->list);
146 kfree_rcu(addr, rcu);
147 SCTP_DBG_OBJCNT_DEC(addr);
148 }
149}
150
151
152void sctp_bind_addr_free(struct sctp_bind_addr *bp)
153{
154
155 sctp_bind_addr_clean(bp);
156}
157
158
159int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
160 __u8 addr_state, gfp_t gfp)
161{
162 struct sctp_sockaddr_entry *addr;
163
164
165 addr = t_new(struct sctp_sockaddr_entry, gfp);
166 if (!addr)
167 return -ENOMEM;
168
169 memcpy(&addr->a, new, sizeof(*new));
170
171
172
173
174 if (!addr->a.v4.sin_port)
175 addr->a.v4.sin_port = htons(bp->port);
176
177 addr->state = addr_state;
178 addr->valid = 1;
179
180 INIT_LIST_HEAD(&addr->list);
181
182
183
184
185 list_add_tail_rcu(&addr->list, &bp->address_list);
186 SCTP_DBG_OBJCNT_INC(addr);
187
188 return 0;
189}
190
191
192
193
194int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
195{
196 struct sctp_sockaddr_entry *addr, *temp;
197 int found = 0;
198
199
200
201
202 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
203 if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
204
205 found = 1;
206 addr->valid = 0;
207 list_del_rcu(&addr->list);
208 break;
209 }
210 }
211
212 if (found) {
213 kfree_rcu(addr, rcu);
214 SCTP_DBG_OBJCNT_DEC(addr);
215 return 0;
216 }
217
218 return -EINVAL;
219}
220
221
222
223
224
225
226union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
227 int *addrs_len,
228 gfp_t gfp)
229{
230 union sctp_params addrparms;
231 union sctp_params retval;
232 int addrparms_len;
233 union sctp_addr_param rawaddr;
234 int len;
235 struct sctp_sockaddr_entry *addr;
236 struct list_head *pos;
237 struct sctp_af *af;
238
239 addrparms_len = 0;
240 len = 0;
241
242
243 list_for_each(pos, &bp->address_list) {
244 len += sizeof(union sctp_addr_param);
245 }
246
247
248
249
250 if (len == sizeof(union sctp_addr_param)) {
251 retval.v = NULL;
252 goto end_raw;
253 }
254
255 retval.v = kmalloc(len, gfp);
256 if (!retval.v)
257 goto end_raw;
258
259 addrparms = retval;
260
261 list_for_each_entry(addr, &bp->address_list, list) {
262 af = sctp_get_af_specific(addr->a.v4.sin_family);
263 len = af->to_addr_param(&addr->a, &rawaddr);
264 memcpy(addrparms.v, &rawaddr, len);
265 addrparms.v += len;
266 addrparms_len += len;
267 }
268
269end_raw:
270 *addrs_len = addrparms_len;
271 return retval;
272}
273
274
275
276
277
278int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
279 int addrs_len, __u16 port, gfp_t gfp)
280{
281 union sctp_addr_param *rawaddr;
282 struct sctp_paramhdr *param;
283 union sctp_addr addr;
284 int retval = 0;
285 int len;
286 struct sctp_af *af;
287
288
289 while (addrs_len) {
290 param = (struct sctp_paramhdr *)raw_addr_list;
291 rawaddr = (union sctp_addr_param *)raw_addr_list;
292
293 af = sctp_get_af_specific(param_type2af(param->type));
294 if (unlikely(!af)) {
295 retval = -EINVAL;
296 sctp_bind_addr_clean(bp);
297 break;
298 }
299
300 af->from_addr_param(&addr, rawaddr, htons(port), 0);
301 retval = sctp_add_bind_addr(bp, &addr, SCTP_ADDR_SRC, gfp);
302 if (retval) {
303
304 sctp_bind_addr_clean(bp);
305 break;
306 }
307
308 len = ntohs(param->length);
309 addrs_len -= len;
310 raw_addr_list += len;
311 }
312
313 return retval;
314}
315
316
317
318
319
320
321int sctp_bind_addr_match(struct sctp_bind_addr *bp,
322 const union sctp_addr *addr,
323 struct sctp_sock *opt)
324{
325 struct sctp_sockaddr_entry *laddr;
326 int match = 0;
327
328 rcu_read_lock();
329 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
330 if (!laddr->valid)
331 continue;
332 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
333 match = 1;
334 break;
335 }
336 }
337 rcu_read_unlock();
338
339 return match;
340}
341
342
343
344
345int sctp_bind_addr_conflict(struct sctp_bind_addr *bp,
346 const union sctp_addr *addr,
347 struct sctp_sock *bp_sp,
348 struct sctp_sock *addr_sp)
349{
350 struct sctp_sockaddr_entry *laddr;
351 int conflict = 0;
352 struct sctp_sock *sp;
353
354
355
356
357
358 if (sctp_opt2sk(bp_sp)->sk_family == AF_INET6)
359 sp = bp_sp;
360 else if (sctp_opt2sk(addr_sp)->sk_family == AF_INET6)
361 sp = addr_sp;
362 else
363 sp = bp_sp;
364
365 rcu_read_lock();
366 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
367 if (!laddr->valid)
368 continue;
369
370 conflict = sp->pf->cmp_addr(&laddr->a, addr, sp);
371 if (conflict)
372 break;
373 }
374 rcu_read_unlock();
375
376 return conflict;
377}
378
379
380int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
381 const union sctp_addr *addr)
382{
383 struct sctp_sockaddr_entry *laddr;
384 struct sctp_af *af;
385 int state = -1;
386
387 af = sctp_get_af_specific(addr->sa.sa_family);
388 if (unlikely(!af))
389 return state;
390
391 rcu_read_lock();
392 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
393 if (!laddr->valid)
394 continue;
395 if (af->cmp_addr(&laddr->a, addr)) {
396 state = laddr->state;
397 break;
398 }
399 }
400 rcu_read_unlock();
401
402 return state;
403}
404
405
406
407
408union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
409 const union sctp_addr *addrs,
410 int addrcnt,
411 struct sctp_sock *opt)
412{
413 struct sctp_sockaddr_entry *laddr;
414 union sctp_addr *addr;
415 void *addr_buf;
416 struct sctp_af *af;
417 int i;
418
419
420
421
422
423 list_for_each_entry(laddr, &bp->address_list, list) {
424 addr_buf = (union sctp_addr *)addrs;
425 for (i = 0; i < addrcnt; i++) {
426 addr = addr_buf;
427 af = sctp_get_af_specific(addr->v4.sin_family);
428 if (!af)
429 break;
430
431 if (opt->pf->cmp_addr(&laddr->a, addr, opt))
432 break;
433
434 addr_buf += af->sockaddr_len;
435 }
436 if (i == addrcnt)
437 return &laddr->a;
438 }
439
440 return NULL;
441}
442
443
444static int sctp_copy_one_addr(struct net *net, struct sctp_bind_addr *dest,
445 union sctp_addr *addr,
446 sctp_scope_t scope, gfp_t gfp,
447 int flags)
448{
449 int error = 0;
450
451 if (sctp_is_any(NULL, addr)) {
452 error = sctp_copy_local_addr_list(net, dest, scope, gfp, flags);
453 } else if (sctp_in_scope(net, addr, scope)) {
454
455
456
457
458 if ((((AF_INET == addr->sa.sa_family) &&
459 (flags & SCTP_ADDR4_PEERSUPP))) ||
460 (((AF_INET6 == addr->sa.sa_family) &&
461 (flags & SCTP_ADDR6_ALLOWED) &&
462 (flags & SCTP_ADDR6_PEERSUPP))))
463 error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
464 gfp);
465 }
466
467 return error;
468}
469
470
471int sctp_is_any(struct sock *sk, const union sctp_addr *addr)
472{
473 unsigned short fam = 0;
474 struct sctp_af *af;
475
476
477 if (addr->sa.sa_family != AF_UNSPEC)
478 fam = addr->sa.sa_family;
479 else if (sk)
480 fam = sk->sk_family;
481
482 af = sctp_get_af_specific(fam);
483 if (!af)
484 return 0;
485
486 return af->is_any(addr);
487}
488
489
490int sctp_in_scope(struct net *net, const union sctp_addr *addr, sctp_scope_t scope)
491{
492 sctp_scope_t addr_scope = sctp_scope(addr);
493
494
495
496
497 if (SCTP_SCOPE_UNUSABLE == addr_scope)
498 return 0;
499
500
501
502
503
504
505
506
507
508 switch (net->sctp.scope_policy) {
509 case SCTP_SCOPE_POLICY_DISABLE:
510 return 1;
511 case SCTP_SCOPE_POLICY_ENABLE:
512 if (addr_scope <= scope)
513 return 1;
514 break;
515 case SCTP_SCOPE_POLICY_PRIVATE:
516 if (addr_scope <= scope || SCTP_SCOPE_PRIVATE == addr_scope)
517 return 1;
518 break;
519 case SCTP_SCOPE_POLICY_LINK:
520 if (addr_scope <= scope || SCTP_SCOPE_LINK == addr_scope)
521 return 1;
522 break;
523 default:
524 break;
525 }
526
527 return 0;
528}
529
530int sctp_is_ep_boundall(struct sock *sk)
531{
532 struct sctp_bind_addr *bp;
533 struct sctp_sockaddr_entry *addr;
534
535 bp = &sctp_sk(sk)->ep->base.bind_addr;
536 if (sctp_list_single_entry(&bp->address_list)) {
537 addr = list_entry(bp->address_list.next,
538 struct sctp_sockaddr_entry, list);
539 if (sctp_is_any(sk, &addr->a))
540 return 1;
541 }
542 return 0;
543}
544
545
546
547
548
549
550sctp_scope_t sctp_scope(const union sctp_addr *addr)
551{
552 struct sctp_af *af;
553
554 af = sctp_get_af_specific(addr->sa.sa_family);
555 if (!af)
556 return SCTP_SCOPE_UNUSABLE;
557
558 return af->scope((union sctp_addr *)addr);
559}
560