1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#include <linux/module.h>
43#include <linux/init.h>
44#include <linux/types.h>
45#include <linux/kernel.h>
46#include <linux/list.h>
47#include <linux/spinlock.h>
48#include <linux/rcupdate.h>
49#include <linux/rculist.h>
50#include <linux/net.h>
51#include <linux/netdevice.h>
52#include <linux/if_arp.h>
53#include <linux/skbuff.h>
54#include <linux/can.h>
55#include <linux/can/core.h>
56#include <linux/can/skb.h>
57#include <linux/can/gw.h>
58#include <net/rtnetlink.h>
59#include <net/net_namespace.h>
60#include <net/sock.h>
61
62#define CAN_GW_VERSION "20130117"
63#define CAN_GW_NAME "can-gw"
64
65MODULE_DESCRIPTION("PF_CAN netlink gateway");
66MODULE_LICENSE("Dual BSD/GPL");
67MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
68MODULE_ALIAS(CAN_GW_NAME);
69
70#define CGW_MIN_HOPS 1
71#define CGW_MAX_HOPS 6
72#define CGW_DEFAULT_HOPS 1
73
74static unsigned int max_hops __read_mostly = CGW_DEFAULT_HOPS;
75module_param(max_hops, uint, S_IRUGO);
76MODULE_PARM_DESC(max_hops,
77 "maximum " CAN_GW_NAME " routing hops for CAN frames "
78 "(valid values: " __stringify(CGW_MIN_HOPS) "-"
79 __stringify(CGW_MAX_HOPS) " hops, "
80 "default: " __stringify(CGW_DEFAULT_HOPS) ")");
81
82static HLIST_HEAD(cgw_list);
83static struct notifier_block notifier;
84
85static struct kmem_cache *cgw_cache __read_mostly;
86
87
88struct cf_mod {
89 struct {
90 struct can_frame and;
91 struct can_frame or;
92 struct can_frame xor;
93 struct can_frame set;
94 } modframe;
95 struct {
96 u8 and;
97 u8 or;
98 u8 xor;
99 u8 set;
100 } modtype;
101 void (*modfunc[MAX_MODFUNCTIONS])(struct can_frame *cf,
102 struct cf_mod *mod);
103
104
105 struct {
106 struct cgw_csum_xor xor;
107 struct cgw_csum_crc8 crc8;
108 } csum;
109 struct {
110 void (*xor)(struct can_frame *cf, struct cgw_csum_xor *xor);
111 void (*crc8)(struct can_frame *cf, struct cgw_csum_crc8 *crc8);
112 } csumfunc;
113};
114
115
116
117
118
119
120
121
122struct can_can_gw {
123 struct can_filter filter;
124 int src_idx;
125 int dst_idx;
126};
127
128
129struct cgw_job {
130 struct hlist_node list;
131 struct rcu_head rcu;
132 u32 handled_frames;
133 u32 dropped_frames;
134 u32 deleted_frames;
135 struct cf_mod mod;
136 union {
137
138 struct net_device *dev;
139 } src;
140 union {
141
142 struct net_device *dev;
143 } dst;
144 union {
145 struct can_can_gw ccgw;
146
147 };
148 u8 gwtype;
149 u16 flags;
150};
151
152
153
154#define MODFUNC(func, op) static void func(struct can_frame *cf, \
155 struct cf_mod *mod) { op ; }
156
157MODFUNC(mod_and_id, cf->can_id &= mod->modframe.and.can_id)
158MODFUNC(mod_and_dlc, cf->can_dlc &= mod->modframe.and.can_dlc)
159MODFUNC(mod_and_data, *(u64 *)cf->data &= *(u64 *)mod->modframe.and.data)
160MODFUNC(mod_or_id, cf->can_id |= mod->modframe.or.can_id)
161MODFUNC(mod_or_dlc, cf->can_dlc |= mod->modframe.or.can_dlc)
162MODFUNC(mod_or_data, *(u64 *)cf->data |= *(u64 *)mod->modframe.or.data)
163MODFUNC(mod_xor_id, cf->can_id ^= mod->modframe.xor.can_id)
164MODFUNC(mod_xor_dlc, cf->can_dlc ^= mod->modframe.xor.can_dlc)
165MODFUNC(mod_xor_data, *(u64 *)cf->data ^= *(u64 *)mod->modframe.xor.data)
166MODFUNC(mod_set_id, cf->can_id = mod->modframe.set.can_id)
167MODFUNC(mod_set_dlc, cf->can_dlc = mod->modframe.set.can_dlc)
168MODFUNC(mod_set_data, *(u64 *)cf->data = *(u64 *)mod->modframe.set.data)
169
170static inline void canframecpy(struct can_frame *dst, struct can_frame *src)
171{
172
173
174
175
176
177
178 dst->can_id = src->can_id;
179 dst->can_dlc = src->can_dlc;
180 *(u64 *)dst->data = *(u64 *)src->data;
181}
182
183static int cgw_chk_csum_parms(s8 fr, s8 to, s8 re)
184{
185
186
187
188
189
190
191
192
193
194 if (fr > -9 && fr < 8 &&
195 to > -9 && to < 8 &&
196 re > -9 && re < 8)
197 return 0;
198 else
199 return -EINVAL;
200}
201
202static inline int calc_idx(int idx, int rx_dlc)
203{
204 if (idx < 0)
205 return rx_dlc + idx;
206 else
207 return idx;
208}
209
210static void cgw_csum_xor_rel(struct can_frame *cf, struct cgw_csum_xor *xor)
211{
212 int from = calc_idx(xor->from_idx, cf->can_dlc);
213 int to = calc_idx(xor->to_idx, cf->can_dlc);
214 int res = calc_idx(xor->result_idx, cf->can_dlc);
215 u8 val = xor->init_xor_val;
216 int i;
217
218 if (from < 0 || to < 0 || res < 0)
219 return;
220
221 if (from <= to) {
222 for (i = from; i <= to; i++)
223 val ^= cf->data[i];
224 } else {
225 for (i = from; i >= to; i--)
226 val ^= cf->data[i];
227 }
228
229 cf->data[res] = val;
230}
231
232static void cgw_csum_xor_pos(struct can_frame *cf, struct cgw_csum_xor *xor)
233{
234 u8 val = xor->init_xor_val;
235 int i;
236
237 for (i = xor->from_idx; i <= xor->to_idx; i++)
238 val ^= cf->data[i];
239
240 cf->data[xor->result_idx] = val;
241}
242
243static void cgw_csum_xor_neg(struct can_frame *cf, struct cgw_csum_xor *xor)
244{
245 u8 val = xor->init_xor_val;
246 int i;
247
248 for (i = xor->from_idx; i >= xor->to_idx; i--)
249 val ^= cf->data[i];
250
251 cf->data[xor->result_idx] = val;
252}
253
254static void cgw_csum_crc8_rel(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
255{
256 int from = calc_idx(crc8->from_idx, cf->can_dlc);
257 int to = calc_idx(crc8->to_idx, cf->can_dlc);
258 int res = calc_idx(crc8->result_idx, cf->can_dlc);
259 u8 crc = crc8->init_crc_val;
260 int i;
261
262 if (from < 0 || to < 0 || res < 0)
263 return;
264
265 if (from <= to) {
266 for (i = crc8->from_idx; i <= crc8->to_idx; i++)
267 crc = crc8->crctab[crc^cf->data[i]];
268 } else {
269 for (i = crc8->from_idx; i >= crc8->to_idx; i--)
270 crc = crc8->crctab[crc^cf->data[i]];
271 }
272
273 switch (crc8->profile) {
274
275 case CGW_CRC8PRF_1U8:
276 crc = crc8->crctab[crc^crc8->profile_data[0]];
277 break;
278
279 case CGW_CRC8PRF_16U8:
280 crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
281 break;
282
283 case CGW_CRC8PRF_SFFID_XOR:
284 crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
285 (cf->can_id >> 8 & 0xFF)];
286 break;
287
288 }
289
290 cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
291}
292
293static void cgw_csum_crc8_pos(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
294{
295 u8 crc = crc8->init_crc_val;
296 int i;
297
298 for (i = crc8->from_idx; i <= crc8->to_idx; i++)
299 crc = crc8->crctab[crc^cf->data[i]];
300
301 switch (crc8->profile) {
302
303 case CGW_CRC8PRF_1U8:
304 crc = crc8->crctab[crc^crc8->profile_data[0]];
305 break;
306
307 case CGW_CRC8PRF_16U8:
308 crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
309 break;
310
311 case CGW_CRC8PRF_SFFID_XOR:
312 crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
313 (cf->can_id >> 8 & 0xFF)];
314 break;
315 }
316
317 cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
318}
319
320static void cgw_csum_crc8_neg(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
321{
322 u8 crc = crc8->init_crc_val;
323 int i;
324
325 for (i = crc8->from_idx; i >= crc8->to_idx; i--)
326 crc = crc8->crctab[crc^cf->data[i]];
327
328 switch (crc8->profile) {
329
330 case CGW_CRC8PRF_1U8:
331 crc = crc8->crctab[crc^crc8->profile_data[0]];
332 break;
333
334 case CGW_CRC8PRF_16U8:
335 crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
336 break;
337
338 case CGW_CRC8PRF_SFFID_XOR:
339 crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
340 (cf->can_id >> 8 & 0xFF)];
341 break;
342 }
343
344 cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
345}
346
347
348static void can_can_gw_rcv(struct sk_buff *skb, void *data)
349{
350 struct cgw_job *gwj = (struct cgw_job *)data;
351 struct can_frame *cf;
352 struct sk_buff *nskb;
353 int modidx = 0;
354
355
356
357
358
359
360
361
362
363
364
365
366
367#define cgw_hops(skb) ((skb)->csum_start)
368
369 BUG_ON(skb->ip_summed != CHECKSUM_UNNECESSARY);
370
371 if (cgw_hops(skb) >= max_hops) {
372
373 gwj->deleted_frames++;
374 return;
375 }
376
377 if (!(gwj->dst.dev->flags & IFF_UP)) {
378 gwj->dropped_frames++;
379 return;
380 }
381
382
383 if (!(gwj->flags & CGW_FLAGS_CAN_IIF_TX_OK) &&
384 can_skb_prv(skb)->ifindex == gwj->dst.dev->ifindex)
385 return;
386
387
388
389
390
391
392
393 if (gwj->mod.modfunc[0])
394 nskb = skb_copy(skb, GFP_ATOMIC);
395 else
396 nskb = skb_clone(skb, GFP_ATOMIC);
397
398 if (!nskb) {
399 gwj->dropped_frames++;
400 return;
401 }
402
403
404 cgw_hops(nskb) = cgw_hops(skb) + 1;
405 nskb->dev = gwj->dst.dev;
406
407
408 cf = (struct can_frame *)nskb->data;
409
410
411 while (modidx < MAX_MODFUNCTIONS && gwj->mod.modfunc[modidx])
412 (*gwj->mod.modfunc[modidx++])(cf, &gwj->mod);
413
414
415 if (modidx) {
416 if (gwj->mod.csumfunc.crc8)
417 (*gwj->mod.csumfunc.crc8)(cf, &gwj->mod.csum.crc8);
418
419 if (gwj->mod.csumfunc.xor)
420 (*gwj->mod.csumfunc.xor)(cf, &gwj->mod.csum.xor);
421 }
422
423
424 if (!(gwj->flags & CGW_FLAGS_CAN_SRC_TSTAMP))
425 nskb->tstamp.tv64 = 0;
426
427
428 if (can_send(nskb, gwj->flags & CGW_FLAGS_CAN_ECHO))
429 gwj->dropped_frames++;
430 else
431 gwj->handled_frames++;
432}
433
434static inline int cgw_register_filter(struct cgw_job *gwj)
435{
436 return can_rx_register(gwj->src.dev, gwj->ccgw.filter.can_id,
437 gwj->ccgw.filter.can_mask, can_can_gw_rcv,
438 gwj, "gw");
439}
440
441static inline void cgw_unregister_filter(struct cgw_job *gwj)
442{
443 can_rx_unregister(gwj->src.dev, gwj->ccgw.filter.can_id,
444 gwj->ccgw.filter.can_mask, can_can_gw_rcv, gwj);
445}
446
447static int cgw_notifier(struct notifier_block *nb,
448 unsigned long msg, void *ptr)
449{
450 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
451
452 if (!net_eq(dev_net(dev), &init_net))
453 return NOTIFY_DONE;
454 if (dev->type != ARPHRD_CAN)
455 return NOTIFY_DONE;
456
457 if (msg == NETDEV_UNREGISTER) {
458
459 struct cgw_job *gwj = NULL;
460 struct hlist_node *nx;
461
462 ASSERT_RTNL();
463
464 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
465
466 if (gwj->src.dev == dev || gwj->dst.dev == dev) {
467 hlist_del(&gwj->list);
468 cgw_unregister_filter(gwj);
469 kmem_cache_free(cgw_cache, gwj);
470 }
471 }
472 }
473
474 return NOTIFY_DONE;
475}
476
477static int cgw_put_job(struct sk_buff *skb, struct cgw_job *gwj, int type,
478 u32 pid, u32 seq, int flags)
479{
480 struct cgw_frame_mod mb;
481 struct rtcanmsg *rtcan;
482 struct nlmsghdr *nlh;
483
484 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtcan), flags);
485 if (!nlh)
486 return -EMSGSIZE;
487
488 rtcan = nlmsg_data(nlh);
489 rtcan->can_family = AF_CAN;
490 rtcan->gwtype = gwj->gwtype;
491 rtcan->flags = gwj->flags;
492
493
494
495 if (gwj->handled_frames) {
496 if (nla_put_u32(skb, CGW_HANDLED, gwj->handled_frames) < 0)
497 goto cancel;
498 }
499
500 if (gwj->dropped_frames) {
501 if (nla_put_u32(skb, CGW_DROPPED, gwj->dropped_frames) < 0)
502 goto cancel;
503 }
504
505 if (gwj->deleted_frames) {
506 if (nla_put_u32(skb, CGW_DELETED, gwj->deleted_frames) < 0)
507 goto cancel;
508 }
509
510
511
512 if (gwj->mod.modtype.and) {
513 memcpy(&mb.cf, &gwj->mod.modframe.and, sizeof(mb.cf));
514 mb.modtype = gwj->mod.modtype.and;
515 if (nla_put(skb, CGW_MOD_AND, sizeof(mb), &mb) < 0)
516 goto cancel;
517 }
518
519 if (gwj->mod.modtype.or) {
520 memcpy(&mb.cf, &gwj->mod.modframe.or, sizeof(mb.cf));
521 mb.modtype = gwj->mod.modtype.or;
522 if (nla_put(skb, CGW_MOD_OR, sizeof(mb), &mb) < 0)
523 goto cancel;
524 }
525
526 if (gwj->mod.modtype.xor) {
527 memcpy(&mb.cf, &gwj->mod.modframe.xor, sizeof(mb.cf));
528 mb.modtype = gwj->mod.modtype.xor;
529 if (nla_put(skb, CGW_MOD_XOR, sizeof(mb), &mb) < 0)
530 goto cancel;
531 }
532
533 if (gwj->mod.modtype.set) {
534 memcpy(&mb.cf, &gwj->mod.modframe.set, sizeof(mb.cf));
535 mb.modtype = gwj->mod.modtype.set;
536 if (nla_put(skb, CGW_MOD_SET, sizeof(mb), &mb) < 0)
537 goto cancel;
538 }
539
540 if (gwj->mod.csumfunc.crc8) {
541 if (nla_put(skb, CGW_CS_CRC8, CGW_CS_CRC8_LEN,
542 &gwj->mod.csum.crc8) < 0)
543 goto cancel;
544 }
545
546 if (gwj->mod.csumfunc.xor) {
547 if (nla_put(skb, CGW_CS_XOR, CGW_CS_XOR_LEN,
548 &gwj->mod.csum.xor) < 0)
549 goto cancel;
550 }
551
552 if (gwj->gwtype == CGW_TYPE_CAN_CAN) {
553
554 if (gwj->ccgw.filter.can_id || gwj->ccgw.filter.can_mask) {
555 if (nla_put(skb, CGW_FILTER, sizeof(struct can_filter),
556 &gwj->ccgw.filter) < 0)
557 goto cancel;
558 }
559
560 if (nla_put_u32(skb, CGW_SRC_IF, gwj->ccgw.src_idx) < 0)
561 goto cancel;
562
563 if (nla_put_u32(skb, CGW_DST_IF, gwj->ccgw.dst_idx) < 0)
564 goto cancel;
565 }
566
567 return nlmsg_end(skb, nlh);
568
569cancel:
570 nlmsg_cancel(skb, nlh);
571 return -EMSGSIZE;
572}
573
574
575static int cgw_dump_jobs(struct sk_buff *skb, struct netlink_callback *cb)
576{
577 struct cgw_job *gwj = NULL;
578 int idx = 0;
579 int s_idx = cb->args[0];
580
581 rcu_read_lock();
582 hlist_for_each_entry_rcu(gwj, &cgw_list, list) {
583 if (idx < s_idx)
584 goto cont;
585
586 if (cgw_put_job(skb, gwj, RTM_NEWROUTE, NETLINK_CB(cb->skb).portid,
587 cb->nlh->nlmsg_seq, NLM_F_MULTI) < 0)
588 break;
589cont:
590 idx++;
591 }
592 rcu_read_unlock();
593
594 cb->args[0] = idx;
595
596 return skb->len;
597}
598
599static const struct nla_policy cgw_policy[CGW_MAX+1] = {
600 [CGW_MOD_AND] = { .len = sizeof(struct cgw_frame_mod) },
601 [CGW_MOD_OR] = { .len = sizeof(struct cgw_frame_mod) },
602 [CGW_MOD_XOR] = { .len = sizeof(struct cgw_frame_mod) },
603 [CGW_MOD_SET] = { .len = sizeof(struct cgw_frame_mod) },
604 [CGW_CS_XOR] = { .len = sizeof(struct cgw_csum_xor) },
605 [CGW_CS_CRC8] = { .len = sizeof(struct cgw_csum_crc8) },
606 [CGW_SRC_IF] = { .type = NLA_U32 },
607 [CGW_DST_IF] = { .type = NLA_U32 },
608 [CGW_FILTER] = { .len = sizeof(struct can_filter) },
609};
610
611
612static int cgw_parse_attr(struct nlmsghdr *nlh, struct cf_mod *mod,
613 u8 gwtype, void *gwtypeattr)
614{
615 struct nlattr *tb[CGW_MAX+1];
616 struct cgw_frame_mod mb;
617 int modidx = 0;
618 int err = 0;
619
620
621 memset(mod, 0, sizeof(*mod));
622
623 err = nlmsg_parse(nlh, sizeof(struct rtcanmsg), tb, CGW_MAX,
624 cgw_policy);
625 if (err < 0)
626 return err;
627
628
629
630 if (tb[CGW_MOD_AND]) {
631 nla_memcpy(&mb, tb[CGW_MOD_AND], CGW_MODATTR_LEN);
632
633 canframecpy(&mod->modframe.and, &mb.cf);
634 mod->modtype.and = mb.modtype;
635
636 if (mb.modtype & CGW_MOD_ID)
637 mod->modfunc[modidx++] = mod_and_id;
638
639 if (mb.modtype & CGW_MOD_DLC)
640 mod->modfunc[modidx++] = mod_and_dlc;
641
642 if (mb.modtype & CGW_MOD_DATA)
643 mod->modfunc[modidx++] = mod_and_data;
644 }
645
646 if (tb[CGW_MOD_OR]) {
647 nla_memcpy(&mb, tb[CGW_MOD_OR], CGW_MODATTR_LEN);
648
649 canframecpy(&mod->modframe.or, &mb.cf);
650 mod->modtype.or = mb.modtype;
651
652 if (mb.modtype & CGW_MOD_ID)
653 mod->modfunc[modidx++] = mod_or_id;
654
655 if (mb.modtype & CGW_MOD_DLC)
656 mod->modfunc[modidx++] = mod_or_dlc;
657
658 if (mb.modtype & CGW_MOD_DATA)
659 mod->modfunc[modidx++] = mod_or_data;
660 }
661
662 if (tb[CGW_MOD_XOR]) {
663 nla_memcpy(&mb, tb[CGW_MOD_XOR], CGW_MODATTR_LEN);
664
665 canframecpy(&mod->modframe.xor, &mb.cf);
666 mod->modtype.xor = mb.modtype;
667
668 if (mb.modtype & CGW_MOD_ID)
669 mod->modfunc[modidx++] = mod_xor_id;
670
671 if (mb.modtype & CGW_MOD_DLC)
672 mod->modfunc[modidx++] = mod_xor_dlc;
673
674 if (mb.modtype & CGW_MOD_DATA)
675 mod->modfunc[modidx++] = mod_xor_data;
676 }
677
678 if (tb[CGW_MOD_SET]) {
679 nla_memcpy(&mb, tb[CGW_MOD_SET], CGW_MODATTR_LEN);
680
681 canframecpy(&mod->modframe.set, &mb.cf);
682 mod->modtype.set = mb.modtype;
683
684 if (mb.modtype & CGW_MOD_ID)
685 mod->modfunc[modidx++] = mod_set_id;
686
687 if (mb.modtype & CGW_MOD_DLC)
688 mod->modfunc[modidx++] = mod_set_dlc;
689
690 if (mb.modtype & CGW_MOD_DATA)
691 mod->modfunc[modidx++] = mod_set_data;
692 }
693
694
695 if (modidx) {
696
697 if (tb[CGW_CS_CRC8]) {
698 struct cgw_csum_crc8 *c = nla_data(tb[CGW_CS_CRC8]);
699
700 err = cgw_chk_csum_parms(c->from_idx, c->to_idx,
701 c->result_idx);
702 if (err)
703 return err;
704
705 nla_memcpy(&mod->csum.crc8, tb[CGW_CS_CRC8],
706 CGW_CS_CRC8_LEN);
707
708
709
710
711
712 if (c->from_idx < 0 || c->to_idx < 0 ||
713 c->result_idx < 0)
714 mod->csumfunc.crc8 = cgw_csum_crc8_rel;
715 else if (c->from_idx <= c->to_idx)
716 mod->csumfunc.crc8 = cgw_csum_crc8_pos;
717 else
718 mod->csumfunc.crc8 = cgw_csum_crc8_neg;
719 }
720
721 if (tb[CGW_CS_XOR]) {
722 struct cgw_csum_xor *c = nla_data(tb[CGW_CS_XOR]);
723
724 err = cgw_chk_csum_parms(c->from_idx, c->to_idx,
725 c->result_idx);
726 if (err)
727 return err;
728
729 nla_memcpy(&mod->csum.xor, tb[CGW_CS_XOR],
730 CGW_CS_XOR_LEN);
731
732
733
734
735
736 if (c->from_idx < 0 || c->to_idx < 0 ||
737 c->result_idx < 0)
738 mod->csumfunc.xor = cgw_csum_xor_rel;
739 else if (c->from_idx <= c->to_idx)
740 mod->csumfunc.xor = cgw_csum_xor_pos;
741 else
742 mod->csumfunc.xor = cgw_csum_xor_neg;
743 }
744 }
745
746 if (gwtype == CGW_TYPE_CAN_CAN) {
747
748
749
750 struct can_can_gw *ccgw = (struct can_can_gw *)gwtypeattr;
751 memset(ccgw, 0, sizeof(*ccgw));
752
753
754 if (tb[CGW_FILTER])
755 nla_memcpy(&ccgw->filter, tb[CGW_FILTER],
756 sizeof(struct can_filter));
757
758 err = -ENODEV;
759
760
761 if (!tb[CGW_SRC_IF] || !tb[CGW_DST_IF])
762 return err;
763
764 ccgw->src_idx = nla_get_u32(tb[CGW_SRC_IF]);
765 ccgw->dst_idx = nla_get_u32(tb[CGW_DST_IF]);
766
767
768 if (!ccgw->src_idx && !ccgw->dst_idx)
769 return 0;
770
771
772 if (!ccgw->src_idx || !ccgw->dst_idx)
773 return err;
774 }
775
776
777
778 return 0;
779}
780
781static int cgw_create_job(struct sk_buff *skb, struct nlmsghdr *nlh)
782{
783 struct rtcanmsg *r;
784 struct cgw_job *gwj;
785 int err = 0;
786
787 if (!capable(CAP_NET_ADMIN))
788 return -EPERM;
789
790 if (nlmsg_len(nlh) < sizeof(*r))
791 return -EINVAL;
792
793 r = nlmsg_data(nlh);
794 if (r->can_family != AF_CAN)
795 return -EPFNOSUPPORT;
796
797
798 if (r->gwtype != CGW_TYPE_CAN_CAN)
799 return -EINVAL;
800
801 gwj = kmem_cache_alloc(cgw_cache, GFP_KERNEL);
802 if (!gwj)
803 return -ENOMEM;
804
805 gwj->handled_frames = 0;
806 gwj->dropped_frames = 0;
807 gwj->deleted_frames = 0;
808 gwj->flags = r->flags;
809 gwj->gwtype = r->gwtype;
810
811 err = cgw_parse_attr(nlh, &gwj->mod, CGW_TYPE_CAN_CAN, &gwj->ccgw);
812 if (err < 0)
813 goto out;
814
815 err = -ENODEV;
816
817
818 if (!gwj->ccgw.src_idx || !gwj->ccgw.dst_idx)
819 goto out;
820
821 gwj->src.dev = dev_get_by_index(&init_net, gwj->ccgw.src_idx);
822
823 if (!gwj->src.dev)
824 goto out;
825
826
827 if (gwj->src.dev->type != ARPHRD_CAN || gwj->src.dev->header_ops)
828 goto put_src_out;
829
830 gwj->dst.dev = dev_get_by_index(&init_net, gwj->ccgw.dst_idx);
831
832 if (!gwj->dst.dev)
833 goto put_src_out;
834
835
836 if (gwj->dst.dev->type != ARPHRD_CAN || gwj->dst.dev->header_ops)
837 goto put_src_dst_out;
838
839 ASSERT_RTNL();
840
841 err = cgw_register_filter(gwj);
842 if (!err)
843 hlist_add_head_rcu(&gwj->list, &cgw_list);
844
845put_src_dst_out:
846 dev_put(gwj->dst.dev);
847put_src_out:
848 dev_put(gwj->src.dev);
849out:
850 if (err)
851 kmem_cache_free(cgw_cache, gwj);
852
853 return err;
854}
855
856static void cgw_remove_all_jobs(void)
857{
858 struct cgw_job *gwj = NULL;
859 struct hlist_node *nx;
860
861 ASSERT_RTNL();
862
863 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
864 hlist_del(&gwj->list);
865 cgw_unregister_filter(gwj);
866 kmem_cache_free(cgw_cache, gwj);
867 }
868}
869
870static int cgw_remove_job(struct sk_buff *skb, struct nlmsghdr *nlh)
871{
872 struct cgw_job *gwj = NULL;
873 struct hlist_node *nx;
874 struct rtcanmsg *r;
875 struct cf_mod mod;
876 struct can_can_gw ccgw;
877 int err = 0;
878
879 if (!capable(CAP_NET_ADMIN))
880 return -EPERM;
881
882 if (nlmsg_len(nlh) < sizeof(*r))
883 return -EINVAL;
884
885 r = nlmsg_data(nlh);
886 if (r->can_family != AF_CAN)
887 return -EPFNOSUPPORT;
888
889
890 if (r->gwtype != CGW_TYPE_CAN_CAN)
891 return -EINVAL;
892
893 err = cgw_parse_attr(nlh, &mod, CGW_TYPE_CAN_CAN, &ccgw);
894 if (err < 0)
895 return err;
896
897
898 if (!ccgw.src_idx && !ccgw.dst_idx) {
899 cgw_remove_all_jobs();
900 return 0;
901 }
902
903 err = -EINVAL;
904
905 ASSERT_RTNL();
906
907
908 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
909
910 if (gwj->flags != r->flags)
911 continue;
912
913 if (memcmp(&gwj->mod, &mod, sizeof(mod)))
914 continue;
915
916
917 if (memcmp(&gwj->ccgw, &ccgw, sizeof(ccgw)))
918 continue;
919
920 hlist_del(&gwj->list);
921 cgw_unregister_filter(gwj);
922 kmem_cache_free(cgw_cache, gwj);
923 err = 0;
924 break;
925 }
926
927 return err;
928}
929
930static __init int cgw_module_init(void)
931{
932
933 max_hops = clamp_t(unsigned int, max_hops, CGW_MIN_HOPS, CGW_MAX_HOPS);
934
935 pr_info("can: netlink gateway (rev " CAN_GW_VERSION ") max_hops=%d\n",
936 max_hops);
937
938 cgw_cache = kmem_cache_create("can_gw", sizeof(struct cgw_job),
939 0, 0, NULL);
940
941 if (!cgw_cache)
942 return -ENOMEM;
943
944
945 notifier.notifier_call = cgw_notifier;
946 register_netdevice_notifier(¬ifier);
947
948 if (__rtnl_register(PF_CAN, RTM_GETROUTE, NULL, cgw_dump_jobs, NULL)) {
949 unregister_netdevice_notifier(¬ifier);
950 kmem_cache_destroy(cgw_cache);
951 return -ENOBUFS;
952 }
953
954
955 __rtnl_register(PF_CAN, RTM_NEWROUTE, cgw_create_job, NULL, NULL);
956 __rtnl_register(PF_CAN, RTM_DELROUTE, cgw_remove_job, NULL, NULL);
957
958 return 0;
959}
960
961static __exit void cgw_module_exit(void)
962{
963 rtnl_unregister_all(PF_CAN);
964
965 unregister_netdevice_notifier(¬ifier);
966
967 rtnl_lock();
968 cgw_remove_all_jobs();
969 rtnl_unlock();
970
971 rcu_barrier();
972
973 kmem_cache_destroy(cgw_cache);
974}
975
976module_init(cgw_module_init);
977module_exit(cgw_module_exit);
978