xref: /openbmc/linux/net/sctp/bind_addr.c (revision f42b3800)
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 	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.  */
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 	/* 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)) {
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 
97 out:
98 	if (error)
99 		sctp_bind_addr_clean(dest);
100 
101 	return error;
102 }
103 
104 /* 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  */
109 int 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 	/* All addresses share the same port.  */
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 /* Initialize the SCTP_bind_addr structure for either an endpoint or
129  * an association.
130  */
131 void 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. */
140 static 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  */
155 void 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. */
167 int 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 	/* Add the address to the bind address list.  */
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 	/* Fix up the port if it has not yet been set.
180 	 * Both v4 and v6 have the port at the same offset.
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 	/* 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);
195 	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  */
203 int 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 	/* 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) {
212 		if (sctp_cmp_addr_exact(&addr->a, del_addr)) {
213 			/* Found the exact match. */
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 /* 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  */
235 union 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 	/* 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 
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 
278 end_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  */
287 int 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 	/* 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 
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 			/* 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. */
330 int 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 /* Get the state of the entry in the bind_addr_list */
352 int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
353 			 const union sctp_addr *addr)
354 {
355 	struct sctp_sockaddr_entry *laddr;
356 	struct sctp_af *af;
357 	int state = -1;
358 
359 	af = sctp_get_af_specific(addr->sa.sa_family);
360 	if (unlikely(!af))
361 		return state;
362 
363 	rcu_read_lock();
364 	list_for_each_entry_rcu(laddr, &bp->address_list, list) {
365 		if (!laddr->valid)
366 			continue;
367 		if (af->cmp_addr(&laddr->a, addr)) {
368 			state = laddr->state;
369 			break;
370 		}
371 	}
372 	rcu_read_unlock();
373 
374 	return state;
375 }
376 
377 /* Find the first address in the bind address list that is not present in
378  * the addrs packed array.
379  */
380 union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr	*bp,
381 					const union sctp_addr	*addrs,
382 					int			addrcnt,
383 					struct sctp_sock	*opt)
384 {
385 	struct sctp_sockaddr_entry	*laddr;
386 	union sctp_addr			*addr;
387 	void 				*addr_buf;
388 	struct sctp_af			*af;
389 	int				i;
390 
391 	/* This is only called sctp_send_asconf_del_ip() and we hold
392 	 * the socket lock in that code patch, so that address list
393 	 * can't change.
394 	 */
395 	list_for_each_entry(laddr, &bp->address_list, list) {
396 		addr_buf = (union sctp_addr *)addrs;
397 		for (i = 0; i < addrcnt; i++) {
398 			addr = (union sctp_addr *)addr_buf;
399 			af = sctp_get_af_specific(addr->v4.sin_family);
400 			if (!af)
401 				break;
402 
403 			if (opt->pf->cmp_addr(&laddr->a, addr, opt))
404 				break;
405 
406 			addr_buf += af->sockaddr_len;
407 		}
408 		if (i == addrcnt)
409 			return &laddr->a;
410 	}
411 
412 	return NULL;
413 }
414 
415 /* Copy out addresses from the global local address list. */
416 static int sctp_copy_one_addr(struct sctp_bind_addr *dest,
417 			      union sctp_addr *addr,
418 			      sctp_scope_t scope, gfp_t gfp,
419 			      int flags)
420 {
421 	int error = 0;
422 
423 	if (sctp_is_any(addr)) {
424 		error = sctp_copy_local_addr_list(dest, scope, gfp, flags);
425 	} else if (sctp_in_scope(addr, scope)) {
426 		/* Now that the address is in scope, check to see if
427 		 * the address type is supported by local sock as
428 		 * well as the remote peer.
429 		 */
430 		if ((((AF_INET == addr->sa.sa_family) &&
431 		      (flags & SCTP_ADDR4_PEERSUPP))) ||
432 		    (((AF_INET6 == addr->sa.sa_family) &&
433 		      (flags & SCTP_ADDR6_ALLOWED) &&
434 		      (flags & SCTP_ADDR6_PEERSUPP))))
435 			error = sctp_add_bind_addr(dest, addr, SCTP_ADDR_SRC,
436 						    gfp);
437 	}
438 
439 	return error;
440 }
441 
442 /* Is this a wildcard address?  */
443 int sctp_is_any(const union sctp_addr *addr)
444 {
445 	struct sctp_af *af = sctp_get_af_specific(addr->sa.sa_family);
446 	if (!af)
447 		return 0;
448 	return af->is_any(addr);
449 }
450 
451 /* Is 'addr' valid for 'scope'?  */
452 int sctp_in_scope(const union sctp_addr *addr, sctp_scope_t scope)
453 {
454 	sctp_scope_t addr_scope = sctp_scope(addr);
455 
456 	/* The unusable SCTP addresses will not be considered with
457 	 * any defined scopes.
458 	 */
459 	if (SCTP_SCOPE_UNUSABLE == addr_scope)
460 		return 0;
461 	/*
462 	 * For INIT and INIT-ACK address list, let L be the level of
463 	 * of requested destination address, sender and receiver
464 	 * SHOULD include all of its addresses with level greater
465 	 * than or equal to L.
466 	 */
467 	if (addr_scope <= scope)
468 		return 1;
469 
470 	return 0;
471 }
472 
473 /********************************************************************
474  * 3rd Level Abstractions
475  ********************************************************************/
476 
477 /* What is the scope of 'addr'?  */
478 sctp_scope_t sctp_scope(const union sctp_addr *addr)
479 {
480 	struct sctp_af *af;
481 
482 	af = sctp_get_af_specific(addr->sa.sa_family);
483 	if (!af)
484 		return SCTP_SCOPE_UNUSABLE;
485 
486 	return af->scope((union sctp_addr *)addr);
487 }
488