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.10 2007/08/16 20:03:58 dillon 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, M_WAITOK); 66 bzero(sid, sizeof(*sid)); 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 } 372