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 struct list_head *pos;
71 int error = 0;
72
73
74 dest->port = src->port;
75
76
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
86
87
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
101out:
102 if (error)
103 sctp_bind_addr_clean(dest);
104
105 return error;
106}
107
108
109
110
111
112
113int 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
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
135
136
137void 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
146static 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
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
161void sctp_bind_addr_free(struct sctp_bind_addr *bp)
162{
163
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
173int sctp_add_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *new,
174 __u8 use_as_src, gfp_t gfp)
175{
176 struct sctp_sockaddr_entry *addr;
177
178
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
186
187
188 if (!addr->a.v4.sin_port)
189 addr->a.v4.sin_port = htons(bp->port);
190
191 addr->use_as_src = use_as_src;
192 addr->valid = 1;
193
194 INIT_LIST_HEAD(&addr->list);
195 INIT_RCU_HEAD(&addr->rcu);
196
197
198
199
200 list_add_tail_rcu(&addr->list, &bp->address_list);
201 SCTP_DBG_OBJCNT_INC(addr);
202
203 return 0;
204}
205
206
207
208
209int sctp_del_bind_addr(struct sctp_bind_addr *bp, union sctp_addr *del_addr)
210{
211 struct sctp_sockaddr_entry *addr, *temp;
212
213
214
215
216 list_for_each_entry_safe(addr, temp, &bp->address_list, list) {
217 if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
218
219 addr->valid = 0;
220 list_del_rcu(&addr->list);
221 break;
222 }
223 }
224
225 if (addr && !addr->valid) {
226 call_rcu(&addr->rcu, sctp_local_addr_free);
227 SCTP_DBG_OBJCNT_DEC(addr);
228 return 0;
229 }
230
231 return -EINVAL;
232}
233
234
235
236
237
238
239union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
240 int *addrs_len,
241 gfp_t gfp)
242{
243 union sctp_params addrparms;
244 union sctp_params retval;
245 int addrparms_len;
246 union sctp_addr_param rawaddr;
247 int len;
248 struct sctp_sockaddr_entry *addr;
249 struct list_head *pos;
250 struct sctp_af *af;
251
252 addrparms_len = 0;
253 len = 0;
254
255
256 list_for_each(pos, &bp->address_list) {
257 len += sizeof(union sctp_addr_param);
258 }
259
260
261
262
263 if (len == sizeof(union sctp_addr_param)) {
264 retval.v = NULL;
265 goto end_raw;
266 }
267
268 retval.v = kmalloc(len, gfp);
269 if (!retval.v)
270 goto end_raw;
271
272 addrparms = retval;
273
274 list_for_each(pos, &bp->address_list) {
275 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
276 af = sctp_get_af_specific(addr->a.v4.sin_family);
277 len = af->to_addr_param(&addr->a, &rawaddr);
278 memcpy(addrparms.v, &rawaddr, len);
279 addrparms.v += len;
280 addrparms_len += len;
281 }
282
283end_raw:
284 *addrs_len = addrparms_len;
285 return retval;
286}
287
288
289
290
291
292int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw_addr_list,
293 int addrs_len, __u16 port, gfp_t gfp)
294{
295 union sctp_addr_param *rawaddr;
296 struct sctp_paramhdr *param;
297 union sctp_addr addr;
298 int retval = 0;
299 int len;
300 struct sctp_af *af;
301
302
303 while (addrs_len) {
304 param = (struct sctp_paramhdr *)raw_addr_list;
305 rawaddr = (union sctp_addr_param *)raw_addr_list;
306
307 af = sctp_get_af_specific(param_type2af(param->type));
308 if (unlikely(!af)) {
309 retval = -EINVAL;
310 sctp_bind_addr_clean(bp);
311 break;
312 }
313
314 af->from_addr_param(&addr, rawaddr, htons(port), 0);
315 retval = sctp_add_bind_addr(bp, &addr, 1, gfp);
316 if (retval) {
317
318 sctp_bind_addr_clean(bp);
319 break;
320 }
321
322 len = ntohs(param->length);
323 addrs_len -= len;
324 raw_addr_list += len;
325 }
326
327 return retval;
328}
329
330
331
332
333
334
335int sctp_bind_addr_match(struct sctp_bind_addr *bp,
336 const union sctp_addr *addr,
337 struct sctp_sock *opt)
338{
339 struct sctp_sockaddr_entry *laddr;
340 int match = 0;
341
342 rcu_read_lock();
343 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
344 if (!laddr->valid)
345 continue;
346 if (opt->pf->cmp_addr(&laddr->a, addr, opt)) {
347 match = 1;
348 break;
349 }
350 }
351 rcu_read_unlock();
352
353 return match;
354}
355
356
357
358
359union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
360 const union sctp_addr *addrs,
361 int addrcnt,
362 struct sctp_sock *opt)
363{
364 struct sctp_sockaddr_entry *laddr;
365 union sctp_addr *addr;
366 void *addr_buf;
367 struct sctp_af *af;
368 int i;
369
370
371
372
373
374 list_for_each_entry(laddr, &bp->address_list, list) {
375 addr_buf = (union sctp_addr *)addrs;
376 for (i = 0; i < addrcnt; i++) {
377 addr = (union sctp_addr *)addr_buf;
378 af = sctp_get_af_specific(addr->v4.sin_family);
379 if (!af)
380 break;
381
382 if (opt->pf->cmp_addr(&laddr->a, addr, opt))
383 break;
384
385 addr_buf += af->sockaddr_len;
386 }
387 if (i == addrcnt)
388 return &laddr->a;
389 }
390
391 return NULL;
392}
393
394
395static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
396 union sctp_addr *addr,
397 sctp_scope_t scope, gfp_t gfp,
398 int flags)
399{
400 int error = 0;
401
402 if (sctp_is_any(addr)) {
403 error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
404 } else if (sctp_in_scope(addr, scope)) {
405
406
407
408
409 if ((((AF_INET == addr->sa.sa_family) &&
410 (flags & SCTP_ADDR4_PEERSUPP))) ||
411 (((AF_INET6 == addr->sa.sa_family) &&
412 (flags & SCTP_ADDR6_ALLOWED) &&
413 (flags & SCTP_ADDR6_PEERSUPP))))
414 error = sctp_add_bind_addr(dest, addr, 1, gfp);
415 }
416
417 return error;
418}
419
420
421int sctp_is_any(const union sctp_addr *addr)
422{
423 struct sctp_af *af = sctp_get_af_specific(addr->sa.sa_family);
424 if (!af)
425 return 0;
426 return af->is_any(addr);
427}
428
429
430int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
431{
432 sctp_scope_t addr_scope = sctp_scope(addr);
433
434
435
436
437 if (SCTP_SCOPE_UNUSABLE == addr_scope)
438 return 0;
439
440
441
442
443
444
445 if (addr_scope <= scope)
446 return 1;
447
448 return 0;
449}
450
451
452
453
454
455
456sctp_scope_t sctp_scope(const union sctp_addr *addr)
457{
458 struct sctp_af *af;
459
460 af = sctp_get_af_specific(addr->sa.sa_family);
461 if (!af)
462 return SCTP_SCOPE_UNUSABLE;
463
464 return af->scope((union sctp_addr *)addr);
465}
466