Merge branch 'linus' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6-microblaze.git] / net / ipv6 / seg6.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  SR-IPv6 implementation
4  *
5  *  Author:
6  *  David Lebrun <david.lebrun@uclouvain.be>
7  */
8
9 #include <linux/errno.h>
10 #include <linux/types.h>
11 #include <linux/socket.h>
12 #include <linux/net.h>
13 #include <linux/in6.h>
14 #include <linux/slab.h>
15 #include <linux/rhashtable.h>
16
17 #include <net/ipv6.h>
18 #include <net/protocol.h>
19
20 #include <net/seg6.h>
21 #include <net/genetlink.h>
22 #include <linux/seg6.h>
23 #include <linux/seg6_genl.h>
24 #ifdef CONFIG_IPV6_SEG6_HMAC
25 #include <net/seg6_hmac.h>
26 #endif
27
28 bool seg6_validate_srh(struct ipv6_sr_hdr *srh, int len)
29 {
30         int trailing;
31         unsigned int tlv_offset;
32
33         if (srh->type != IPV6_SRCRT_TYPE_4)
34                 return false;
35
36         if (((srh->hdrlen + 1) << 3) != len)
37                 return false;
38
39         if (srh->segments_left > srh->first_segment)
40                 return false;
41
42         tlv_offset = sizeof(*srh) + ((srh->first_segment + 1) << 4);
43
44         trailing = len - tlv_offset;
45         if (trailing < 0)
46                 return false;
47
48         while (trailing) {
49                 struct sr6_tlv *tlv;
50                 unsigned int tlv_len;
51
52                 if (trailing < sizeof(*tlv))
53                         return false;
54
55                 tlv = (struct sr6_tlv *)((unsigned char *)srh + tlv_offset);
56                 tlv_len = sizeof(*tlv) + tlv->len;
57
58                 trailing -= tlv_len;
59                 if (trailing < 0)
60                         return false;
61
62                 tlv_offset += tlv_len;
63         }
64
65         return true;
66 }
67
68 static struct genl_family seg6_genl_family;
69
70 static const struct nla_policy seg6_genl_policy[SEG6_ATTR_MAX + 1] = {
71         [SEG6_ATTR_DST]                         = { .type = NLA_BINARY,
72                 .len = sizeof(struct in6_addr) },
73         [SEG6_ATTR_DSTLEN]                      = { .type = NLA_S32, },
74         [SEG6_ATTR_HMACKEYID]           = { .type = NLA_U32, },
75         [SEG6_ATTR_SECRET]                      = { .type = NLA_BINARY, },
76         [SEG6_ATTR_SECRETLEN]           = { .type = NLA_U8, },
77         [SEG6_ATTR_ALGID]                       = { .type = NLA_U8, },
78         [SEG6_ATTR_HMACINFO]            = { .type = NLA_NESTED, },
79 };
80
81 #ifdef CONFIG_IPV6_SEG6_HMAC
82
83 static int seg6_genl_sethmac(struct sk_buff *skb, struct genl_info *info)
84 {
85         struct net *net = genl_info_net(info);
86         struct seg6_pernet_data *sdata;
87         struct seg6_hmac_info *hinfo;
88         u32 hmackeyid;
89         char *secret;
90         int err = 0;
91         u8 algid;
92         u8 slen;
93
94         sdata = seg6_pernet(net);
95
96         if (!info->attrs[SEG6_ATTR_HMACKEYID] ||
97             !info->attrs[SEG6_ATTR_SECRETLEN] ||
98             !info->attrs[SEG6_ATTR_ALGID])
99                 return -EINVAL;
100
101         hmackeyid = nla_get_u32(info->attrs[SEG6_ATTR_HMACKEYID]);
102         slen = nla_get_u8(info->attrs[SEG6_ATTR_SECRETLEN]);
103         algid = nla_get_u8(info->attrs[SEG6_ATTR_ALGID]);
104
105         if (hmackeyid == 0)
106                 return -EINVAL;
107
108         if (slen > SEG6_HMAC_SECRET_LEN)
109                 return -EINVAL;
110
111         mutex_lock(&sdata->lock);
112         hinfo = seg6_hmac_info_lookup(net, hmackeyid);
113
114         if (!slen) {
115                 if (!hinfo)
116                         err = -ENOENT;
117
118                 err = seg6_hmac_info_del(net, hmackeyid);
119
120                 goto out_unlock;
121         }
122
123         if (!info->attrs[SEG6_ATTR_SECRET]) {
124                 err = -EINVAL;
125                 goto out_unlock;
126         }
127
128         if (hinfo) {
129                 err = seg6_hmac_info_del(net, hmackeyid);
130                 if (err)
131                         goto out_unlock;
132         }
133
134         secret = (char *)nla_data(info->attrs[SEG6_ATTR_SECRET]);
135
136         hinfo = kzalloc(sizeof(*hinfo), GFP_KERNEL);
137         if (!hinfo) {
138                 err = -ENOMEM;
139                 goto out_unlock;
140         }
141
142         memcpy(hinfo->secret, secret, slen);
143         hinfo->slen = slen;
144         hinfo->alg_id = algid;
145         hinfo->hmackeyid = hmackeyid;
146
147         err = seg6_hmac_info_add(net, hmackeyid, hinfo);
148         if (err)
149                 kfree(hinfo);
150
151 out_unlock:
152         mutex_unlock(&sdata->lock);
153         return err;
154 }
155
156 #else
157
158 static int seg6_genl_sethmac(struct sk_buff *skb, struct genl_info *info)
159 {
160         return -ENOTSUPP;
161 }
162
163 #endif
164
165 static int seg6_genl_set_tunsrc(struct sk_buff *skb, struct genl_info *info)
166 {
167         struct net *net = genl_info_net(info);
168         struct in6_addr *val, *t_old, *t_new;
169         struct seg6_pernet_data *sdata;
170
171         sdata = seg6_pernet(net);
172
173         if (!info->attrs[SEG6_ATTR_DST])
174                 return -EINVAL;
175
176         val = nla_data(info->attrs[SEG6_ATTR_DST]);
177         t_new = kmemdup(val, sizeof(*val), GFP_KERNEL);
178         if (!t_new)
179                 return -ENOMEM;
180
181         mutex_lock(&sdata->lock);
182
183         t_old = sdata->tun_src;
184         rcu_assign_pointer(sdata->tun_src, t_new);
185
186         mutex_unlock(&sdata->lock);
187
188         synchronize_net();
189         kfree(t_old);
190
191         return 0;
192 }
193
194 static int seg6_genl_get_tunsrc(struct sk_buff *skb, struct genl_info *info)
195 {
196         struct net *net = genl_info_net(info);
197         struct in6_addr *tun_src;
198         struct sk_buff *msg;
199         void *hdr;
200
201         msg = genlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
202         if (!msg)
203                 return -ENOMEM;
204
205         hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
206                           &seg6_genl_family, 0, SEG6_CMD_GET_TUNSRC);
207         if (!hdr)
208                 goto free_msg;
209
210         rcu_read_lock();
211         tun_src = rcu_dereference(seg6_pernet(net)->tun_src);
212
213         if (nla_put(msg, SEG6_ATTR_DST, sizeof(struct in6_addr), tun_src))
214                 goto nla_put_failure;
215
216         rcu_read_unlock();
217
218         genlmsg_end(msg, hdr);
219         return genlmsg_reply(msg, info);
220
221 nla_put_failure:
222         rcu_read_unlock();
223 free_msg:
224         nlmsg_free(msg);
225         return -ENOMEM;
226 }
227
228 #ifdef CONFIG_IPV6_SEG6_HMAC
229
230 static int __seg6_hmac_fill_info(struct seg6_hmac_info *hinfo,
231                                  struct sk_buff *msg)
232 {
233         if (nla_put_u32(msg, SEG6_ATTR_HMACKEYID, hinfo->hmackeyid) ||
234             nla_put_u8(msg, SEG6_ATTR_SECRETLEN, hinfo->slen) ||
235             nla_put(msg, SEG6_ATTR_SECRET, hinfo->slen, hinfo->secret) ||
236             nla_put_u8(msg, SEG6_ATTR_ALGID, hinfo->alg_id))
237                 return -1;
238
239         return 0;
240 }
241
242 static int __seg6_genl_dumphmac_element(struct seg6_hmac_info *hinfo,
243                                         u32 portid, u32 seq, u32 flags,
244                                         struct sk_buff *skb, u8 cmd)
245 {
246         void *hdr;
247
248         hdr = genlmsg_put(skb, portid, seq, &seg6_genl_family, flags, cmd);
249         if (!hdr)
250                 return -ENOMEM;
251
252         if (__seg6_hmac_fill_info(hinfo, skb) < 0)
253                 goto nla_put_failure;
254
255         genlmsg_end(skb, hdr);
256         return 0;
257
258 nla_put_failure:
259         genlmsg_cancel(skb, hdr);
260         return -EMSGSIZE;
261 }
262
263 static int seg6_genl_dumphmac_start(struct netlink_callback *cb)
264 {
265         struct net *net = sock_net(cb->skb->sk);
266         struct seg6_pernet_data *sdata;
267         struct rhashtable_iter *iter;
268
269         sdata = seg6_pernet(net);
270         iter = (struct rhashtable_iter *)cb->args[0];
271
272         if (!iter) {
273                 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
274                 if (!iter)
275                         return -ENOMEM;
276
277                 cb->args[0] = (long)iter;
278         }
279
280         rhashtable_walk_enter(&sdata->hmac_infos, iter);
281
282         return 0;
283 }
284
285 static int seg6_genl_dumphmac_done(struct netlink_callback *cb)
286 {
287         struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];
288
289         rhashtable_walk_exit(iter);
290
291         kfree(iter);
292
293         return 0;
294 }
295
296 static int seg6_genl_dumphmac(struct sk_buff *skb, struct netlink_callback *cb)
297 {
298         struct rhashtable_iter *iter = (struct rhashtable_iter *)cb->args[0];
299         struct seg6_hmac_info *hinfo;
300         int ret;
301
302         rhashtable_walk_start(iter);
303
304         for (;;) {
305                 hinfo = rhashtable_walk_next(iter);
306
307                 if (IS_ERR(hinfo)) {
308                         if (PTR_ERR(hinfo) == -EAGAIN)
309                                 continue;
310                         ret = PTR_ERR(hinfo);
311                         goto done;
312                 } else if (!hinfo) {
313                         break;
314                 }
315
316                 ret = __seg6_genl_dumphmac_element(hinfo,
317                                                    NETLINK_CB(cb->skb).portid,
318                                                    cb->nlh->nlmsg_seq,
319                                                    NLM_F_MULTI,
320                                                    skb, SEG6_CMD_DUMPHMAC);
321                 if (ret)
322                         goto done;
323         }
324
325         ret = skb->len;
326
327 done:
328         rhashtable_walk_stop(iter);
329         return ret;
330 }
331
332 #else
333
334 static int seg6_genl_dumphmac_start(struct netlink_callback *cb)
335 {
336         return 0;
337 }
338
339 static int seg6_genl_dumphmac_done(struct netlink_callback *cb)
340 {
341         return 0;
342 }
343
344 static int seg6_genl_dumphmac(struct sk_buff *skb, struct netlink_callback *cb)
345 {
346         return -ENOTSUPP;
347 }
348
349 #endif
350
351 static int __net_init seg6_net_init(struct net *net)
352 {
353         struct seg6_pernet_data *sdata;
354
355         sdata = kzalloc(sizeof(*sdata), GFP_KERNEL);
356         if (!sdata)
357                 return -ENOMEM;
358
359         mutex_init(&sdata->lock);
360
361         sdata->tun_src = kzalloc(sizeof(*sdata->tun_src), GFP_KERNEL);
362         if (!sdata->tun_src) {
363                 kfree(sdata);
364                 return -ENOMEM;
365         }
366
367         net->ipv6.seg6_data = sdata;
368
369 #ifdef CONFIG_IPV6_SEG6_HMAC
370         seg6_hmac_net_init(net);
371 #endif
372
373         return 0;
374 }
375
376 static void __net_exit seg6_net_exit(struct net *net)
377 {
378         struct seg6_pernet_data *sdata = seg6_pernet(net);
379
380 #ifdef CONFIG_IPV6_SEG6_HMAC
381         seg6_hmac_net_exit(net);
382 #endif
383
384         kfree(sdata->tun_src);
385         kfree(sdata);
386 }
387
388 static struct pernet_operations ip6_segments_ops = {
389         .init = seg6_net_init,
390         .exit = seg6_net_exit,
391 };
392
393 static const struct genl_ops seg6_genl_ops[] = {
394         {
395                 .cmd    = SEG6_CMD_SETHMAC,
396                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
397                 .doit   = seg6_genl_sethmac,
398                 .flags  = GENL_ADMIN_PERM,
399         },
400         {
401                 .cmd    = SEG6_CMD_DUMPHMAC,
402                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
403                 .start  = seg6_genl_dumphmac_start,
404                 .dumpit = seg6_genl_dumphmac,
405                 .done   = seg6_genl_dumphmac_done,
406                 .flags  = GENL_ADMIN_PERM,
407         },
408         {
409                 .cmd    = SEG6_CMD_SET_TUNSRC,
410                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
411                 .doit   = seg6_genl_set_tunsrc,
412                 .flags  = GENL_ADMIN_PERM,
413         },
414         {
415                 .cmd    = SEG6_CMD_GET_TUNSRC,
416                 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
417                 .doit   = seg6_genl_get_tunsrc,
418                 .flags  = GENL_ADMIN_PERM,
419         },
420 };
421
422 static struct genl_family seg6_genl_family __ro_after_init = {
423         .hdrsize        = 0,
424         .name           = SEG6_GENL_NAME,
425         .version        = SEG6_GENL_VERSION,
426         .maxattr        = SEG6_ATTR_MAX,
427         .policy = seg6_genl_policy,
428         .netnsok        = true,
429         .parallel_ops   = true,
430         .ops            = seg6_genl_ops,
431         .n_ops          = ARRAY_SIZE(seg6_genl_ops),
432         .module         = THIS_MODULE,
433 };
434
435 int __init seg6_init(void)
436 {
437         int err = -ENOMEM;
438
439         err = genl_register_family(&seg6_genl_family);
440         if (err)
441                 goto out;
442
443         err = register_pernet_subsys(&ip6_segments_ops);
444         if (err)
445                 goto out_unregister_genl;
446
447 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
448         err = seg6_iptunnel_init();
449         if (err)
450                 goto out_unregister_pernet;
451
452         err = seg6_local_init();
453         if (err)
454                 goto out_unregister_pernet;
455 #endif
456
457 #ifdef CONFIG_IPV6_SEG6_HMAC
458         err = seg6_hmac_init();
459         if (err)
460                 goto out_unregister_iptun;
461 #endif
462
463         pr_info("Segment Routing with IPv6\n");
464
465 out:
466         return err;
467 #ifdef CONFIG_IPV6_SEG6_HMAC
468 out_unregister_iptun:
469 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
470         seg6_local_exit();
471         seg6_iptunnel_exit();
472 #endif
473 #endif
474 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
475 out_unregister_pernet:
476         unregister_pernet_subsys(&ip6_segments_ops);
477 #endif
478 out_unregister_genl:
479         genl_unregister_family(&seg6_genl_family);
480         goto out;
481 }
482
483 void seg6_exit(void)
484 {
485 #ifdef CONFIG_IPV6_SEG6_HMAC
486         seg6_hmac_exit();
487 #endif
488 #ifdef CONFIG_IPV6_SEG6_LWTUNNEL
489         seg6_iptunnel_exit();
490 #endif
491         unregister_pernet_subsys(&ip6_segments_ops);
492         genl_unregister_family(&seg6_genl_family);
493 }