1 // SPDX-License-Identifier: GPL-2.0
3 * IPv6 Address Label subsystem
4 * for the IPv6 "Default" Source Address Selection
6 * Copyright (C)2007 USAGI/WIDE Project
10 * YOSHIFUJI Hideaki @ USAGI/WIDE Project <yoshfuji@linux-ipv6.org>
13 #include <linux/kernel.h>
14 #include <linux/list.h>
15 #include <linux/rcupdate.h>
16 #include <linux/in6.h>
17 #include <linux/slab.h>
18 #include <net/addrconf.h>
19 #include <linux/if_addrlabel.h>
20 #include <linux/netlink.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/refcount.h>
25 #define ADDRLABEL(x...) printk(x)
27 #define ADDRLABEL(x...) do { ; } while (0)
33 struct ip6addrlbl_entry
{
34 possible_net_t lbl_net
;
35 struct in6_addr prefix
;
40 struct hlist_node list
;
45 static struct ip6addrlbl_table
47 struct hlist_head head
;
53 struct net
*ip6addrlbl_net(const struct ip6addrlbl_entry
*lbl
)
55 return read_pnet(&lbl
->lbl_net
);
59 * Default policy table (RFC6724 + extensions)
61 * prefix addr_type label
62 * -------------------------------------------------------------------------
67 * ::ffff:0:0/96 V4MAPPED 4
68 * fc00::/7 N/A 5 ULA (RFC 4193)
69 * 2001::/32 N/A 6 Teredo (RFC 4380)
70 * 2001:10::/28 N/A 7 ORCHID (RFC 4843)
71 * fec0::/10 N/A 11 Site-local
72 * (deprecated by RFC3879)
73 * 3ffe::/16 N/A 12 6bone
75 * Note: 0xffffffff is used if we do not have any policies.
76 * Note: Labels for ULA and 6to4 are different from labels listed in RFC6724.
79 #define IPV6_ADDR_LABEL_DEFAULT 0xffffffffUL
81 static const __net_initconst
struct ip6addrlbl_init_table
83 const struct in6_addr
*prefix
;
86 } ip6addrlbl_init_table
[] = {
88 .prefix
= &in6addr_any
,
91 .prefix
= &(struct in6_addr
){ { { 0xfc } } } ,
95 .prefix
= &(struct in6_addr
){ { { 0xfe, 0xc0 } } },
99 .prefix
= &(struct in6_addr
){ { { 0x20, 0x02 } } },
103 .prefix
= &(struct in6_addr
){ { { 0x3f, 0xfe } } },
107 .prefix
= &(struct in6_addr
){ { { 0x20, 0x01 } } },
110 }, { /* 2001:10::/28 */
111 .prefix
= &(struct in6_addr
){ { { 0x20, 0x01, 0x00, 0x10 } } },
114 }, { /* ::ffff:0:0 */
115 .prefix
= &(struct in6_addr
){ { { [10] = 0xff, [11] = 0xff } } },
119 .prefix
= &in6addr_any
,
123 .prefix
= &in6addr_loopback
,
129 /* Object management */
130 static inline void ip6addrlbl_free(struct ip6addrlbl_entry
*p
)
135 static void ip6addrlbl_free_rcu(struct rcu_head
*h
)
137 ip6addrlbl_free(container_of(h
, struct ip6addrlbl_entry
, rcu
));
140 static bool ip6addrlbl_hold(struct ip6addrlbl_entry
*p
)
142 return refcount_inc_not_zero(&p
->refcnt
);
145 static inline void ip6addrlbl_put(struct ip6addrlbl_entry
*p
)
147 if (refcount_dec_and_test(&p
->refcnt
))
148 call_rcu(&p
->rcu
, ip6addrlbl_free_rcu
);
152 static bool __ip6addrlbl_match(struct net
*net
,
153 const struct ip6addrlbl_entry
*p
,
154 const struct in6_addr
*addr
,
155 int addrtype
, int ifindex
)
157 if (!net_eq(ip6addrlbl_net(p
), net
))
159 if (p
->ifindex
&& p
->ifindex
!= ifindex
)
161 if (p
->addrtype
&& p
->addrtype
!= addrtype
)
163 if (!ipv6_prefix_equal(addr
, &p
->prefix
, p
->prefixlen
))
168 static struct ip6addrlbl_entry
*__ipv6_addr_label(struct net
*net
,
169 const struct in6_addr
*addr
,
170 int type
, int ifindex
)
172 struct ip6addrlbl_entry
*p
;
173 hlist_for_each_entry_rcu(p
, &ip6addrlbl_table
.head
, list
) {
174 if (__ip6addrlbl_match(net
, p
, addr
, type
, ifindex
))
180 u32
ipv6_addr_label(struct net
*net
,
181 const struct in6_addr
*addr
, int type
, int ifindex
)
184 struct ip6addrlbl_entry
*p
;
186 type
&= IPV6_ADDR_MAPPED
| IPV6_ADDR_COMPATv4
| IPV6_ADDR_LOOPBACK
;
189 p
= __ipv6_addr_label(net
, addr
, type
, ifindex
);
190 label
= p
? p
->label
: IPV6_ADDR_LABEL_DEFAULT
;
193 ADDRLABEL(KERN_DEBUG
"%s(addr=%pI6, type=%d, ifindex=%d) => %08x\n",
194 __func__
, addr
, type
, ifindex
, label
);
199 /* allocate one entry */
200 static struct ip6addrlbl_entry
*ip6addrlbl_alloc(struct net
*net
,
201 const struct in6_addr
*prefix
,
202 int prefixlen
, int ifindex
,
205 struct ip6addrlbl_entry
*newp
;
208 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u)\n",
209 __func__
, prefix
, prefixlen
, ifindex
, (unsigned int)label
);
211 addrtype
= ipv6_addr_type(prefix
) & (IPV6_ADDR_MAPPED
| IPV6_ADDR_COMPATv4
| IPV6_ADDR_LOOPBACK
);
214 case IPV6_ADDR_MAPPED
:
216 return ERR_PTR(-EINVAL
);
220 case IPV6_ADDR_COMPATv4
:
224 case IPV6_ADDR_LOOPBACK
:
225 if (prefixlen
!= 128)
230 newp
= kmalloc(sizeof(*newp
), GFP_KERNEL
);
232 return ERR_PTR(-ENOMEM
);
234 ipv6_addr_prefix(&newp
->prefix
, prefix
, prefixlen
);
235 newp
->prefixlen
= prefixlen
;
236 newp
->ifindex
= ifindex
;
237 newp
->addrtype
= addrtype
;
239 INIT_HLIST_NODE(&newp
->list
);
240 write_pnet(&newp
->lbl_net
, net
);
241 refcount_set(&newp
->refcnt
, 1);
246 static int __ip6addrlbl_add(struct ip6addrlbl_entry
*newp
, int replace
)
248 struct hlist_node
*n
;
249 struct ip6addrlbl_entry
*last
= NULL
, *p
= NULL
;
252 ADDRLABEL(KERN_DEBUG
"%s(newp=%p, replace=%d)\n", __func__
, newp
,
255 hlist_for_each_entry_safe(p
, n
, &ip6addrlbl_table
.head
, list
) {
256 if (p
->prefixlen
== newp
->prefixlen
&&
257 net_eq(ip6addrlbl_net(p
), ip6addrlbl_net(newp
)) &&
258 p
->ifindex
== newp
->ifindex
&&
259 ipv6_addr_equal(&p
->prefix
, &newp
->prefix
)) {
264 hlist_replace_rcu(&p
->list
, &newp
->list
);
267 } else if ((p
->prefixlen
== newp
->prefixlen
&& !p
->ifindex
) ||
268 (p
->prefixlen
< newp
->prefixlen
)) {
269 hlist_add_before_rcu(&newp
->list
, &p
->list
);
275 hlist_add_behind_rcu(&newp
->list
, &last
->list
);
277 hlist_add_head_rcu(&newp
->list
, &ip6addrlbl_table
.head
);
280 ip6addrlbl_table
.seq
++;
285 static int ip6addrlbl_add(struct net
*net
,
286 const struct in6_addr
*prefix
, int prefixlen
,
287 int ifindex
, u32 label
, int replace
)
289 struct ip6addrlbl_entry
*newp
;
292 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u, replace=%d)\n",
293 __func__
, prefix
, prefixlen
, ifindex
, (unsigned int)label
,
296 newp
= ip6addrlbl_alloc(net
, prefix
, prefixlen
, ifindex
, label
);
298 return PTR_ERR(newp
);
299 spin_lock(&ip6addrlbl_table
.lock
);
300 ret
= __ip6addrlbl_add(newp
, replace
);
301 spin_unlock(&ip6addrlbl_table
.lock
);
303 ip6addrlbl_free(newp
);
308 static int __ip6addrlbl_del(struct net
*net
,
309 const struct in6_addr
*prefix
, int prefixlen
,
312 struct ip6addrlbl_entry
*p
= NULL
;
313 struct hlist_node
*n
;
316 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d)\n",
317 __func__
, prefix
, prefixlen
, ifindex
);
319 hlist_for_each_entry_safe(p
, n
, &ip6addrlbl_table
.head
, list
) {
320 if (p
->prefixlen
== prefixlen
&&
321 net_eq(ip6addrlbl_net(p
), net
) &&
322 p
->ifindex
== ifindex
&&
323 ipv6_addr_equal(&p
->prefix
, prefix
)) {
324 hlist_del_rcu(&p
->list
);
333 static int ip6addrlbl_del(struct net
*net
,
334 const struct in6_addr
*prefix
, int prefixlen
,
337 struct in6_addr prefix_buf
;
340 ADDRLABEL(KERN_DEBUG
"%s(prefix=%pI6, prefixlen=%d, ifindex=%d)\n",
341 __func__
, prefix
, prefixlen
, ifindex
);
343 ipv6_addr_prefix(&prefix_buf
, prefix
, prefixlen
);
344 spin_lock(&ip6addrlbl_table
.lock
);
345 ret
= __ip6addrlbl_del(net
, &prefix_buf
, prefixlen
, ifindex
);
346 spin_unlock(&ip6addrlbl_table
.lock
);
350 /* add default label */
351 static int __net_init
ip6addrlbl_net_init(struct net
*net
)
356 ADDRLABEL(KERN_DEBUG
"%s\n", __func__
);
358 for (i
= 0; i
< ARRAY_SIZE(ip6addrlbl_init_table
); i
++) {
359 int ret
= ip6addrlbl_add(net
,
360 ip6addrlbl_init_table
[i
].prefix
,
361 ip6addrlbl_init_table
[i
].prefixlen
,
363 ip6addrlbl_init_table
[i
].label
, 0);
364 /* XXX: should we free all rules when we catch an error? */
365 if (ret
&& (!err
|| err
!= -ENOMEM
))
371 static void __net_exit
ip6addrlbl_net_exit(struct net
*net
)
373 struct ip6addrlbl_entry
*p
= NULL
;
374 struct hlist_node
*n
;
376 /* Remove all labels belonging to the exiting net */
377 spin_lock(&ip6addrlbl_table
.lock
);
378 hlist_for_each_entry_safe(p
, n
, &ip6addrlbl_table
.head
, list
) {
379 if (net_eq(ip6addrlbl_net(p
), net
)) {
380 hlist_del_rcu(&p
->list
);
384 spin_unlock(&ip6addrlbl_table
.lock
);
387 static struct pernet_operations ipv6_addr_label_ops
= {
388 .init
= ip6addrlbl_net_init
,
389 .exit
= ip6addrlbl_net_exit
,
392 int __init
ipv6_addr_label_init(void)
394 spin_lock_init(&ip6addrlbl_table
.lock
);
396 return register_pernet_subsys(&ipv6_addr_label_ops
);
399 void ipv6_addr_label_cleanup(void)
401 unregister_pernet_subsys(&ipv6_addr_label_ops
);
404 static const struct nla_policy ifal_policy
[IFAL_MAX
+1] = {
405 [IFAL_ADDRESS
] = { .len
= sizeof(struct in6_addr
), },
406 [IFAL_LABEL
] = { .len
= sizeof(u32
), },
409 static bool addrlbl_ifindex_exists(struct net
*net
, int ifindex
)
412 struct net_device
*dev
;
415 dev
= dev_get_by_index_rcu(net
, ifindex
);
421 static int ip6addrlbl_newdel(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
422 struct netlink_ext_ack
*extack
)
424 struct net
*net
= sock_net(skb
->sk
);
425 struct ifaddrlblmsg
*ifal
;
426 struct nlattr
*tb
[IFAL_MAX
+1];
427 struct in6_addr
*pfx
;
431 err
= nlmsg_parse(nlh
, sizeof(*ifal
), tb
, IFAL_MAX
, ifal_policy
,
436 ifal
= nlmsg_data(nlh
);
438 if (ifal
->ifal_family
!= AF_INET6
||
439 ifal
->ifal_prefixlen
> 128)
442 if (!tb
[IFAL_ADDRESS
])
444 pfx
= nla_data(tb
[IFAL_ADDRESS
]);
448 label
= nla_get_u32(tb
[IFAL_LABEL
]);
449 if (label
== IPV6_ADDR_LABEL_DEFAULT
)
452 switch (nlh
->nlmsg_type
) {
453 case RTM_NEWADDRLABEL
:
454 if (ifal
->ifal_index
&&
455 !addrlbl_ifindex_exists(net
, ifal
->ifal_index
))
458 err
= ip6addrlbl_add(net
, pfx
, ifal
->ifal_prefixlen
,
459 ifal
->ifal_index
, label
,
460 nlh
->nlmsg_flags
& NLM_F_REPLACE
);
462 case RTM_DELADDRLABEL
:
463 err
= ip6addrlbl_del(net
, pfx
, ifal
->ifal_prefixlen
,
472 static void ip6addrlbl_putmsg(struct nlmsghdr
*nlh
,
473 int prefixlen
, int ifindex
, u32 lseq
)
475 struct ifaddrlblmsg
*ifal
= nlmsg_data(nlh
);
476 ifal
->ifal_family
= AF_INET6
;
477 ifal
->ifal_prefixlen
= prefixlen
;
478 ifal
->ifal_flags
= 0;
479 ifal
->ifal_index
= ifindex
;
480 ifal
->ifal_seq
= lseq
;
483 static int ip6addrlbl_fill(struct sk_buff
*skb
,
484 struct ip6addrlbl_entry
*p
,
486 u32 portid
, u32 seq
, int event
,
489 struct nlmsghdr
*nlh
= nlmsg_put(skb
, portid
, seq
, event
,
490 sizeof(struct ifaddrlblmsg
), flags
);
494 ip6addrlbl_putmsg(nlh
, p
->prefixlen
, p
->ifindex
, lseq
);
496 if (nla_put_in6_addr(skb
, IFAL_ADDRESS
, &p
->prefix
) < 0 ||
497 nla_put_u32(skb
, IFAL_LABEL
, p
->label
) < 0) {
498 nlmsg_cancel(skb
, nlh
);
506 static int ip6addrlbl_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
508 struct net
*net
= sock_net(skb
->sk
);
509 struct ip6addrlbl_entry
*p
;
510 int idx
= 0, s_idx
= cb
->args
[0];
514 hlist_for_each_entry_rcu(p
, &ip6addrlbl_table
.head
, list
) {
516 net_eq(ip6addrlbl_net(p
), net
)) {
517 err
= ip6addrlbl_fill(skb
, p
,
518 ip6addrlbl_table
.seq
,
519 NETLINK_CB(cb
->skb
).portid
,
533 static inline int ip6addrlbl_msgsize(void)
535 return NLMSG_ALIGN(sizeof(struct ifaddrlblmsg
))
536 + nla_total_size(16) /* IFAL_ADDRESS */
537 + nla_total_size(4); /* IFAL_LABEL */
540 static int ip6addrlbl_get(struct sk_buff
*in_skb
, struct nlmsghdr
*nlh
,
541 struct netlink_ext_ack
*extack
)
543 struct net
*net
= sock_net(in_skb
->sk
);
544 struct ifaddrlblmsg
*ifal
;
545 struct nlattr
*tb
[IFAL_MAX
+1];
546 struct in6_addr
*addr
;
549 struct ip6addrlbl_entry
*p
;
552 err
= nlmsg_parse(nlh
, sizeof(*ifal
), tb
, IFAL_MAX
, ifal_policy
,
557 ifal
= nlmsg_data(nlh
);
559 if (ifal
->ifal_family
!= AF_INET6
||
560 ifal
->ifal_prefixlen
!= 128)
563 if (ifal
->ifal_index
&&
564 !addrlbl_ifindex_exists(net
, ifal
->ifal_index
))
567 if (!tb
[IFAL_ADDRESS
])
569 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 skb
= nlmsg_new(ip6addrlbl_msgsize(), GFP_KERNEL
);
589 err
= ip6addrlbl_fill(skb
, p
, lseq
,
590 NETLINK_CB(in_skb
).portid
, nlh
->nlmsg_seq
,
591 RTM_NEWADDRLABEL
, 0);
596 WARN_ON(err
== -EMSGSIZE
);
601 err
= rtnl_unicast(skb
, net
, NETLINK_CB(in_skb
).portid
);
606 void __init
ipv6_addr_label_rtnl_register(void)
608 __rtnl_register(PF_INET6
, RTM_NEWADDRLABEL
, ip6addrlbl_newdel
,
609 NULL
, RTNL_FLAG_DOIT_UNLOCKED
);
610 __rtnl_register(PF_INET6
, RTM_DELADDRLABEL
, ip6addrlbl_newdel
,
611 NULL
, RTNL_FLAG_DOIT_UNLOCKED
);
612 __rtnl_register(PF_INET6
, RTM_GETADDRLABEL
, ip6addrlbl_get
,
613 ip6addrlbl_dump
, RTNL_FLAG_DOIT_UNLOCKED
);