For kmalloc(), MALLOC() and contigmalloc(), use M_ZERO instead of
[dragonfly.git] / sys / netinet6 / scope6.c
1 /*      $FreeBSD: src/sys/netinet6/scope6.c,v 1.1.2.3 2002/04/01 15:29:04 ume Exp $     */
2 /*      $DragonFly: src/sys/netinet6/scope6.c,v 1.11 2008/01/05 14:02:40 swildner Exp $ */
3 /*      $KAME: scope6.c,v 1.10 2000/07/24 13:29:31 itojun Exp $ */
4
5 /*
6  * Copyright (C) 2000 WIDE Project.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. Neither the name of the project nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include <sys/param.h>
35 #include <sys/malloc.h>
36 #include <sys/mbuf.h>
37 #include <sys/socket.h>
38 #include <sys/systm.h>
39 #include <sys/queue.h>
40 #include <sys/thread2.h>
41
42 #include <net/route.h>
43 #include <net/if.h>
44
45 #include <netinet/in.h>
46
47 #include <netinet6/in6_var.h>
48 #include <netinet6/scope6_var.h>
49
50 static struct scope6_id sid_default;
51 #define SID(ifp) \
52         (((struct in6_ifextra *)(ifp)->if_afdata[AF_INET6])->scope6_id)
53
54 void
55 scope6_init(void)
56 {
57         bzero(&sid_default, sizeof(sid_default));
58 }
59
60 struct scope6_id *
61 scope6_ifattach(struct ifnet *ifp)
62 {
63         struct scope6_id *sid;
64
65         sid = (struct scope6_id *)kmalloc(sizeof(*sid), M_IFADDR,
66             M_WAITOK | M_ZERO);
67
68         crit_enter();
69
70         /*
71          * XXX: IPV6_ADDR_SCOPE_xxx macros are not standard.
72          * Should we rather hardcode here?
73          */
74         sid->s6id_list[IPV6_ADDR_SCOPE_NODELOCAL] = ifp->if_index;
75         sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = ifp->if_index;
76 #ifdef MULTI_SCOPE
77         /* by default, we don't care about scope boundary for these scopes. */
78         sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL] = 1;
79         sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL] = 1;
80 #endif
81
82         crit_exit();
83         return sid;
84 }
85
86 void
87 scope6_ifdetach(struct scope6_id *sid)
88 {
89         kfree(sid, M_IFADDR);
90 }
91
92 int
93 scope6_set(struct ifnet *ifp, struct scope6_id *idlist)
94 {
95         int i;
96         int error = 0;
97         struct scope6_id *sid = SID(ifp);
98
99         if (!sid)       /* paranoid? */
100                 return (EINVAL);
101
102         /*
103          * XXX: We need more consistency checks of the relationship among
104          * scopes (e.g. an organization should be larger than a site).
105          */
106
107         /*
108          * TODO(XXX): after setting, we should reflect the changes to
109          * interface addresses, routing table entries, PCB entries...
110          */
111
112         crit_enter();
113
114         for (i = 0; i < 16; i++) {
115                 if (idlist->s6id_list[i] &&
116                     idlist->s6id_list[i] != sid->s6id_list[i]) {
117                         if (i == IPV6_ADDR_SCOPE_LINKLOCAL &&
118                             idlist->s6id_list[i] > if_index) {
119                                 /*
120                                  * XXX: theoretically, there should be no
121                                  * relationship between link IDs and interface
122                                  * IDs, but we check the consistency for
123                                  * safety in later use.
124                                  */
125                                 crit_exit();
126                                 return (EINVAL);
127                         }
128
129                         /*
130                          * XXX: we must need lots of work in this case,
131                          * but we simply set the new value in this initial
132                          * implementation.
133                          */
134                         sid->s6id_list[i] = idlist->s6id_list[i];
135                 }
136         }
137         crit_exit();
138
139         return (error);
140 }
141
142 int
143 scope6_get(struct ifnet *ifp, struct scope6_id *idlist)
144 {
145         struct scope6_id *sid = SID(ifp);
146
147         if (sid == NULL)        /* paranoid? */
148                 return (EINVAL);
149
150         *idlist = *sid;
151
152         return (0);
153 }
154
155
156 /*
157  * Get a scope of the address. Node-local, link-local, site-local or global.
158  */
159 int
160 in6_addrscope(struct in6_addr *addr)
161 {
162         int scope;
163
164         if (addr->s6_addr8[0] == 0xfe) {
165                 scope = addr->s6_addr8[1] & 0xc0;
166
167                 switch (scope) {
168                 case 0x80:
169                         return IPV6_ADDR_SCOPE_LINKLOCAL;
170                         break;
171                 case 0xc0:
172                         return IPV6_ADDR_SCOPE_SITELOCAL;
173                         break;
174                 default:
175                         return IPV6_ADDR_SCOPE_GLOBAL; /* just in case */
176                         break;
177                 }
178         }
179
180
181         if (addr->s6_addr8[0] == 0xff) {
182                 scope = addr->s6_addr8[1] & 0x0f;
183
184                 /*
185                  * due to other scope such as reserved,
186                  * return scope doesn't work.
187                  */
188                 switch (scope) {
189                 case IPV6_ADDR_SCOPE_NODELOCAL:
190                         return IPV6_ADDR_SCOPE_NODELOCAL;
191                         break;
192                 case IPV6_ADDR_SCOPE_LINKLOCAL:
193                         return IPV6_ADDR_SCOPE_LINKLOCAL;
194                         break;
195                 case IPV6_ADDR_SCOPE_SITELOCAL:
196                         return IPV6_ADDR_SCOPE_SITELOCAL;
197                         break;
198                 default:
199                         return IPV6_ADDR_SCOPE_GLOBAL;
200                         break;
201                 }
202         }
203
204         if (bcmp(&kin6addr_loopback, addr, sizeof(*addr) - 1) == 0) {
205                 if (addr->s6_addr8[15] == 1) /* loopback */
206                         return IPV6_ADDR_SCOPE_NODELOCAL;
207                 if (addr->s6_addr8[15] == 0) /* unspecified */
208                         return IPV6_ADDR_SCOPE_LINKLOCAL;
209         }
210
211         return IPV6_ADDR_SCOPE_GLOBAL;
212 }
213
214 int
215 in6_addr2scopeid(struct ifnet *ifp,     /* must not be NULL */
216                  struct in6_addr *addr) /* must not be NULL */
217 {
218         int scope;
219         struct scope6_id *sid = SID(ifp);
220
221 #ifdef DIAGNOSTIC
222         if (sid == NULL) { /* should not happen */
223                 panic("in6_addr2zoneid: scope array is NULL");
224                 /* NOTREACHED */
225         }
226 #endif
227
228         /*
229          * special case: the loopback address can only belong to a loopback
230          * interface.
231          */
232         if (IN6_IS_ADDR_LOOPBACK(addr)) {
233                 if (!(ifp->if_flags & IFF_LOOPBACK))
234                         return (-1);
235                 else
236                         return (0); /* there's no ambiguity */
237         }
238
239         scope = in6_addrscope(addr);
240
241         switch(scope) {
242         case IPV6_ADDR_SCOPE_NODELOCAL:
243                 return (-1);    /* XXX: is this an appropriate value? */
244
245         case IPV6_ADDR_SCOPE_LINKLOCAL:
246                 return (sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL]);
247
248         case IPV6_ADDR_SCOPE_SITELOCAL:
249                 return (sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL]);
250
251         case IPV6_ADDR_SCOPE_ORGLOCAL:
252                 return (sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL]);
253
254         default:
255                 return (0);     /* XXX: treat as global. */
256         }
257 }
258
259 void
260 scope6_setdefault(struct ifnet *ifp)    /* note that this might be NULL */
261 {
262         /*
263          * Currently, this function just set the default "interfaces"
264          * and "links" according to the given interface.
265          * We might eventually have to separate the notion of "link" from
266          * "interface" and provide a user interface to set the default.
267          */
268         if (ifp) {
269                 sid_default.s6id_list[IPV6_ADDR_SCOPE_NODELOCAL] =
270                         ifp->if_index;
271                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] =
272                         ifp->if_index;
273         } else {
274                 sid_default.s6id_list[IPV6_ADDR_SCOPE_NODELOCAL] = 0;
275                 sid_default.s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL] = 0;
276         }
277 }
278
279 int
280 scope6_get_default(struct scope6_id *idlist)
281 {
282         *idlist = sid_default;
283
284         return (0);
285 }
286
287 u_int32_t
288 scope6_addr2default(struct in6_addr *addr)
289 {
290         /*
291          * special case: The loopback address should be considered as
292          * link-local, but there's no ambiguity in the syntax.
293          */
294         if (IN6_IS_ADDR_LOOPBACK(addr))
295                 return (0);
296
297         return (sid_default.s6id_list[in6_addrscope(addr)]);
298 }
299
300 /*
301  * Determine the appropriate scope zone ID for in6 and ifp.  If ret_id is
302  * non NULL, it is set to the zone ID.  If the zone ID needs to be embedded
303   * in the in6_addr structure, in6 will be modified.
304  */
305 int
306 in6_setscope(struct in6_addr *in6, struct ifnet *ifp, u_int32_t *ret_id)
307 {
308         int scope;
309         u_int32_t zoneid = 0;
310         struct scope6_id *sid;
311
312         lwkt_serialize_enter(ifp->if_serializer);
313
314         sid = SID(ifp);
315
316 #ifdef DIAGNOSTIC
317         if (sid == NULL) { /* should not happen */
318                 panic("in6_setscope: scope array is NULL");
319                 /* NOTREACHED */
320         }
321 #endif
322
323         /*
324          * special case: the loopback address can only belong to a loopback
325          * interface.
326          */
327         if (IN6_IS_ADDR_LOOPBACK(in6)) {
328                 if (!(ifp->if_flags & IFF_LOOPBACK)) {
329                         lwkt_serialize_exit(ifp->if_serializer);
330                         return (EINVAL);
331                 } else {
332                         if (ret_id != NULL)
333                                 *ret_id = 0; /* there's no ambiguity */
334                         lwkt_serialize_exit(ifp->if_serializer);
335                         return (0);
336                 }
337         }
338
339         scope = in6_addrscope(in6);
340
341         switch (scope) {
342         case IPV6_ADDR_SCOPE_NODELOCAL: /* should be interface index */
343                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_NODELOCAL];
344                 break;
345
346         case IPV6_ADDR_SCOPE_LINKLOCAL:
347                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_LINKLOCAL];
348                 break;
349
350         case IPV6_ADDR_SCOPE_SITELOCAL:
351                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_SITELOCAL];
352                 break;
353
354         case IPV6_ADDR_SCOPE_ORGLOCAL:
355                 zoneid = sid->s6id_list[IPV6_ADDR_SCOPE_ORGLOCAL];
356                 break;
357
358         default:
359                 zoneid = 0;     /* XXX: treat as global. */
360                 break;
361         }
362         lwkt_serialize_exit(ifp->if_serializer);
363
364         if (ret_id != NULL)
365                 *ret_id = zoneid;
366
367         if (IN6_IS_SCOPE_LINKLOCAL(in6) || IN6_IS_ADDR_MC_NODELOCAL(in6) )
368                 in6->s6_addr16[1] = htons(zoneid & 0xffff); /* XXX */
369
370         return (0);
371 }