blob: 2f291f961a170018f1464fb50f4faa272887a50d [file] [log] [blame]
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +00001/*
2 * gw.c - CAN frame Gateway/Router/Bridge with netlink interface
3 *
4 * Copyright (c) 2011 Volkswagen Group Electronic Research
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Volkswagen nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * Alternatively, provided that this notice is retained in full, this
20 * software may be distributed under the terms of the GNU General
21 * Public License ("GPL") version 2, in which case the provisions of the
22 * GPL apply INSTEAD OF those given above.
23 *
24 * The provided data structures and external interfaces from this code
25 * are not restricted to be used by modules with a GPL compatible license.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
38 * DAMAGE.
39 *
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000040 */
41
42#include <linux/module.h>
43#include <linux/init.h>
44#include <linux/types.h>
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +010045#include <linux/kernel.h>
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000046#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>
Oliver Hartkoppd904d3e2013-01-17 18:43:41 +010056#include <linux/can/skb.h>
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000057#include <linux/can/gw.h>
58#include <net/rtnetlink.h>
59#include <net/net_namespace.h>
60#include <net/sock.h>
61
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +010062#define CAN_GW_VERSION "20130117"
63#define CAN_GW_NAME "can-gw"
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000064
65MODULE_DESCRIPTION("PF_CAN netlink gateway");
66MODULE_LICENSE("Dual BSD/GPL");
67MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +010068MODULE_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) ")");
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000081
Daniel Balutaa75afd42012-03-26 02:05:50 +030082static HLIST_HEAD(cgw_list);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +000083static struct notifier_block notifier;
84
85static struct kmem_cache *cgw_cache __read_mostly;
86
87/* structure that contains the (on-the-fly) CAN frame modifications */
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 /* CAN frame checksum calculation after CAN frame modifications */
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 * So far we just support CAN -> CAN routing and frame modifications.
118 *
119 * The internal can_can_gw structure contains data and attributes for
120 * a CAN -> CAN gateway job.
121 */
122struct can_can_gw {
123 struct can_filter filter;
124 int src_idx;
125 int dst_idx;
126};
127
128/* list entry for CAN gateways jobs */
129struct cgw_job {
130 struct hlist_node list;
131 struct rcu_head rcu;
132 u32 handled_frames;
133 u32 dropped_frames;
Oliver Hartkoppe6afa002013-01-17 18:43:46 +0100134 u32 deleted_frames;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000135 struct cf_mod mod;
136 union {
137 /* CAN frame data source */
138 struct net_device *dev;
139 } src;
140 union {
141 /* CAN frame data destination */
142 struct net_device *dev;
143 } dst;
144 union {
145 struct can_can_gw ccgw;
146 /* tbc */
147 };
148 u8 gwtype;
149 u16 flags;
150};
151
152/* modification functions that are invoked in the hot path in can_can_gw_rcv */
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 * Copy the struct members separately to ensure that no uninitialized
174 * data are copied in the 3 bytes hole of the struct. This is needed
175 * to make easy compares of the data in the struct cf_mod.
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 * absolute dlc values 0 .. 7 => 0 .. 7, e.g. data [0]
187 * relative to received dlc -1 .. -8 :
188 * e.g. for received dlc = 8
189 * -1 => index = 7 (data[7])
190 * -3 => index = 5 (data[5])
191 * -8 => index = 0 (data[0])
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/* the receive & process & send function */
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
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +0100355 /*
356 * Do not handle CAN frames routed more than 'max_hops' times.
357 * In general we should never catch this delimiter which is intended
358 * to cover a misconfiguration protection (e.g. circular CAN routes).
359 *
360 * The Controller Area Network controllers only accept CAN frames with
361 * correct CRCs - which are not visible in the controller registers.
362 * According to skbuff.h documentation the csum_start element for IP
363 * checksums is undefined/unsued when ip_summed == CHECKSUM_UNNECESSARY.
364 * Only CAN skbs can be processed here which already have this property.
365 */
366
367#define cgw_hops(skb) ((skb)->csum_start)
368
369 BUG_ON(skb->ip_summed != CHECKSUM_UNNECESSARY);
370
Oliver Hartkoppe6afa002013-01-17 18:43:46 +0100371 if (cgw_hops(skb) >= max_hops) {
372 /* indicate deleted frames due to misconfiguration */
373 gwj->deleted_frames++;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000374 return;
Oliver Hartkoppe6afa002013-01-17 18:43:46 +0100375 }
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000376
377 if (!(gwj->dst.dev->flags & IFF_UP)) {
378 gwj->dropped_frames++;
379 return;
380 }
381
Oliver Hartkoppd904d3e2013-01-17 18:43:41 +0100382 /* is sending the skb back to the incoming interface not allowed? */
383 if (!(gwj->flags & CGW_FLAGS_CAN_IIF_TX_OK) &&
Oliver Hartkopp2bf34402013-01-28 08:33:33 +0000384 can_skb_prv(skb)->ifindex == gwj->dst.dev->ifindex)
Oliver Hartkoppd904d3e2013-01-17 18:43:41 +0100385 return;
386
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000387 /*
388 * clone the given skb, which has not been done in can_rcv()
389 *
390 * When there is at least one modification function activated,
391 * we need to copy the skb as we want to modify skb->data.
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
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +0100403 /* put the incremented hop counter in the cloned skb */
404 cgw_hops(nskb) = cgw_hops(skb) + 1;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000405 nskb->dev = gwj->dst.dev;
406
407 /* pointer to modifiable CAN frame */
408 cf = (struct can_frame *)nskb->data;
409
410 /* perform preprocessed modification functions if there are any */
411 while (modidx < MAX_MODFUNCTIONS && gwj->mod.modfunc[modidx])
412 (*gwj->mod.modfunc[modidx++])(cf, &gwj->mod);
413
414 /* check for checksum updates when the CAN frame has been modified */
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 /* clear the skb timestamp if not configured the other way */
424 if (!(gwj->flags & CGW_FLAGS_CAN_SRC_TSTAMP))
425 nskb->tstamp.tv64 = 0;
426
427 /* send to netdevice */
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,
Jiri Pirko351638e2013-05-28 01:30:21 +0000448 unsigned long msg, void *ptr)
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000449{
Jiri Pirko351638e2013-05-28 01:30:21 +0000450 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000451
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;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800460 struct hlist_node *nx;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000461
462 ASSERT_RTNL();
463
Sasha Levinb67bfe02013-02-27 17:06:00 -0800464 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000465
466 if (gwj->src.dev == dev || gwj->dst.dev == dev) {
467 hlist_del(&gwj->list);
468 cgw_unregister_filter(gwj);
Wei Yongjun3480a212013-04-09 14:16:04 +0800469 kmem_cache_free(cgw_cache, gwj);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000470 }
471 }
472 }
473
474 return NOTIFY_DONE;
475}
476
Thomas Graf1da0faa32012-07-05 14:19:57 +0200477static int cgw_put_job(struct sk_buff *skb, struct cgw_job *gwj, int type,
478 u32 pid, u32 seq, int flags)
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000479{
480 struct cgw_frame_mod mb;
481 struct rtcanmsg *rtcan;
Thomas Graf1da0faa32012-07-05 14:19:57 +0200482 struct nlmsghdr *nlh;
483
484 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtcan), flags);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000485 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 /* add statistics if available */
494
495 if (gwj->handled_frames) {
496 if (nla_put_u32(skb, CGW_HANDLED, gwj->handled_frames) < 0)
497 goto cancel;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000498 }
499
500 if (gwj->dropped_frames) {
501 if (nla_put_u32(skb, CGW_DROPPED, gwj->dropped_frames) < 0)
502 goto cancel;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000503 }
504
Oliver Hartkoppe6afa002013-01-17 18:43:46 +0100505 if (gwj->deleted_frames) {
506 if (nla_put_u32(skb, CGW_DELETED, gwj->deleted_frames) < 0)
507 goto cancel;
508 }
509
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000510 /* check non default settings of attributes */
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000517 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000524 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000531 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000538 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000544 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000550 }
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;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000558 }
559
560 if (nla_put_u32(skb, CGW_SRC_IF, gwj->ccgw.src_idx) < 0)
561 goto cancel;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000562
563 if (nla_put_u32(skb, CGW_DST_IF, gwj->ccgw.dst_idx) < 0)
564 goto cancel;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000565 }
566
Thomas Graf6eaf53c2012-07-05 14:19:55 +0200567 return nlmsg_end(skb, nlh);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000568
569cancel:
570 nlmsg_cancel(skb, nlh);
571 return -EMSGSIZE;
572}
573
574/* Dump information about all CAN gateway jobs, in response to RTM_GETROUTE */
575static int cgw_dump_jobs(struct sk_buff *skb, struct netlink_callback *cb)
576{
577 struct cgw_job *gwj = NULL;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000578 int idx = 0;
579 int s_idx = cb->args[0];
580
581 rcu_read_lock();
Sasha Levinb67bfe02013-02-27 17:06:00 -0800582 hlist_for_each_entry_rcu(gwj, &cgw_list, list) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000583 if (idx < s_idx)
584 goto cont;
585
Eric W. Biederman15e47302012-09-07 20:12:54 +0000586 if (cgw_put_job(skb, gwj, RTM_NEWROUTE, NETLINK_CB(cb->skb).portid,
Thomas Graf1da0faa32012-07-05 14:19:57 +0200587 cb->nlh->nlmsg_seq, NLM_F_MULTI) < 0)
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000588 break;
589cont:
590 idx++;
591 }
592 rcu_read_unlock();
593
594 cb->args[0] = idx;
595
596 return skb->len;
597}
598
Thomas Graf732d35f2012-07-05 14:19:56 +0200599static 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
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000611/* check for common and gwtype specific attributes */
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 /* initialize modification & checksum data space */
621 memset(mod, 0, sizeof(*mod));
622
Thomas Graf732d35f2012-07-05 14:19:56 +0200623 err = nlmsg_parse(nlh, sizeof(struct rtcanmsg), tb, CGW_MAX,
624 cgw_policy);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000625 if (err < 0)
626 return err;
627
628 /* check for AND/OR/XOR/SET modifications */
629
Thomas Graf732d35f2012-07-05 14:19:56 +0200630 if (tb[CGW_MOD_AND]) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000631 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
Thomas Graf732d35f2012-07-05 14:19:56 +0200646 if (tb[CGW_MOD_OR]) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000647 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
Thomas Graf732d35f2012-07-05 14:19:56 +0200662 if (tb[CGW_MOD_XOR]) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000663 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
Thomas Graf732d35f2012-07-05 14:19:56 +0200678 if (tb[CGW_MOD_SET]) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000679 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 /* check for checksum operations after CAN frame modifications */
695 if (modidx) {
696
Thomas Graf732d35f2012-07-05 14:19:56 +0200697 if (tb[CGW_CS_CRC8]) {
Thomas Graf5d91efa2012-07-05 14:19:58 +0200698 struct cgw_csum_crc8 *c = nla_data(tb[CGW_CS_CRC8]);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000699
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 * select dedicated processing function to reduce
710 * runtime operations in receive hot path.
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
Thomas Graf732d35f2012-07-05 14:19:56 +0200721 if (tb[CGW_CS_XOR]) {
Thomas Graf5d91efa2012-07-05 14:19:58 +0200722 struct cgw_csum_xor *c = nla_data(tb[CGW_CS_XOR]);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000723
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 * select dedicated processing function to reduce
734 * runtime operations in receive hot path.
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 /* check CGW_TYPE_CAN_CAN specific attributes */
749
750 struct can_can_gw *ccgw = (struct can_can_gw *)gwtypeattr;
751 memset(ccgw, 0, sizeof(*ccgw));
752
753 /* check for can_filter in attributes */
Thomas Graf732d35f2012-07-05 14:19:56 +0200754 if (tb[CGW_FILTER])
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000755 nla_memcpy(&ccgw->filter, tb[CGW_FILTER],
756 sizeof(struct can_filter));
757
758 err = -ENODEV;
759
760 /* specifying two interfaces is mandatory */
761 if (!tb[CGW_SRC_IF] || !tb[CGW_DST_IF])
762 return err;
763
Thomas Graf732d35f2012-07-05 14:19:56 +0200764 ccgw->src_idx = nla_get_u32(tb[CGW_SRC_IF]);
765 ccgw->dst_idx = nla_get_u32(tb[CGW_DST_IF]);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000766
767 /* both indices set to 0 for flushing all routing entries */
768 if (!ccgw->src_idx && !ccgw->dst_idx)
769 return 0;
770
771 /* only one index set to 0 is an error */
772 if (!ccgw->src_idx || !ccgw->dst_idx)
773 return err;
774 }
775
776 /* add the checks for other gwtypes here */
777
778 return 0;
779}
780
Thomas Graf661d2962013-03-21 07:45:29 +0000781static int cgw_create_job(struct sk_buff *skb, struct nlmsghdr *nlh)
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000782{
783 struct rtcanmsg *r;
784 struct cgw_job *gwj;
785 int err = 0;
786
Eric W. Biedermandfc47ef2012-11-16 03:03:00 +0000787 if (!capable(CAP_NET_ADMIN))
788 return -EPERM;
789
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000790 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 /* so far we only support CAN -> CAN routings */
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;
Oliver Hartkoppe6afa002013-01-17 18:43:46 +0100807 gwj->deleted_frames = 0;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000808 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 /* ifindex == 0 is not allowed for job creation */
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 /* check for CAN netdev not using header_ops - see gw_rcv() */
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 /* check for CAN netdev not using header_ops - see gw_rcv() */
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;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800859 struct hlist_node *nx;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000860
861 ASSERT_RTNL();
862
Sasha Levinb67bfe02013-02-27 17:06:00 -0800863 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000864 hlist_del(&gwj->list);
865 cgw_unregister_filter(gwj);
Wei Yongjun3480a212013-04-09 14:16:04 +0800866 kmem_cache_free(cgw_cache, gwj);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000867 }
868}
869
Thomas Graf661d2962013-03-21 07:45:29 +0000870static int cgw_remove_job(struct sk_buff *skb, struct nlmsghdr *nlh)
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000871{
872 struct cgw_job *gwj = NULL;
Sasha Levinb67bfe02013-02-27 17:06:00 -0800873 struct hlist_node *nx;
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000874 struct rtcanmsg *r;
875 struct cf_mod mod;
876 struct can_can_gw ccgw;
877 int err = 0;
878
Eric W. Biedermandfc47ef2012-11-16 03:03:00 +0000879 if (!capable(CAP_NET_ADMIN))
880 return -EPERM;
881
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000882 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 /* so far we only support CAN -> CAN routings */
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 /* two interface indices both set to 0 => remove all entries */
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 /* remove only the first matching entry */
Sasha Levinb67bfe02013-02-27 17:06:00 -0800908 hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000909
910 if (gwj->flags != r->flags)
911 continue;
912
913 if (memcmp(&gwj->mod, &mod, sizeof(mod)))
914 continue;
915
916 /* if (r->gwtype == CGW_TYPE_CAN_CAN) - is made sure here */
917 if (memcmp(&gwj->ccgw, &ccgw, sizeof(ccgw)))
918 continue;
919
920 hlist_del(&gwj->list);
921 cgw_unregister_filter(gwj);
Wei Yongjun3480a212013-04-09 14:16:04 +0800922 kmem_cache_free(cgw_cache, gwj);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000923 err = 0;
924 break;
925 }
926
927 return err;
928}
929
930static __init int cgw_module_init(void)
931{
Oliver Hartkoppbe286ba2013-01-17 18:43:44 +0100932 /* sanitize given module parameter */
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);
Oliver Hartkoppc1aabdf2011-09-01 04:23:23 +0000937
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 /* set notifier */
945 notifier.notifier_call = cgw_notifier;
946 register_netdevice_notifier(&notifier);
947
948 if (__rtnl_register(PF_CAN, RTM_GETROUTE, NULL, cgw_dump_jobs, NULL)) {
949 unregister_netdevice_notifier(&notifier);
950 kmem_cache_destroy(cgw_cache);
951 return -ENOBUFS;
952 }
953
954 /* Only the first call to __rtnl_register can fail */
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(&notifier);
966
967 rtnl_lock();
968 cgw_remove_all_jobs();
969 rtnl_unlock();
970
971 rcu_barrier(); /* Wait for completion of call_rcu()'s */
972
973 kmem_cache_destroy(cgw_cache);
974}
975
976module_init(cgw_module_init);
977module_exit(cgw_module_exit);