2 * gw.c - CAN frame Gateway/Router/Bridge with netlink interface
4 * Copyright (c) 2011 Volkswagen Group Electronic Research
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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.
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.
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
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>
62 #define CAN_GW_VERSION "20130117"
63 #define CAN_GW_NAME "can-gw"
65 MODULE_DESCRIPTION("PF_CAN netlink gateway");
66 MODULE_LICENSE("Dual BSD/GPL");
67 MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
68 MODULE_ALIAS(CAN_GW_NAME
);
70 #define CGW_MIN_HOPS 1
71 #define CGW_MAX_HOPS 6
72 #define CGW_DEFAULT_HOPS 1
74 static unsigned int max_hops __read_mostly
= CGW_DEFAULT_HOPS
;
75 module_param(max_hops
, uint
, S_IRUGO
);
76 MODULE_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
) ")");
82 static HLIST_HEAD(cgw_list
);
83 static struct notifier_block notifier
;
85 static struct kmem_cache
*cgw_cache __read_mostly
;
87 /* structure that contains the (on-the-fly) CAN frame modifications */
101 void (*modfunc
[MAX_MODFUNCTIONS
])(struct can_frame
*cf
,
104 /* CAN frame checksum calculation after CAN frame modifications */
106 struct cgw_csum_xor
xor;
107 struct cgw_csum_crc8 crc8
;
110 void (*xor)(struct can_frame
*cf
, struct cgw_csum_xor
*xor);
111 void (*crc8
)(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
);
117 * So far we just support CAN -> CAN routing and frame modifications.
119 * The internal can_can_gw structure contains data and attributes for
120 * a CAN -> CAN gateway job.
123 struct can_filter filter
;
128 /* list entry for CAN gateways jobs */
130 struct hlist_node list
;
137 /* CAN frame data source */
138 struct net_device
*dev
;
141 /* CAN frame data destination */
142 struct net_device
*dev
;
145 struct can_can_gw ccgw
;
152 /* modification functions that are invoked in the hot path in can_can_gw_rcv */
154 #define MODFUNC(func, op) static void func(struct can_frame *cf, \
155 struct cf_mod *mod) { op ; }
157 MODFUNC(mod_and_id
, cf
->can_id
&= mod
->modframe
.and.can_id
)
158 MODFUNC(mod_and_dlc
, cf
->can_dlc
&= mod
->modframe
.and.can_dlc
)
159 MODFUNC(mod_and_data
, *(u64
*)cf
->data
&= *(u64
*)mod
->modframe
.and.data
)
160 MODFUNC(mod_or_id
, cf
->can_id
|= mod
->modframe
.or.can_id
)
161 MODFUNC(mod_or_dlc
, cf
->can_dlc
|= mod
->modframe
.or.can_dlc
)
162 MODFUNC(mod_or_data
, *(u64
*)cf
->data
|= *(u64
*)mod
->modframe
.or.data
)
163 MODFUNC(mod_xor_id
, cf
->can_id
^= mod
->modframe
.xor.can_id
)
164 MODFUNC(mod_xor_dlc
, cf
->can_dlc
^= mod
->modframe
.xor.can_dlc
)
165 MODFUNC(mod_xor_data
, *(u64
*)cf
->data
^= *(u64
*)mod
->modframe
.xor.data
)
166 MODFUNC(mod_set_id
, cf
->can_id
= mod
->modframe
.set
.can_id
)
167 MODFUNC(mod_set_dlc
, cf
->can_dlc
= mod
->modframe
.set
.can_dlc
)
168 MODFUNC(mod_set_data
, *(u64
*)cf
->data
= *(u64
*)mod
->modframe
.set
.data
)
170 static inline void canframecpy(struct can_frame
*dst
, struct can_frame
*src
)
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.
178 dst
->can_id
= src
->can_id
;
179 dst
->can_dlc
= src
->can_dlc
;
180 *(u64
*)dst
->data
= *(u64
*)src
->data
;
183 static int cgw_chk_csum_parms(s8 fr
, s8 to
, s8 re
)
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])
194 if (fr
> -9 && fr
< 8 &&
202 static inline int calc_idx(int idx
, int rx_dlc
)
210 static void cgw_csum_xor_rel(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
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
;
218 if (from
< 0 || to
< 0 || res
< 0)
222 for (i
= from
; i
<= to
; i
++)
225 for (i
= from
; i
>= to
; i
--)
232 static void cgw_csum_xor_pos(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
234 u8 val
= xor->init_xor_val
;
237 for (i
= xor->from_idx
; i
<= xor->to_idx
; i
++)
240 cf
->data
[xor->result_idx
] = val
;
243 static void cgw_csum_xor_neg(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
245 u8 val
= xor->init_xor_val
;
248 for (i
= xor->from_idx
; i
>= xor->to_idx
; i
--)
251 cf
->data
[xor->result_idx
] = val
;
254 static void cgw_csum_crc8_rel(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
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
;
262 if (from
< 0 || to
< 0 || res
< 0)
266 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
267 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
269 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
270 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
273 switch (crc8
->profile
) {
275 case CGW_CRC8PRF_1U8
:
276 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
279 case CGW_CRC8PRF_16U8
:
280 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
283 case CGW_CRC8PRF_SFFID_XOR
:
284 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
285 (cf
->can_id
>> 8 & 0xFF)];
290 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
293 static void cgw_csum_crc8_pos(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
295 u8 crc
= crc8
->init_crc_val
;
298 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
299 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
301 switch (crc8
->profile
) {
303 case CGW_CRC8PRF_1U8
:
304 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
307 case CGW_CRC8PRF_16U8
:
308 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
311 case CGW_CRC8PRF_SFFID_XOR
:
312 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
313 (cf
->can_id
>> 8 & 0xFF)];
317 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
320 static void cgw_csum_crc8_neg(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
322 u8 crc
= crc8
->init_crc_val
;
325 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
326 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
328 switch (crc8
->profile
) {
330 case CGW_CRC8PRF_1U8
:
331 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
334 case CGW_CRC8PRF_16U8
:
335 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
338 case CGW_CRC8PRF_SFFID_XOR
:
339 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
340 (cf
->can_id
>> 8 & 0xFF)];
344 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
347 /* the receive & process & send function */
348 static void can_can_gw_rcv(struct sk_buff
*skb
, void *data
)
350 struct cgw_job
*gwj
= (struct cgw_job
*)data
;
351 struct can_frame
*cf
;
352 struct sk_buff
*nskb
;
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).
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.
367 #define cgw_hops(skb) ((skb)->csum_start)
369 BUG_ON(skb
->ip_summed
!= CHECKSUM_UNNECESSARY
);
371 if (cgw_hops(skb
) >= max_hops
) {
372 /* indicate deleted frames due to misconfiguration */
373 gwj
->deleted_frames
++;
377 if (!(gwj
->dst
.dev
->flags
& IFF_UP
)) {
378 gwj
->dropped_frames
++;
382 /* is sending the skb back to the incoming interface not allowed? */
383 if (!(gwj
->flags
& CGW_FLAGS_CAN_IIF_TX_OK
) &&
384 can_skb_prv(skb
)->ifindex
== gwj
->dst
.dev
->ifindex
)
388 * clone the given skb, which has not been done in can_rcv()
390 * When there is at least one modification function activated,
391 * we need to copy the skb as we want to modify skb->data.
393 if (gwj
->mod
.modfunc
[0])
394 nskb
= skb_copy(skb
, GFP_ATOMIC
);
396 nskb
= skb_clone(skb
, GFP_ATOMIC
);
399 gwj
->dropped_frames
++;
403 /* put the incremented hop counter in the cloned skb */
404 cgw_hops(nskb
) = cgw_hops(skb
) + 1;
405 nskb
->dev
= gwj
->dst
.dev
;
407 /* pointer to modifiable CAN frame */
408 cf
= (struct can_frame
*)nskb
->data
;
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
);
414 /* check for checksum updates when the CAN frame has been modified */
416 if (gwj
->mod
.csumfunc
.crc8
)
417 (*gwj
->mod
.csumfunc
.crc8
)(cf
, &gwj
->mod
.csum
.crc8
);
419 if (gwj
->mod
.csumfunc
.xor)
420 (*gwj
->mod
.csumfunc
.xor)(cf
, &gwj
->mod
.csum
.xor);
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;
427 /* send to netdevice */
428 if (can_send(nskb
, gwj
->flags
& CGW_FLAGS_CAN_ECHO
))
429 gwj
->dropped_frames
++;
431 gwj
->handled_frames
++;
434 static inline int cgw_register_filter(struct cgw_job
*gwj
)
436 return can_rx_register(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
437 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
,
441 static inline void cgw_unregister_filter(struct cgw_job
*gwj
)
443 can_rx_unregister(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
444 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
, gwj
);
447 static int cgw_notifier(struct notifier_block
*nb
,
448 unsigned long msg
, void *data
)
450 struct net_device
*dev
= (struct net_device
*)data
;
452 if (!net_eq(dev_net(dev
), &init_net
))
454 if (dev
->type
!= ARPHRD_CAN
)
457 if (msg
== NETDEV_UNREGISTER
) {
459 struct cgw_job
*gwj
= NULL
;
460 struct hlist_node
*n
, *nx
;
464 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
466 if (gwj
->src
.dev
== dev
|| gwj
->dst
.dev
== dev
) {
467 hlist_del(&gwj
->list
);
468 cgw_unregister_filter(gwj
);
477 static int cgw_put_job(struct sk_buff
*skb
, struct cgw_job
*gwj
, int type
,
478 u32 pid
, u32 seq
, int flags
)
480 struct cgw_frame_mod mb
;
481 struct rtcanmsg
*rtcan
;
482 struct nlmsghdr
*nlh
;
484 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*rtcan
), flags
);
488 rtcan
= nlmsg_data(nlh
);
489 rtcan
->can_family
= AF_CAN
;
490 rtcan
->gwtype
= gwj
->gwtype
;
491 rtcan
->flags
= gwj
->flags
;
493 /* add statistics if available */
495 if (gwj
->handled_frames
) {
496 if (nla_put_u32(skb
, CGW_HANDLED
, gwj
->handled_frames
) < 0)
500 if (gwj
->dropped_frames
) {
501 if (nla_put_u32(skb
, CGW_DROPPED
, gwj
->dropped_frames
) < 0)
505 if (gwj
->deleted_frames
) {
506 if (nla_put_u32(skb
, CGW_DELETED
, gwj
->deleted_frames
) < 0)
510 /* check non default settings of attributes */
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)
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)
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)
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)
540 if (gwj
->mod
.csumfunc
.crc8
) {
541 if (nla_put(skb
, CGW_CS_CRC8
, CGW_CS_CRC8_LEN
,
542 &gwj
->mod
.csum
.crc8
) < 0)
546 if (gwj
->mod
.csumfunc
.xor) {
547 if (nla_put(skb
, CGW_CS_XOR
, CGW_CS_XOR_LEN
,
548 &gwj
->mod
.csum
.xor) < 0)
552 if (gwj
->gwtype
== CGW_TYPE_CAN_CAN
) {
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)
560 if (nla_put_u32(skb
, CGW_SRC_IF
, gwj
->ccgw
.src_idx
) < 0)
563 if (nla_put_u32(skb
, CGW_DST_IF
, gwj
->ccgw
.dst_idx
) < 0)
567 return nlmsg_end(skb
, nlh
);
570 nlmsg_cancel(skb
, nlh
);
574 /* Dump information about all CAN gateway jobs, in response to RTM_GETROUTE */
575 static int cgw_dump_jobs(struct sk_buff
*skb
, struct netlink_callback
*cb
)
577 struct cgw_job
*gwj
= NULL
;
578 struct hlist_node
*n
;
580 int s_idx
= cb
->args
[0];
583 hlist_for_each_entry_rcu(gwj
, n
, &cgw_list
, list
) {
587 if (cgw_put_job(skb
, gwj
, RTM_NEWROUTE
, NETLINK_CB(cb
->skb
).portid
,
588 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
) < 0)
600 static const struct nla_policy cgw_policy
[CGW_MAX
+1] = {
601 [CGW_MOD_AND
] = { .len
= sizeof(struct cgw_frame_mod
) },
602 [CGW_MOD_OR
] = { .len
= sizeof(struct cgw_frame_mod
) },
603 [CGW_MOD_XOR
] = { .len
= sizeof(struct cgw_frame_mod
) },
604 [CGW_MOD_SET
] = { .len
= sizeof(struct cgw_frame_mod
) },
605 [CGW_CS_XOR
] = { .len
= sizeof(struct cgw_csum_xor
) },
606 [CGW_CS_CRC8
] = { .len
= sizeof(struct cgw_csum_crc8
) },
607 [CGW_SRC_IF
] = { .type
= NLA_U32
},
608 [CGW_DST_IF
] = { .type
= NLA_U32
},
609 [CGW_FILTER
] = { .len
= sizeof(struct can_filter
) },
612 /* check for common and gwtype specific attributes */
613 static int cgw_parse_attr(struct nlmsghdr
*nlh
, struct cf_mod
*mod
,
614 u8 gwtype
, void *gwtypeattr
)
616 struct nlattr
*tb
[CGW_MAX
+1];
617 struct cgw_frame_mod mb
;
621 /* initialize modification & checksum data space */
622 memset(mod
, 0, sizeof(*mod
));
624 err
= nlmsg_parse(nlh
, sizeof(struct rtcanmsg
), tb
, CGW_MAX
,
629 /* check for AND/OR/XOR/SET modifications */
631 if (tb
[CGW_MOD_AND
]) {
632 nla_memcpy(&mb
, tb
[CGW_MOD_AND
], CGW_MODATTR_LEN
);
634 canframecpy(&mod
->modframe
.and, &mb
.cf
);
635 mod
->modtype
.and = mb
.modtype
;
637 if (mb
.modtype
& CGW_MOD_ID
)
638 mod
->modfunc
[modidx
++] = mod_and_id
;
640 if (mb
.modtype
& CGW_MOD_DLC
)
641 mod
->modfunc
[modidx
++] = mod_and_dlc
;
643 if (mb
.modtype
& CGW_MOD_DATA
)
644 mod
->modfunc
[modidx
++] = mod_and_data
;
647 if (tb
[CGW_MOD_OR
]) {
648 nla_memcpy(&mb
, tb
[CGW_MOD_OR
], CGW_MODATTR_LEN
);
650 canframecpy(&mod
->modframe
.or, &mb
.cf
);
651 mod
->modtype
.or = mb
.modtype
;
653 if (mb
.modtype
& CGW_MOD_ID
)
654 mod
->modfunc
[modidx
++] = mod_or_id
;
656 if (mb
.modtype
& CGW_MOD_DLC
)
657 mod
->modfunc
[modidx
++] = mod_or_dlc
;
659 if (mb
.modtype
& CGW_MOD_DATA
)
660 mod
->modfunc
[modidx
++] = mod_or_data
;
663 if (tb
[CGW_MOD_XOR
]) {
664 nla_memcpy(&mb
, tb
[CGW_MOD_XOR
], CGW_MODATTR_LEN
);
666 canframecpy(&mod
->modframe
.xor, &mb
.cf
);
667 mod
->modtype
.xor = mb
.modtype
;
669 if (mb
.modtype
& CGW_MOD_ID
)
670 mod
->modfunc
[modidx
++] = mod_xor_id
;
672 if (mb
.modtype
& CGW_MOD_DLC
)
673 mod
->modfunc
[modidx
++] = mod_xor_dlc
;
675 if (mb
.modtype
& CGW_MOD_DATA
)
676 mod
->modfunc
[modidx
++] = mod_xor_data
;
679 if (tb
[CGW_MOD_SET
]) {
680 nla_memcpy(&mb
, tb
[CGW_MOD_SET
], CGW_MODATTR_LEN
);
682 canframecpy(&mod
->modframe
.set
, &mb
.cf
);
683 mod
->modtype
.set
= mb
.modtype
;
685 if (mb
.modtype
& CGW_MOD_ID
)
686 mod
->modfunc
[modidx
++] = mod_set_id
;
688 if (mb
.modtype
& CGW_MOD_DLC
)
689 mod
->modfunc
[modidx
++] = mod_set_dlc
;
691 if (mb
.modtype
& CGW_MOD_DATA
)
692 mod
->modfunc
[modidx
++] = mod_set_data
;
695 /* check for checksum operations after CAN frame modifications */
698 if (tb
[CGW_CS_CRC8
]) {
699 struct cgw_csum_crc8
*c
= nla_data(tb
[CGW_CS_CRC8
]);
701 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
706 nla_memcpy(&mod
->csum
.crc8
, tb
[CGW_CS_CRC8
],
710 * select dedicated processing function to reduce
711 * runtime operations in receive hot path.
713 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
715 mod
->csumfunc
.crc8
= cgw_csum_crc8_rel
;
716 else if (c
->from_idx
<= c
->to_idx
)
717 mod
->csumfunc
.crc8
= cgw_csum_crc8_pos
;
719 mod
->csumfunc
.crc8
= cgw_csum_crc8_neg
;
722 if (tb
[CGW_CS_XOR
]) {
723 struct cgw_csum_xor
*c
= nla_data(tb
[CGW_CS_XOR
]);
725 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
730 nla_memcpy(&mod
->csum
.xor, tb
[CGW_CS_XOR
],
734 * select dedicated processing function to reduce
735 * runtime operations in receive hot path.
737 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
739 mod
->csumfunc
.xor = cgw_csum_xor_rel
;
740 else if (c
->from_idx
<= c
->to_idx
)
741 mod
->csumfunc
.xor = cgw_csum_xor_pos
;
743 mod
->csumfunc
.xor = cgw_csum_xor_neg
;
747 if (gwtype
== CGW_TYPE_CAN_CAN
) {
749 /* check CGW_TYPE_CAN_CAN specific attributes */
751 struct can_can_gw
*ccgw
= (struct can_can_gw
*)gwtypeattr
;
752 memset(ccgw
, 0, sizeof(*ccgw
));
754 /* check for can_filter in attributes */
756 nla_memcpy(&ccgw
->filter
, tb
[CGW_FILTER
],
757 sizeof(struct can_filter
));
761 /* specifying two interfaces is mandatory */
762 if (!tb
[CGW_SRC_IF
] || !tb
[CGW_DST_IF
])
765 ccgw
->src_idx
= nla_get_u32(tb
[CGW_SRC_IF
]);
766 ccgw
->dst_idx
= nla_get_u32(tb
[CGW_DST_IF
]);
768 /* both indices set to 0 for flushing all routing entries */
769 if (!ccgw
->src_idx
&& !ccgw
->dst_idx
)
772 /* only one index set to 0 is an error */
773 if (!ccgw
->src_idx
|| !ccgw
->dst_idx
)
777 /* add the checks for other gwtypes here */
782 static int cgw_create_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
789 if (!capable(CAP_NET_ADMIN
))
792 if (nlmsg_len(nlh
) < sizeof(*r
))
796 if (r
->can_family
!= AF_CAN
)
797 return -EPFNOSUPPORT
;
799 /* so far we only support CAN -> CAN routings */
800 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
803 gwj
= kmem_cache_alloc(cgw_cache
, GFP_KERNEL
);
807 gwj
->handled_frames
= 0;
808 gwj
->dropped_frames
= 0;
809 gwj
->deleted_frames
= 0;
810 gwj
->flags
= r
->flags
;
811 gwj
->gwtype
= r
->gwtype
;
813 err
= cgw_parse_attr(nlh
, &gwj
->mod
, CGW_TYPE_CAN_CAN
, &gwj
->ccgw
);
819 /* ifindex == 0 is not allowed for job creation */
820 if (!gwj
->ccgw
.src_idx
|| !gwj
->ccgw
.dst_idx
)
823 gwj
->src
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.src_idx
);
828 /* check for CAN netdev not using header_ops - see gw_rcv() */
829 if (gwj
->src
.dev
->type
!= ARPHRD_CAN
|| gwj
->src
.dev
->header_ops
)
832 gwj
->dst
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.dst_idx
);
837 /* check for CAN netdev not using header_ops - see gw_rcv() */
838 if (gwj
->dst
.dev
->type
!= ARPHRD_CAN
|| gwj
->dst
.dev
->header_ops
)
839 goto put_src_dst_out
;
843 err
= cgw_register_filter(gwj
);
845 hlist_add_head_rcu(&gwj
->list
, &cgw_list
);
848 dev_put(gwj
->dst
.dev
);
850 dev_put(gwj
->src
.dev
);
853 kmem_cache_free(cgw_cache
, gwj
);
858 static void cgw_remove_all_jobs(void)
860 struct cgw_job
*gwj
= NULL
;
861 struct hlist_node
*n
, *nx
;
865 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
866 hlist_del(&gwj
->list
);
867 cgw_unregister_filter(gwj
);
872 static int cgw_remove_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
874 struct cgw_job
*gwj
= NULL
;
875 struct hlist_node
*n
, *nx
;
878 struct can_can_gw ccgw
;
881 if (!capable(CAP_NET_ADMIN
))
884 if (nlmsg_len(nlh
) < sizeof(*r
))
888 if (r
->can_family
!= AF_CAN
)
889 return -EPFNOSUPPORT
;
891 /* so far we only support CAN -> CAN routings */
892 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
895 err
= cgw_parse_attr(nlh
, &mod
, CGW_TYPE_CAN_CAN
, &ccgw
);
899 /* two interface indices both set to 0 => remove all entries */
900 if (!ccgw
.src_idx
&& !ccgw
.dst_idx
) {
901 cgw_remove_all_jobs();
909 /* remove only the first matching entry */
910 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
912 if (gwj
->flags
!= r
->flags
)
915 if (memcmp(&gwj
->mod
, &mod
, sizeof(mod
)))
918 /* if (r->gwtype == CGW_TYPE_CAN_CAN) - is made sure here */
919 if (memcmp(&gwj
->ccgw
, &ccgw
, sizeof(ccgw
)))
922 hlist_del(&gwj
->list
);
923 cgw_unregister_filter(gwj
);
932 static __init
int cgw_module_init(void)
934 /* sanitize given module parameter */
935 max_hops
= clamp_t(unsigned int, max_hops
, CGW_MIN_HOPS
, CGW_MAX_HOPS
);
937 pr_info("can: netlink gateway (rev " CAN_GW_VERSION
") max_hops=%d\n",
940 cgw_cache
= kmem_cache_create("can_gw", sizeof(struct cgw_job
),
947 notifier
.notifier_call
= cgw_notifier
;
948 register_netdevice_notifier(¬ifier
);
950 if (__rtnl_register(PF_CAN
, RTM_GETROUTE
, NULL
, cgw_dump_jobs
, NULL
)) {
951 unregister_netdevice_notifier(¬ifier
);
952 kmem_cache_destroy(cgw_cache
);
956 /* Only the first call to __rtnl_register can fail */
957 __rtnl_register(PF_CAN
, RTM_NEWROUTE
, cgw_create_job
, NULL
, NULL
);
958 __rtnl_register(PF_CAN
, RTM_DELROUTE
, cgw_remove_job
, NULL
, NULL
);
963 static __exit
void cgw_module_exit(void)
965 rtnl_unregister_all(PF_CAN
);
967 unregister_netdevice_notifier(¬ifier
);
970 cgw_remove_all_jobs();
973 rcu_barrier(); /* Wait for completion of call_rcu()'s */
975 kmem_cache_destroy(cgw_cache
);
978 module_init(cgw_module_init
);
979 module_exit(cgw_module_exit
);
This page took 0.050197 seconds and 6 git commands to generate.