]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - net/can/gw.c
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
;
136 /* CAN frame data source */
137 struct net_device
*dev
;
140 /* CAN frame data destination */
141 struct net_device
*dev
;
144 struct can_can_gw ccgw
;
151 /* modification functions that are invoked in the hot path in can_can_gw_rcv */
153 #define MODFUNC(func, op) static void func(struct can_frame *cf, \
154 struct cf_mod *mod) { op ; }
156 MODFUNC(mod_and_id
, cf
->can_id
&= mod
->modframe
.and.can_id
)
157 MODFUNC(mod_and_dlc
, cf
->can_dlc
&= mod
->modframe
.and.can_dlc
)
158 MODFUNC(mod_and_data
, *(u64
*)cf
->data
&= *(u64
*)mod
->modframe
.and.data
)
159 MODFUNC(mod_or_id
, cf
->can_id
|= mod
->modframe
.or.can_id
)
160 MODFUNC(mod_or_dlc
, cf
->can_dlc
|= mod
->modframe
.or.can_dlc
)
161 MODFUNC(mod_or_data
, *(u64
*)cf
->data
|= *(u64
*)mod
->modframe
.or.data
)
162 MODFUNC(mod_xor_id
, cf
->can_id
^= mod
->modframe
.xor.can_id
)
163 MODFUNC(mod_xor_dlc
, cf
->can_dlc
^= mod
->modframe
.xor.can_dlc
)
164 MODFUNC(mod_xor_data
, *(u64
*)cf
->data
^= *(u64
*)mod
->modframe
.xor.data
)
165 MODFUNC(mod_set_id
, cf
->can_id
= mod
->modframe
.set
.can_id
)
166 MODFUNC(mod_set_dlc
, cf
->can_dlc
= mod
->modframe
.set
.can_dlc
)
167 MODFUNC(mod_set_data
, *(u64
*)cf
->data
= *(u64
*)mod
->modframe
.set
.data
)
169 static inline void canframecpy(struct can_frame
*dst
, struct can_frame
*src
)
172 * Copy the struct members separately to ensure that no uninitialized
173 * data are copied in the 3 bytes hole of the struct. This is needed
174 * to make easy compares of the data in the struct cf_mod.
177 dst
->can_id
= src
->can_id
;
178 dst
->can_dlc
= src
->can_dlc
;
179 *(u64
*)dst
->data
= *(u64
*)src
->data
;
182 static int cgw_chk_csum_parms(s8 fr
, s8 to
, s8 re
)
185 * absolute dlc values 0 .. 7 => 0 .. 7, e.g. data [0]
186 * relative to received dlc -1 .. -8 :
187 * e.g. for received dlc = 8
188 * -1 => index = 7 (data[7])
189 * -3 => index = 5 (data[5])
190 * -8 => index = 0 (data[0])
193 if (fr
> -9 && fr
< 8 &&
201 static inline int calc_idx(int idx
, int rx_dlc
)
209 static void cgw_csum_xor_rel(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
211 int from
= calc_idx(xor->from_idx
, cf
->can_dlc
);
212 int to
= calc_idx(xor->to_idx
, cf
->can_dlc
);
213 int res
= calc_idx(xor->result_idx
, cf
->can_dlc
);
214 u8 val
= xor->init_xor_val
;
217 if (from
< 0 || to
< 0 || res
< 0)
221 for (i
= from
; i
<= to
; i
++)
224 for (i
= from
; i
>= to
; i
--)
231 static void cgw_csum_xor_pos(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
233 u8 val
= xor->init_xor_val
;
236 for (i
= xor->from_idx
; i
<= xor->to_idx
; i
++)
239 cf
->data
[xor->result_idx
] = val
;
242 static void cgw_csum_xor_neg(struct can_frame
*cf
, struct cgw_csum_xor
*xor)
244 u8 val
= xor->init_xor_val
;
247 for (i
= xor->from_idx
; i
>= xor->to_idx
; i
--)
250 cf
->data
[xor->result_idx
] = val
;
253 static void cgw_csum_crc8_rel(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
255 int from
= calc_idx(crc8
->from_idx
, cf
->can_dlc
);
256 int to
= calc_idx(crc8
->to_idx
, cf
->can_dlc
);
257 int res
= calc_idx(crc8
->result_idx
, cf
->can_dlc
);
258 u8 crc
= crc8
->init_crc_val
;
261 if (from
< 0 || to
< 0 || res
< 0)
265 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
266 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
268 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
269 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
272 switch (crc8
->profile
) {
274 case CGW_CRC8PRF_1U8
:
275 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
278 case CGW_CRC8PRF_16U8
:
279 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
282 case CGW_CRC8PRF_SFFID_XOR
:
283 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
284 (cf
->can_id
>> 8 & 0xFF)];
289 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
292 static void cgw_csum_crc8_pos(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
294 u8 crc
= crc8
->init_crc_val
;
297 for (i
= crc8
->from_idx
; i
<= crc8
->to_idx
; i
++)
298 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
300 switch (crc8
->profile
) {
302 case CGW_CRC8PRF_1U8
:
303 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
306 case CGW_CRC8PRF_16U8
:
307 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
310 case CGW_CRC8PRF_SFFID_XOR
:
311 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
312 (cf
->can_id
>> 8 & 0xFF)];
316 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
319 static void cgw_csum_crc8_neg(struct can_frame
*cf
, struct cgw_csum_crc8
*crc8
)
321 u8 crc
= crc8
->init_crc_val
;
324 for (i
= crc8
->from_idx
; i
>= crc8
->to_idx
; i
--)
325 crc
= crc8
->crctab
[crc
^cf
->data
[i
]];
327 switch (crc8
->profile
) {
329 case CGW_CRC8PRF_1U8
:
330 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[0]];
333 case CGW_CRC8PRF_16U8
:
334 crc
= crc8
->crctab
[crc
^crc8
->profile_data
[cf
->data
[1] & 0xF]];
337 case CGW_CRC8PRF_SFFID_XOR
:
338 crc
= crc8
->crctab
[crc
^(cf
->can_id
& 0xFF)^
339 (cf
->can_id
>> 8 & 0xFF)];
343 cf
->data
[crc8
->result_idx
] = crc
^crc8
->final_xor_val
;
346 /* the receive & process & send function */
347 static void can_can_gw_rcv(struct sk_buff
*skb
, void *data
)
349 struct cgw_job
*gwj
= (struct cgw_job
*)data
;
350 struct can_frame
*cf
;
351 struct sk_buff
*nskb
;
355 * Do not handle CAN frames routed more than 'max_hops' times.
356 * In general we should never catch this delimiter which is intended
357 * to cover a misconfiguration protection (e.g. circular CAN routes).
359 * The Controller Area Network controllers only accept CAN frames with
360 * correct CRCs - which are not visible in the controller registers.
361 * According to skbuff.h documentation the csum_start element for IP
362 * checksums is undefined/unsued when ip_summed == CHECKSUM_UNNECESSARY.
363 * Only CAN skbs can be processed here which already have this property.
366 #define cgw_hops(skb) ((skb)->csum_start)
368 BUG_ON(skb
->ip_summed
!= CHECKSUM_UNNECESSARY
);
370 if (cgw_hops(skb
) >= max_hops
)
373 if (!(gwj
->dst
.dev
->flags
& IFF_UP
)) {
374 gwj
->dropped_frames
++;
378 /* is sending the skb back to the incoming interface not allowed? */
379 if (!(gwj
->flags
& CGW_FLAGS_CAN_IIF_TX_OK
) &&
380 skb_headroom(skb
) == sizeof(struct can_skb_priv
) &&
381 (((struct can_skb_priv
*)(skb
->head
))->ifindex
==
382 gwj
->dst
.dev
->ifindex
))
386 * clone the given skb, which has not been done in can_rcv()
388 * When there is at least one modification function activated,
389 * we need to copy the skb as we want to modify skb->data.
391 if (gwj
->mod
.modfunc
[0])
392 nskb
= skb_copy(skb
, GFP_ATOMIC
);
394 nskb
= skb_clone(skb
, GFP_ATOMIC
);
397 gwj
->dropped_frames
++;
401 /* put the incremented hop counter in the cloned skb */
402 cgw_hops(nskb
) = cgw_hops(skb
) + 1;
403 nskb
->dev
= gwj
->dst
.dev
;
405 /* pointer to modifiable CAN frame */
406 cf
= (struct can_frame
*)nskb
->data
;
408 /* perform preprocessed modification functions if there are any */
409 while (modidx
< MAX_MODFUNCTIONS
&& gwj
->mod
.modfunc
[modidx
])
410 (*gwj
->mod
.modfunc
[modidx
++])(cf
, &gwj
->mod
);
412 /* check for checksum updates when the CAN frame has been modified */
414 if (gwj
->mod
.csumfunc
.crc8
)
415 (*gwj
->mod
.csumfunc
.crc8
)(cf
, &gwj
->mod
.csum
.crc8
);
417 if (gwj
->mod
.csumfunc
.xor)
418 (*gwj
->mod
.csumfunc
.xor)(cf
, &gwj
->mod
.csum
.xor);
421 /* clear the skb timestamp if not configured the other way */
422 if (!(gwj
->flags
& CGW_FLAGS_CAN_SRC_TSTAMP
))
423 nskb
->tstamp
.tv64
= 0;
425 /* send to netdevice */
426 if (can_send(nskb
, gwj
->flags
& CGW_FLAGS_CAN_ECHO
))
427 gwj
->dropped_frames
++;
429 gwj
->handled_frames
++;
432 static inline int cgw_register_filter(struct cgw_job
*gwj
)
434 return can_rx_register(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
435 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
,
439 static inline void cgw_unregister_filter(struct cgw_job
*gwj
)
441 can_rx_unregister(gwj
->src
.dev
, gwj
->ccgw
.filter
.can_id
,
442 gwj
->ccgw
.filter
.can_mask
, can_can_gw_rcv
, gwj
);
445 static int cgw_notifier(struct notifier_block
*nb
,
446 unsigned long msg
, void *data
)
448 struct net_device
*dev
= (struct net_device
*)data
;
450 if (!net_eq(dev_net(dev
), &init_net
))
452 if (dev
->type
!= ARPHRD_CAN
)
455 if (msg
== NETDEV_UNREGISTER
) {
457 struct cgw_job
*gwj
= NULL
;
458 struct hlist_node
*n
, *nx
;
462 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
464 if (gwj
->src
.dev
== dev
|| gwj
->dst
.dev
== dev
) {
465 hlist_del(&gwj
->list
);
466 cgw_unregister_filter(gwj
);
475 static int cgw_put_job(struct sk_buff
*skb
, struct cgw_job
*gwj
, int type
,
476 u32 pid
, u32 seq
, int flags
)
478 struct cgw_frame_mod mb
;
479 struct rtcanmsg
*rtcan
;
480 struct nlmsghdr
*nlh
;
482 nlh
= nlmsg_put(skb
, pid
, seq
, type
, sizeof(*rtcan
), flags
);
486 rtcan
= nlmsg_data(nlh
);
487 rtcan
->can_family
= AF_CAN
;
488 rtcan
->gwtype
= gwj
->gwtype
;
489 rtcan
->flags
= gwj
->flags
;
491 /* add statistics if available */
493 if (gwj
->handled_frames
) {
494 if (nla_put_u32(skb
, CGW_HANDLED
, gwj
->handled_frames
) < 0)
498 if (gwj
->dropped_frames
) {
499 if (nla_put_u32(skb
, CGW_DROPPED
, gwj
->dropped_frames
) < 0)
503 /* check non default settings of attributes */
505 if (gwj
->mod
.modtype
.and) {
506 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.and, sizeof(mb
.cf
));
507 mb
.modtype
= gwj
->mod
.modtype
.and;
508 if (nla_put(skb
, CGW_MOD_AND
, sizeof(mb
), &mb
) < 0)
512 if (gwj
->mod
.modtype
.or) {
513 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.or, sizeof(mb
.cf
));
514 mb
.modtype
= gwj
->mod
.modtype
.or;
515 if (nla_put(skb
, CGW_MOD_OR
, sizeof(mb
), &mb
) < 0)
519 if (gwj
->mod
.modtype
.xor) {
520 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.xor, sizeof(mb
.cf
));
521 mb
.modtype
= gwj
->mod
.modtype
.xor;
522 if (nla_put(skb
, CGW_MOD_XOR
, sizeof(mb
), &mb
) < 0)
526 if (gwj
->mod
.modtype
.set
) {
527 memcpy(&mb
.cf
, &gwj
->mod
.modframe
.set
, sizeof(mb
.cf
));
528 mb
.modtype
= gwj
->mod
.modtype
.set
;
529 if (nla_put(skb
, CGW_MOD_SET
, sizeof(mb
), &mb
) < 0)
533 if (gwj
->mod
.csumfunc
.crc8
) {
534 if (nla_put(skb
, CGW_CS_CRC8
, CGW_CS_CRC8_LEN
,
535 &gwj
->mod
.csum
.crc8
) < 0)
539 if (gwj
->mod
.csumfunc
.xor) {
540 if (nla_put(skb
, CGW_CS_XOR
, CGW_CS_XOR_LEN
,
541 &gwj
->mod
.csum
.xor) < 0)
545 if (gwj
->gwtype
== CGW_TYPE_CAN_CAN
) {
547 if (gwj
->ccgw
.filter
.can_id
|| gwj
->ccgw
.filter
.can_mask
) {
548 if (nla_put(skb
, CGW_FILTER
, sizeof(struct can_filter
),
549 &gwj
->ccgw
.filter
) < 0)
553 if (nla_put_u32(skb
, CGW_SRC_IF
, gwj
->ccgw
.src_idx
) < 0)
556 if (nla_put_u32(skb
, CGW_DST_IF
, gwj
->ccgw
.dst_idx
) < 0)
560 return nlmsg_end(skb
, nlh
);
563 nlmsg_cancel(skb
, nlh
);
567 /* Dump information about all CAN gateway jobs, in response to RTM_GETROUTE */
568 static int cgw_dump_jobs(struct sk_buff
*skb
, struct netlink_callback
*cb
)
570 struct cgw_job
*gwj
= NULL
;
571 struct hlist_node
*n
;
573 int s_idx
= cb
->args
[0];
576 hlist_for_each_entry_rcu(gwj
, n
, &cgw_list
, list
) {
580 if (cgw_put_job(skb
, gwj
, RTM_NEWROUTE
, NETLINK_CB(cb
->skb
).portid
,
581 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
) < 0)
593 static const struct nla_policy cgw_policy
[CGW_MAX
+1] = {
594 [CGW_MOD_AND
] = { .len
= sizeof(struct cgw_frame_mod
) },
595 [CGW_MOD_OR
] = { .len
= sizeof(struct cgw_frame_mod
) },
596 [CGW_MOD_XOR
] = { .len
= sizeof(struct cgw_frame_mod
) },
597 [CGW_MOD_SET
] = { .len
= sizeof(struct cgw_frame_mod
) },
598 [CGW_CS_XOR
] = { .len
= sizeof(struct cgw_csum_xor
) },
599 [CGW_CS_CRC8
] = { .len
= sizeof(struct cgw_csum_crc8
) },
600 [CGW_SRC_IF
] = { .type
= NLA_U32
},
601 [CGW_DST_IF
] = { .type
= NLA_U32
},
602 [CGW_FILTER
] = { .len
= sizeof(struct can_filter
) },
605 /* check for common and gwtype specific attributes */
606 static int cgw_parse_attr(struct nlmsghdr
*nlh
, struct cf_mod
*mod
,
607 u8 gwtype
, void *gwtypeattr
)
609 struct nlattr
*tb
[CGW_MAX
+1];
610 struct cgw_frame_mod mb
;
614 /* initialize modification & checksum data space */
615 memset(mod
, 0, sizeof(*mod
));
617 err
= nlmsg_parse(nlh
, sizeof(struct rtcanmsg
), tb
, CGW_MAX
,
622 /* check for AND/OR/XOR/SET modifications */
624 if (tb
[CGW_MOD_AND
]) {
625 nla_memcpy(&mb
, tb
[CGW_MOD_AND
], CGW_MODATTR_LEN
);
627 canframecpy(&mod
->modframe
.and, &mb
.cf
);
628 mod
->modtype
.and = mb
.modtype
;
630 if (mb
.modtype
& CGW_MOD_ID
)
631 mod
->modfunc
[modidx
++] = mod_and_id
;
633 if (mb
.modtype
& CGW_MOD_DLC
)
634 mod
->modfunc
[modidx
++] = mod_and_dlc
;
636 if (mb
.modtype
& CGW_MOD_DATA
)
637 mod
->modfunc
[modidx
++] = mod_and_data
;
640 if (tb
[CGW_MOD_OR
]) {
641 nla_memcpy(&mb
, tb
[CGW_MOD_OR
], CGW_MODATTR_LEN
);
643 canframecpy(&mod
->modframe
.or, &mb
.cf
);
644 mod
->modtype
.or = mb
.modtype
;
646 if (mb
.modtype
& CGW_MOD_ID
)
647 mod
->modfunc
[modidx
++] = mod_or_id
;
649 if (mb
.modtype
& CGW_MOD_DLC
)
650 mod
->modfunc
[modidx
++] = mod_or_dlc
;
652 if (mb
.modtype
& CGW_MOD_DATA
)
653 mod
->modfunc
[modidx
++] = mod_or_data
;
656 if (tb
[CGW_MOD_XOR
]) {
657 nla_memcpy(&mb
, tb
[CGW_MOD_XOR
], CGW_MODATTR_LEN
);
659 canframecpy(&mod
->modframe
.xor, &mb
.cf
);
660 mod
->modtype
.xor = mb
.modtype
;
662 if (mb
.modtype
& CGW_MOD_ID
)
663 mod
->modfunc
[modidx
++] = mod_xor_id
;
665 if (mb
.modtype
& CGW_MOD_DLC
)
666 mod
->modfunc
[modidx
++] = mod_xor_dlc
;
668 if (mb
.modtype
& CGW_MOD_DATA
)
669 mod
->modfunc
[modidx
++] = mod_xor_data
;
672 if (tb
[CGW_MOD_SET
]) {
673 nla_memcpy(&mb
, tb
[CGW_MOD_SET
], CGW_MODATTR_LEN
);
675 canframecpy(&mod
->modframe
.set
, &mb
.cf
);
676 mod
->modtype
.set
= mb
.modtype
;
678 if (mb
.modtype
& CGW_MOD_ID
)
679 mod
->modfunc
[modidx
++] = mod_set_id
;
681 if (mb
.modtype
& CGW_MOD_DLC
)
682 mod
->modfunc
[modidx
++] = mod_set_dlc
;
684 if (mb
.modtype
& CGW_MOD_DATA
)
685 mod
->modfunc
[modidx
++] = mod_set_data
;
688 /* check for checksum operations after CAN frame modifications */
691 if (tb
[CGW_CS_CRC8
]) {
692 struct cgw_csum_crc8
*c
= nla_data(tb
[CGW_CS_CRC8
]);
694 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
699 nla_memcpy(&mod
->csum
.crc8
, tb
[CGW_CS_CRC8
],
703 * select dedicated processing function to reduce
704 * runtime operations in receive hot path.
706 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
708 mod
->csumfunc
.crc8
= cgw_csum_crc8_rel
;
709 else if (c
->from_idx
<= c
->to_idx
)
710 mod
->csumfunc
.crc8
= cgw_csum_crc8_pos
;
712 mod
->csumfunc
.crc8
= cgw_csum_crc8_neg
;
715 if (tb
[CGW_CS_XOR
]) {
716 struct cgw_csum_xor
*c
= nla_data(tb
[CGW_CS_XOR
]);
718 err
= cgw_chk_csum_parms(c
->from_idx
, c
->to_idx
,
723 nla_memcpy(&mod
->csum
.xor, tb
[CGW_CS_XOR
],
727 * select dedicated processing function to reduce
728 * runtime operations in receive hot path.
730 if (c
->from_idx
< 0 || c
->to_idx
< 0 ||
732 mod
->csumfunc
.xor = cgw_csum_xor_rel
;
733 else if (c
->from_idx
<= c
->to_idx
)
734 mod
->csumfunc
.xor = cgw_csum_xor_pos
;
736 mod
->csumfunc
.xor = cgw_csum_xor_neg
;
740 if (gwtype
== CGW_TYPE_CAN_CAN
) {
742 /* check CGW_TYPE_CAN_CAN specific attributes */
744 struct can_can_gw
*ccgw
= (struct can_can_gw
*)gwtypeattr
;
745 memset(ccgw
, 0, sizeof(*ccgw
));
747 /* check for can_filter in attributes */
749 nla_memcpy(&ccgw
->filter
, tb
[CGW_FILTER
],
750 sizeof(struct can_filter
));
754 /* specifying two interfaces is mandatory */
755 if (!tb
[CGW_SRC_IF
] || !tb
[CGW_DST_IF
])
758 ccgw
->src_idx
= nla_get_u32(tb
[CGW_SRC_IF
]);
759 ccgw
->dst_idx
= nla_get_u32(tb
[CGW_DST_IF
]);
761 /* both indices set to 0 for flushing all routing entries */
762 if (!ccgw
->src_idx
&& !ccgw
->dst_idx
)
765 /* only one index set to 0 is an error */
766 if (!ccgw
->src_idx
|| !ccgw
->dst_idx
)
770 /* add the checks for other gwtypes here */
775 static int cgw_create_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
782 if (!capable(CAP_NET_ADMIN
))
785 if (nlmsg_len(nlh
) < sizeof(*r
))
789 if (r
->can_family
!= AF_CAN
)
790 return -EPFNOSUPPORT
;
792 /* so far we only support CAN -> CAN routings */
793 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
796 gwj
= kmem_cache_alloc(cgw_cache
, GFP_KERNEL
);
800 gwj
->handled_frames
= 0;
801 gwj
->dropped_frames
= 0;
802 gwj
->flags
= r
->flags
;
803 gwj
->gwtype
= r
->gwtype
;
805 err
= cgw_parse_attr(nlh
, &gwj
->mod
, CGW_TYPE_CAN_CAN
, &gwj
->ccgw
);
811 /* ifindex == 0 is not allowed for job creation */
812 if (!gwj
->ccgw
.src_idx
|| !gwj
->ccgw
.dst_idx
)
815 gwj
->src
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.src_idx
);
820 /* check for CAN netdev not using header_ops - see gw_rcv() */
821 if (gwj
->src
.dev
->type
!= ARPHRD_CAN
|| gwj
->src
.dev
->header_ops
)
824 gwj
->dst
.dev
= dev_get_by_index(&init_net
, gwj
->ccgw
.dst_idx
);
829 /* check for CAN netdev not using header_ops - see gw_rcv() */
830 if (gwj
->dst
.dev
->type
!= ARPHRD_CAN
|| gwj
->dst
.dev
->header_ops
)
831 goto put_src_dst_out
;
835 err
= cgw_register_filter(gwj
);
837 hlist_add_head_rcu(&gwj
->list
, &cgw_list
);
840 dev_put(gwj
->dst
.dev
);
842 dev_put(gwj
->src
.dev
);
845 kmem_cache_free(cgw_cache
, gwj
);
850 static void cgw_remove_all_jobs(void)
852 struct cgw_job
*gwj
= NULL
;
853 struct hlist_node
*n
, *nx
;
857 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
858 hlist_del(&gwj
->list
);
859 cgw_unregister_filter(gwj
);
864 static int cgw_remove_job(struct sk_buff
*skb
, struct nlmsghdr
*nlh
, void *arg
)
866 struct cgw_job
*gwj
= NULL
;
867 struct hlist_node
*n
, *nx
;
870 struct can_can_gw ccgw
;
873 if (!capable(CAP_NET_ADMIN
))
876 if (nlmsg_len(nlh
) < sizeof(*r
))
880 if (r
->can_family
!= AF_CAN
)
881 return -EPFNOSUPPORT
;
883 /* so far we only support CAN -> CAN routings */
884 if (r
->gwtype
!= CGW_TYPE_CAN_CAN
)
887 err
= cgw_parse_attr(nlh
, &mod
, CGW_TYPE_CAN_CAN
, &ccgw
);
891 /* two interface indices both set to 0 => remove all entries */
892 if (!ccgw
.src_idx
&& !ccgw
.dst_idx
) {
893 cgw_remove_all_jobs();
901 /* remove only the first matching entry */
902 hlist_for_each_entry_safe(gwj
, n
, nx
, &cgw_list
, list
) {
904 if (gwj
->flags
!= r
->flags
)
907 if (memcmp(&gwj
->mod
, &mod
, sizeof(mod
)))
910 /* if (r->gwtype == CGW_TYPE_CAN_CAN) - is made sure here */
911 if (memcmp(&gwj
->ccgw
, &ccgw
, sizeof(ccgw
)))
914 hlist_del(&gwj
->list
);
915 cgw_unregister_filter(gwj
);
924 static __init
int cgw_module_init(void)
926 /* sanitize given module parameter */
927 max_hops
= clamp_t(unsigned int, max_hops
, CGW_MIN_HOPS
, CGW_MAX_HOPS
);
929 pr_info("can: netlink gateway (rev " CAN_GW_VERSION
") max_hops=%d\n",
932 cgw_cache
= kmem_cache_create("can_gw", sizeof(struct cgw_job
),
939 notifier
.notifier_call
= cgw_notifier
;
940 register_netdevice_notifier(¬ifier
);
942 if (__rtnl_register(PF_CAN
, RTM_GETROUTE
, NULL
, cgw_dump_jobs
, NULL
)) {
943 unregister_netdevice_notifier(¬ifier
);
944 kmem_cache_destroy(cgw_cache
);
948 /* Only the first call to __rtnl_register can fail */
949 __rtnl_register(PF_CAN
, RTM_NEWROUTE
, cgw_create_job
, NULL
, NULL
);
950 __rtnl_register(PF_CAN
, RTM_DELROUTE
, cgw_remove_job
, NULL
, NULL
);
955 static __exit
void cgw_module_exit(void)
957 rtnl_unregister_all(PF_CAN
);
959 unregister_netdevice_notifier(¬ifier
);
962 cgw_remove_all_jobs();
965 rcu_barrier(); /* Wait for completion of call_rcu()'s */
967 kmem_cache_destroy(cgw_cache
);
970 module_init(cgw_module_init
);
971 module_exit(cgw_module_exit
);