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