2 * IPv6 Address Label subsystem
3 * for the IPv6 "Default" Source Address Selection
5 * Copyright (C)2007 USAGI/WIDE Project
9 * YOSHIFUJI Hideaki @ USAGI/WIDE Project <yoshfuji@linux-ipv6.org>
12 #include <linux/kernel.h>
13 #include <linux/list.h>
14 #include <linux/rcupdate.h>
15 #include <linux/in6.h>
16 #include <linux/slab.h>
17 #include <net/addrconf.h>
18 #include <linux/if_addrlabel.h>
19 #include <linux/netlink.h>
20 #include <linux/rtnetlink.h>
23 #define ADDRLABEL(x...) printk(x)
25 #define ADDRLABEL(x...) do { ; } while(0)
31 struct ip6addrlbl_entry
36 struct in6_addr prefix
;
41 struct hlist_node list
;
46 static struct ip6addrlbl_table
48 struct hlist_head head
;
54 struct net
*ip6addrlbl_net(const struct ip6addrlbl_entry
*lbl
)
56 return read_pnet(&lbl
->lbl_net
);
60 * Default policy table (RFC6724 + extensions)
62 * prefix addr_type label
63 * -------------------------------------------------------------------------
68 * ::ffff:0:0/96 V4MAPPED 4
69 * fc00::/7 N/A 5 ULA (RFC 4193)
70 * 2001::/32 N/A 6 Teredo (RFC 4380)
71 * 2001:10::/28 N/A 7 ORCHID (RFC 4843)
72 * fec0::/10 N/A 11 Site-local
73 * (deprecated by RFC3879)
74 * 3ffe::/16 N/A 12 6bone
76 * Note: 0xffffffff is used if we do not have any policies.
77 * Note: Labels for ULA and 6to4 are different from labels listed in RFC6724.
80 #define IPV6_ADDR_LABEL_DEFAULT 0xffffffffUL
82 static const __net_initconst
struct ip6addrlbl_init_table
84 const struct in6_addr
*prefix
;
87 } ip6addrlbl_init_table
[] = {
89 .prefix
= &in6addr_any
,
92 .prefix
= &(struct in6_addr
){{{ 0xfc }}},
96 .prefix
= &(struct in6_addr
){{{ 0xfe, 0xc0 }}},
100 .prefix
= &(struct in6_addr
){{{ 0x20, 0x02 }}},
104 .prefix
= &(struct in6_addr
){{{ 0x3f, 0xfe }}},
108 .prefix
= &(struct in6_addr
){{{ 0x20, 0x01 }}},
111 },{ /* 2001:10::/28 */
112 .prefix
= &(struct in6_addr
){{{ 0x20, 0x01, 0x00, 0x10 }}},
116 .prefix
= &(struct in6_addr
){{{ [10] = 0xff, [11] = 0xff }}},
120 .prefix
= &in6addr_any
,
124 .prefix
= &in6addr_loopback
,
130 /* Object management */
131 static inline void ip6addrlbl_free(struct ip6addrlbl_entry
*p
)
134 release_net(p
->lbl_net
);
139 static void ip6addrlbl_free_rcu(struct rcu_head
*h
)
141 ip6addrlbl_free(container_of(h
, struct ip6addrlbl_entry
, rcu
));
144 static bool ip6addrlbl_hold(struct ip6addrlbl_entry
*p
)
146 return atomic_inc_not_zero(&p
->refcnt
);
149 static inline void ip6addrlbl_put(struct ip6addrlbl_entry
*p
)
151 if (atomic_dec_and_test(&p
->refcnt
))
152 call_rcu(&p
->rcu
, ip6addrlbl_free_rcu
);
156 static bool __ip6addrlbl_match(struct net
*net
,
157 const struct ip6addrlbl_entry
*p
,
158 const struct in6_addr
*addr
,
159 int addrtype
, int ifindex
)
161 if (!net_eq(ip6addrlbl_net(p
), net
))
163 if (p
->ifindex
&& p
->ifindex
!= ifindex
)
165 if (p
->addrtype
&& p
->addrtype
!= addrtype
)
167 if (!ipv6_prefix_equal(addr
, &p
->prefix
, p
->prefixlen
))
172 static struct ip6addrlbl_entry
*__ipv6_addr_label(struct net
*net
,
173 const struct in6_addr
*addr
,
174 int type
, int ifindex
)
176 struct hlist_node
*pos
;
177 struct ip6addrlbl_entry
*p
;
178 hlist_for_each_entry_rcu(p
, pos
, &ip6addrlbl_table
.head
, list
) {
179 if (__ip6addrlbl_match(net
, p
, addr
, type
, ifindex
))
185 u32
ipv6_addr_label(struct net
*net
,
186 const struct in6_addr
*addr
, int type
, int ifindex
)
189 struct ip6addrlbl_entry
*p
;
191 type
&= IPV6_ADDR_MAPPED
| IPV6_ADDR_COMPATv4
| IPV6_ADDR_LOOPBACK
;
194 p
= __ipv6_addr_label(net
, addr
, type
, ifindex
);
195 label
= p
? p
->label
: IPV6_ADDR_LABEL_DEFAULT
;
198 ADDRLABEL(KERN_DEBUG
"%s(addr=%pI6, type=%d, ifindex=%d) => %08x\n",
199 __func__
, addr
, type
, ifindex
, label
);
204 /* allocate one entry */
205 static struct ip6addrlbl_entry
*ip6addrlbl_alloc(struct net
*net
,
206 const struct in6_addr
*prefix
,
207 int prefixlen
, int ifindex
,
210 struct ip6addrlbl_entry
*newp
;
213 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u)\n",
214 __func__
, prefix
, prefixlen
, ifindex
, (unsigned int)label
);
216 addrtype
= ipv6_addr_type(prefix
) & (IPV6_ADDR_MAPPED
| IPV6_ADDR_COMPATv4
| IPV6_ADDR_LOOPBACK
);
219 case IPV6_ADDR_MAPPED
:
221 return ERR_PTR(-EINVAL
);
225 case IPV6_ADDR_COMPATv4
:
229 case IPV6_ADDR_LOOPBACK
:
230 if (prefixlen
!= 128)
235 newp
= kmalloc(sizeof(*newp
), GFP_KERNEL
);
237 return ERR_PTR(-ENOMEM
);
239 ipv6_addr_prefix(&newp
->prefix
, prefix
, prefixlen
);
240 newp
->prefixlen
= prefixlen
;
241 newp
->ifindex
= ifindex
;
242 newp
->addrtype
= addrtype
;
244 INIT_HLIST_NODE(&newp
->list
);
246 newp
->lbl_net
= hold_net(net
);
248 atomic_set(&newp
->refcnt
, 1);
253 static int __ip6addrlbl_add(struct ip6addrlbl_entry
*newp
, int replace
)
257 ADDRLABEL(KERN_DEBUG
"%s(newp=%p, replace=%d)\n",
261 if (hlist_empty(&ip6addrlbl_table
.head
)) {
262 hlist_add_head_rcu(&newp
->list
, &ip6addrlbl_table
.head
);
264 struct hlist_node
*pos
, *n
;
265 struct ip6addrlbl_entry
*p
= NULL
;
266 hlist_for_each_entry_safe(p
, pos
, n
,
267 &ip6addrlbl_table
.head
, list
) {
268 if (p
->prefixlen
== newp
->prefixlen
&&
269 net_eq(ip6addrlbl_net(p
), ip6addrlbl_net(newp
)) &&
270 p
->ifindex
== newp
->ifindex
&&
271 ipv6_addr_equal(&p
->prefix
, &newp
->prefix
)) {
276 hlist_replace_rcu(&p
->list
, &newp
->list
);
279 } else if ((p
->prefixlen
== newp
->prefixlen
&& !p
->ifindex
) ||
280 (p
->prefixlen
< newp
->prefixlen
)) {
281 hlist_add_before_rcu(&newp
->list
, &p
->list
);
285 hlist_add_after_rcu(&p
->list
, &newp
->list
);
289 ip6addrlbl_table
.seq
++;
294 static int ip6addrlbl_add(struct net
*net
,
295 const struct in6_addr
*prefix
, int prefixlen
,
296 int ifindex
, u32 label
, int replace
)
298 struct ip6addrlbl_entry
*newp
;
301 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u, replace=%d)\n",
302 __func__
, prefix
, prefixlen
, ifindex
, (unsigned int)label
,
305 newp
= ip6addrlbl_alloc(net
, prefix
, prefixlen
, ifindex
, label
);
307 return PTR_ERR(newp
);
308 spin_lock(&ip6addrlbl_table
.lock
);
309 ret
= __ip6addrlbl_add(newp
, replace
);
310 spin_unlock(&ip6addrlbl_table
.lock
);
312 ip6addrlbl_free(newp
);
317 static int __ip6addrlbl_del(struct net
*net
,
318 const struct in6_addr
*prefix
, int prefixlen
,
321 struct ip6addrlbl_entry
*p
= NULL
;
322 struct hlist_node
*pos
, *n
;
325 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d)\n",
326 __func__
, prefix
, prefixlen
, ifindex
);
328 hlist_for_each_entry_safe(p
, pos
, n
, &ip6addrlbl_table
.head
, list
) {
329 if (p
->prefixlen
== prefixlen
&&
330 net_eq(ip6addrlbl_net(p
), net
) &&
331 p
->ifindex
== ifindex
&&
332 ipv6_addr_equal(&p
->prefix
, prefix
)) {
333 hlist_del_rcu(&p
->list
);
342 static int ip6addrlbl_del(struct net
*net
,
343 const struct in6_addr
*prefix
, int prefixlen
,
346 struct in6_addr prefix_buf
;
349 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d)\n",
350 __func__
, prefix
, prefixlen
, ifindex
);
352 ipv6_addr_prefix(&prefix_buf
, prefix
, prefixlen
);
353 spin_lock(&ip6addrlbl_table
.lock
);
354 ret
= __ip6addrlbl_del(net
, &prefix_buf
, prefixlen
, ifindex
);
355 spin_unlock(&ip6addrlbl_table
.lock
);
359 /* add default label */
360 static int __net_init
ip6addrlbl_net_init(struct net
*net
)
365 ADDRLABEL(KERN_DEBUG
"%s\n", __func__
);
367 for (i
= 0; i
< ARRAY_SIZE(ip6addrlbl_init_table
); i
++) {
368 int ret
= ip6addrlbl_add(net
,
369 ip6addrlbl_init_table
[i
].prefix
,
370 ip6addrlbl_init_table
[i
].prefixlen
,
372 ip6addrlbl_init_table
[i
].label
, 0);
373 /* XXX: should we free all rules when we catch an error? */
374 if (ret
&& (!err
|| err
!= -ENOMEM
))
380 static void __net_exit
ip6addrlbl_net_exit(struct net
*net
)
382 struct ip6addrlbl_entry
*p
= NULL
;
383 struct hlist_node
*pos
, *n
;
385 /* Remove all labels belonging to the exiting net */
386 spin_lock(&ip6addrlbl_table
.lock
);
387 hlist_for_each_entry_safe(p
, pos
, n
, &ip6addrlbl_table
.head
, list
) {
388 if (net_eq(ip6addrlbl_net(p
), net
)) {
389 hlist_del_rcu(&p
->list
);
393 spin_unlock(&ip6addrlbl_table
.lock
);
396 static struct pernet_operations ipv6_addr_label_ops
= {
397 .init
= ip6addrlbl_net_init
,
398 .exit
= ip6addrlbl_net_exit
,
401 int __init
ipv6_addr_label_init(void)
403 spin_lock_init(&ip6addrlbl_table
.lock
);
405 return register_pernet_subsys(&ipv6_addr_label_ops
);
408 void ipv6_addr_label_cleanup(void)
410 unregister_pernet_subsys(&ipv6_addr_label_ops
);
413 static const struct nla_policy ifal_policy
[IFAL_MAX
+1] = {
414 [IFAL_ADDRESS
] = { .len
= sizeof(struct in6_addr
), },
415 [IFAL_LABEL
] = { .len
= sizeof(u32
), },
418 static int ip6addrlbl_newdel(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
421 struct net
*net
= sock_net(skb
->sk
);
422 struct ifaddrlblmsg
*ifal
;
423 struct nlattr
*tb
[IFAL_MAX
+1];
424 struct in6_addr
*pfx
;
428 err
= nlmsg_parse(nlh
, sizeof(*ifal
), tb
, IFAL_MAX
, ifal_policy
);
432 ifal
= nlmsg_data(nlh
);
434 if (ifal
->ifal_family
!= AF_INET6
||
435 ifal
->ifal_prefixlen
> 128)
438 if (!tb
[IFAL_ADDRESS
])
441 pfx
= nla_data(tb
[IFAL_ADDRESS
]);
447 label
= nla_get_u32(tb
[IFAL_LABEL
]);
448 if (label
== IPV6_ADDR_LABEL_DEFAULT
)
451 switch(nlh
->nlmsg_type
) {
452 case RTM_NEWADDRLABEL
:
453 if (ifal
->ifal_index
&&
454 !__dev_get_by_index(net
, ifal
->ifal_index
))
457 err
= ip6addrlbl_add(net
, pfx
, ifal
->ifal_prefixlen
,
458 ifal
->ifal_index
, label
,
459 nlh
->nlmsg_flags
& NLM_F_REPLACE
);
461 case RTM_DELADDRLABEL
:
462 err
= ip6addrlbl_del(net
, pfx
, ifal
->ifal_prefixlen
,
471 static void ip6addrlbl_putmsg(struct nlmsghdr
*nlh
,
472 int prefixlen
, int ifindex
, u32 lseq
)
474 struct ifaddrlblmsg
*ifal
= nlmsg_data(nlh
);
475 ifal
->ifal_family
= AF_INET6
;
476 ifal
->ifal_prefixlen
= prefixlen
;
477 ifal
->ifal_flags
= 0;
478 ifal
->ifal_index
= ifindex
;
479 ifal
->ifal_seq
= lseq
;
482 static int ip6addrlbl_fill(struct sk_buff
*skb
,
483 struct ip6addrlbl_entry
*p
,
485 u32 portid
, u32 seq
, int event
,
488 struct nlmsghdr
*nlh
= nlmsg_put(skb
, portid
, seq
, event
,
489 sizeof(struct ifaddrlblmsg
), flags
);
493 ip6addrlbl_putmsg(nlh
, p
->prefixlen
, p
->ifindex
, lseq
);
495 if (nla_put(skb
, IFAL_ADDRESS
, 16, &p
->prefix
) < 0 ||
496 nla_put_u32(skb
, IFAL_LABEL
, p
->label
) < 0) {
497 nlmsg_cancel(skb
, nlh
);
501 return nlmsg_end(skb
, nlh
);
504 static int ip6addrlbl_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
506 struct net
*net
= sock_net(skb
->sk
);
507 struct ip6addrlbl_entry
*p
;
508 struct hlist_node
*pos
;
509 int idx
= 0, s_idx
= cb
->args
[0];
513 hlist_for_each_entry_rcu(p
, pos
, &ip6addrlbl_table
.head
, list
) {
515 net_eq(ip6addrlbl_net(p
), net
)) {
516 if ((err
= ip6addrlbl_fill(skb
, p
,
517 ip6addrlbl_table
.seq
,
518 NETLINK_CB(cb
->skb
).portid
,
531 static inline int ip6addrlbl_msgsize(void)
533 return NLMSG_ALIGN(sizeof(struct ifaddrlblmsg
))
534 + nla_total_size(16) /* IFAL_ADDRESS */
535 + nla_total_size(4); /* IFAL_LABEL */
538 static int ip6addrlbl_get(struct sk_buff
*in_skb
, struct nlmsghdr
* nlh
,
541 struct net
*net
= sock_net(in_skb
->sk
);
542 struct ifaddrlblmsg
*ifal
;
543 struct nlattr
*tb
[IFAL_MAX
+1];
544 struct in6_addr
*addr
;
547 struct ip6addrlbl_entry
*p
;
550 err
= nlmsg_parse(nlh
, sizeof(*ifal
), tb
, IFAL_MAX
, ifal_policy
);
554 ifal
= nlmsg_data(nlh
);
556 if (ifal
->ifal_family
!= AF_INET6
||
557 ifal
->ifal_prefixlen
!= 128)
560 if (ifal
->ifal_index
&&
561 !__dev_get_by_index(net
, ifal
->ifal_index
))
564 if (!tb
[IFAL_ADDRESS
])
567 addr
= nla_data(tb
[IFAL_ADDRESS
]);
572 p
= __ipv6_addr_label(net
, addr
, ipv6_addr_type(addr
), ifal
->ifal_index
);
573 if (p
&& ip6addrlbl_hold(p
))
575 lseq
= ip6addrlbl_table
.seq
;
583 if (!(skb
= nlmsg_new(ip6addrlbl_msgsize(), GFP_KERNEL
))) {
588 err
= ip6addrlbl_fill(skb
, p
, lseq
,
589 NETLINK_CB(in_skb
).portid
, nlh
->nlmsg_seq
,
590 RTM_NEWADDRLABEL
, 0);
595 WARN_ON(err
== -EMSGSIZE
);
600 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
605 void __init
ipv6_addr_label_rtnl_register(void)
607 __rtnl_register(PF_INET6
, RTM_NEWADDRLABEL
, ip6addrlbl_newdel
,
609 __rtnl_register(PF_INET6
, RTM_DELADDRLABEL
, ip6addrlbl_newdel
,
611 __rtnl_register(PF_INET6
, RTM_GETADDRLABEL
, ip6addrlbl_get
,
612 ip6addrlbl_dump
, NULL
);