gw.c 25 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004
  1. /*
  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. *
  40. */
  41. #include <linux/module.h>
  42. #include <linux/init.h>
  43. #include <linux/types.h>
  44. #include <linux/kernel.h>
  45. #include <linux/list.h>
  46. #include <linux/spinlock.h>
  47. #include <linux/rcupdate.h>
  48. #include <linux/rculist.h>
  49. #include <linux/net.h>
  50. #include <linux/netdevice.h>
  51. #include <linux/if_arp.h>
  52. #include <linux/skbuff.h>
  53. #include <linux/can.h>
  54. #include <linux/can/core.h>
  55. #include <linux/can/skb.h>
  56. #include <linux/can/gw.h>
  57. #include <net/rtnetlink.h>
  58. #include <net/net_namespace.h>
  59. #include <net/sock.h>
  60. #define CAN_GW_VERSION "20130117"
  61. #define CAN_GW_NAME "can-gw"
  62. MODULE_DESCRIPTION("PF_CAN netlink gateway");
  63. MODULE_LICENSE("Dual BSD/GPL");
  64. MODULE_AUTHOR("Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
  65. MODULE_ALIAS(CAN_GW_NAME);
  66. #define CGW_MIN_HOPS 1
  67. #define CGW_MAX_HOPS 6
  68. #define CGW_DEFAULT_HOPS 1
  69. static unsigned int max_hops __read_mostly = CGW_DEFAULT_HOPS;
  70. module_param(max_hops, uint, S_IRUGO);
  71. MODULE_PARM_DESC(max_hops,
  72. "maximum " CAN_GW_NAME " routing hops for CAN frames "
  73. "(valid values: " __stringify(CGW_MIN_HOPS) "-"
  74. __stringify(CGW_MAX_HOPS) " hops, "
  75. "default: " __stringify(CGW_DEFAULT_HOPS) ")");
  76. static HLIST_HEAD(cgw_list);
  77. static struct notifier_block notifier;
  78. static struct kmem_cache *cgw_cache __read_mostly;
  79. /* structure that contains the (on-the-fly) CAN frame modifications */
  80. struct cf_mod {
  81. struct {
  82. struct can_frame and;
  83. struct can_frame or;
  84. struct can_frame xor;
  85. struct can_frame set;
  86. } modframe;
  87. struct {
  88. u8 and;
  89. u8 or;
  90. u8 xor;
  91. u8 set;
  92. } modtype;
  93. void (*modfunc[MAX_MODFUNCTIONS])(struct can_frame *cf,
  94. struct cf_mod *mod);
  95. /* CAN frame checksum calculation after CAN frame modifications */
  96. struct {
  97. struct cgw_csum_xor xor;
  98. struct cgw_csum_crc8 crc8;
  99. } csum;
  100. struct {
  101. void (*xor)(struct can_frame *cf, struct cgw_csum_xor *xor);
  102. void (*crc8)(struct can_frame *cf, struct cgw_csum_crc8 *crc8);
  103. } csumfunc;
  104. };
  105. /*
  106. * So far we just support CAN -> CAN routing and frame modifications.
  107. *
  108. * The internal can_can_gw structure contains data and attributes for
  109. * a CAN -> CAN gateway job.
  110. */
  111. struct can_can_gw {
  112. struct can_filter filter;
  113. int src_idx;
  114. int dst_idx;
  115. };
  116. /* list entry for CAN gateways jobs */
  117. struct cgw_job {
  118. struct hlist_node list;
  119. struct rcu_head rcu;
  120. u32 handled_frames;
  121. u32 dropped_frames;
  122. u32 deleted_frames;
  123. struct cf_mod mod;
  124. union {
  125. /* CAN frame data source */
  126. struct net_device *dev;
  127. } src;
  128. union {
  129. /* CAN frame data destination */
  130. struct net_device *dev;
  131. } dst;
  132. union {
  133. struct can_can_gw ccgw;
  134. /* tbc */
  135. };
  136. u8 gwtype;
  137. u8 limit_hops;
  138. u16 flags;
  139. };
  140. /* modification functions that are invoked in the hot path in can_can_gw_rcv */
  141. #define MODFUNC(func, op) static void func(struct can_frame *cf, \
  142. struct cf_mod *mod) { op ; }
  143. MODFUNC(mod_and_id, cf->can_id &= mod->modframe.and.can_id)
  144. MODFUNC(mod_and_dlc, cf->can_dlc &= mod->modframe.and.can_dlc)
  145. MODFUNC(mod_and_data, *(u64 *)cf->data &= *(u64 *)mod->modframe.and.data)
  146. MODFUNC(mod_or_id, cf->can_id |= mod->modframe.or.can_id)
  147. MODFUNC(mod_or_dlc, cf->can_dlc |= mod->modframe.or.can_dlc)
  148. MODFUNC(mod_or_data, *(u64 *)cf->data |= *(u64 *)mod->modframe.or.data)
  149. MODFUNC(mod_xor_id, cf->can_id ^= mod->modframe.xor.can_id)
  150. MODFUNC(mod_xor_dlc, cf->can_dlc ^= mod->modframe.xor.can_dlc)
  151. MODFUNC(mod_xor_data, *(u64 *)cf->data ^= *(u64 *)mod->modframe.xor.data)
  152. MODFUNC(mod_set_id, cf->can_id = mod->modframe.set.can_id)
  153. MODFUNC(mod_set_dlc, cf->can_dlc = mod->modframe.set.can_dlc)
  154. MODFUNC(mod_set_data, *(u64 *)cf->data = *(u64 *)mod->modframe.set.data)
  155. static inline void canframecpy(struct can_frame *dst, struct can_frame *src)
  156. {
  157. /*
  158. * Copy the struct members separately to ensure that no uninitialized
  159. * data are copied in the 3 bytes hole of the struct. This is needed
  160. * to make easy compares of the data in the struct cf_mod.
  161. */
  162. dst->can_id = src->can_id;
  163. dst->can_dlc = src->can_dlc;
  164. *(u64 *)dst->data = *(u64 *)src->data;
  165. }
  166. static int cgw_chk_csum_parms(s8 fr, s8 to, s8 re)
  167. {
  168. /*
  169. * absolute dlc values 0 .. 7 => 0 .. 7, e.g. data [0]
  170. * relative to received dlc -1 .. -8 :
  171. * e.g. for received dlc = 8
  172. * -1 => index = 7 (data[7])
  173. * -3 => index = 5 (data[5])
  174. * -8 => index = 0 (data[0])
  175. */
  176. if (fr > -9 && fr < 8 &&
  177. to > -9 && to < 8 &&
  178. re > -9 && re < 8)
  179. return 0;
  180. else
  181. return -EINVAL;
  182. }
  183. static inline int calc_idx(int idx, int rx_dlc)
  184. {
  185. if (idx < 0)
  186. return rx_dlc + idx;
  187. else
  188. return idx;
  189. }
  190. static void cgw_csum_xor_rel(struct can_frame *cf, struct cgw_csum_xor *xor)
  191. {
  192. int from = calc_idx(xor->from_idx, cf->can_dlc);
  193. int to = calc_idx(xor->to_idx, cf->can_dlc);
  194. int res = calc_idx(xor->result_idx, cf->can_dlc);
  195. u8 val = xor->init_xor_val;
  196. int i;
  197. if (from < 0 || to < 0 || res < 0)
  198. return;
  199. if (from <= to) {
  200. for (i = from; i <= to; i++)
  201. val ^= cf->data[i];
  202. } else {
  203. for (i = from; i >= to; i--)
  204. val ^= cf->data[i];
  205. }
  206. cf->data[res] = val;
  207. }
  208. static void cgw_csum_xor_pos(struct can_frame *cf, struct cgw_csum_xor *xor)
  209. {
  210. u8 val = xor->init_xor_val;
  211. int i;
  212. for (i = xor->from_idx; i <= xor->to_idx; i++)
  213. val ^= cf->data[i];
  214. cf->data[xor->result_idx] = val;
  215. }
  216. static void cgw_csum_xor_neg(struct can_frame *cf, struct cgw_csum_xor *xor)
  217. {
  218. u8 val = xor->init_xor_val;
  219. int i;
  220. for (i = xor->from_idx; i >= xor->to_idx; i--)
  221. val ^= cf->data[i];
  222. cf->data[xor->result_idx] = val;
  223. }
  224. static void cgw_csum_crc8_rel(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
  225. {
  226. int from = calc_idx(crc8->from_idx, cf->can_dlc);
  227. int to = calc_idx(crc8->to_idx, cf->can_dlc);
  228. int res = calc_idx(crc8->result_idx, cf->can_dlc);
  229. u8 crc = crc8->init_crc_val;
  230. int i;
  231. if (from < 0 || to < 0 || res < 0)
  232. return;
  233. if (from <= to) {
  234. for (i = crc8->from_idx; i <= crc8->to_idx; i++)
  235. crc = crc8->crctab[crc^cf->data[i]];
  236. } else {
  237. for (i = crc8->from_idx; i >= crc8->to_idx; i--)
  238. crc = crc8->crctab[crc^cf->data[i]];
  239. }
  240. switch (crc8->profile) {
  241. case CGW_CRC8PRF_1U8:
  242. crc = crc8->crctab[crc^crc8->profile_data[0]];
  243. break;
  244. case CGW_CRC8PRF_16U8:
  245. crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
  246. break;
  247. case CGW_CRC8PRF_SFFID_XOR:
  248. crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
  249. (cf->can_id >> 8 & 0xFF)];
  250. break;
  251. }
  252. cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
  253. }
  254. static void cgw_csum_crc8_pos(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
  255. {
  256. u8 crc = crc8->init_crc_val;
  257. int i;
  258. for (i = crc8->from_idx; i <= crc8->to_idx; i++)
  259. crc = crc8->crctab[crc^cf->data[i]];
  260. switch (crc8->profile) {
  261. case CGW_CRC8PRF_1U8:
  262. crc = crc8->crctab[crc^crc8->profile_data[0]];
  263. break;
  264. case CGW_CRC8PRF_16U8:
  265. crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
  266. break;
  267. case CGW_CRC8PRF_SFFID_XOR:
  268. crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
  269. (cf->can_id >> 8 & 0xFF)];
  270. break;
  271. }
  272. cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
  273. }
  274. static void cgw_csum_crc8_neg(struct can_frame *cf, struct cgw_csum_crc8 *crc8)
  275. {
  276. u8 crc = crc8->init_crc_val;
  277. int i;
  278. for (i = crc8->from_idx; i >= crc8->to_idx; i--)
  279. crc = crc8->crctab[crc^cf->data[i]];
  280. switch (crc8->profile) {
  281. case CGW_CRC8PRF_1U8:
  282. crc = crc8->crctab[crc^crc8->profile_data[0]];
  283. break;
  284. case CGW_CRC8PRF_16U8:
  285. crc = crc8->crctab[crc^crc8->profile_data[cf->data[1] & 0xF]];
  286. break;
  287. case CGW_CRC8PRF_SFFID_XOR:
  288. crc = crc8->crctab[crc^(cf->can_id & 0xFF)^
  289. (cf->can_id >> 8 & 0xFF)];
  290. break;
  291. }
  292. cf->data[crc8->result_idx] = crc^crc8->final_xor_val;
  293. }
  294. /* the receive & process & send function */
  295. static void can_can_gw_rcv(struct sk_buff *skb, void *data)
  296. {
  297. struct cgw_job *gwj = (struct cgw_job *)data;
  298. struct can_frame *cf;
  299. struct sk_buff *nskb;
  300. int modidx = 0;
  301. /*
  302. * Do not handle CAN frames routed more than 'max_hops' times.
  303. * In general we should never catch this delimiter which is intended
  304. * to cover a misconfiguration protection (e.g. circular CAN routes).
  305. *
  306. * The Controller Area Network controllers only accept CAN frames with
  307. * correct CRCs - which are not visible in the controller registers.
  308. * According to skbuff.h documentation the csum_start element for IP
  309. * checksums is undefined/unsued when ip_summed == CHECKSUM_UNNECESSARY.
  310. * Only CAN skbs can be processed here which already have this property.
  311. */
  312. #define cgw_hops(skb) ((skb)->csum_start)
  313. BUG_ON(skb->ip_summed != CHECKSUM_UNNECESSARY);
  314. if (cgw_hops(skb) >= max_hops) {
  315. /* indicate deleted frames due to misconfiguration */
  316. gwj->deleted_frames++;
  317. return;
  318. }
  319. if (!(gwj->dst.dev->flags & IFF_UP)) {
  320. gwj->dropped_frames++;
  321. return;
  322. }
  323. /* is sending the skb back to the incoming interface not allowed? */
  324. if (!(gwj->flags & CGW_FLAGS_CAN_IIF_TX_OK) &&
  325. can_skb_prv(skb)->ifindex == gwj->dst.dev->ifindex)
  326. return;
  327. /*
  328. * clone the given skb, which has not been done in can_rcv()
  329. *
  330. * When there is at least one modification function activated,
  331. * we need to copy the skb as we want to modify skb->data.
  332. */
  333. if (gwj->mod.modfunc[0])
  334. nskb = skb_copy(skb, GFP_ATOMIC);
  335. else
  336. nskb = skb_clone(skb, GFP_ATOMIC);
  337. if (!nskb) {
  338. gwj->dropped_frames++;
  339. return;
  340. }
  341. /* put the incremented hop counter in the cloned skb */
  342. cgw_hops(nskb) = cgw_hops(skb) + 1;
  343. /* first processing of this CAN frame -> adjust to private hop limit */
  344. if (gwj->limit_hops && cgw_hops(nskb) == 1)
  345. cgw_hops(nskb) = max_hops - gwj->limit_hops + 1;
  346. nskb->dev = gwj->dst.dev;
  347. /* pointer to modifiable CAN frame */
  348. cf = (struct can_frame *)nskb->data;
  349. /* perform preprocessed modification functions if there are any */
  350. while (modidx < MAX_MODFUNCTIONS && gwj->mod.modfunc[modidx])
  351. (*gwj->mod.modfunc[modidx++])(cf, &gwj->mod);
  352. /* check for checksum updates when the CAN frame has been modified */
  353. if (modidx) {
  354. if (gwj->mod.csumfunc.crc8)
  355. (*gwj->mod.csumfunc.crc8)(cf, &gwj->mod.csum.crc8);
  356. if (gwj->mod.csumfunc.xor)
  357. (*gwj->mod.csumfunc.xor)(cf, &gwj->mod.csum.xor);
  358. }
  359. /* clear the skb timestamp if not configured the other way */
  360. if (!(gwj->flags & CGW_FLAGS_CAN_SRC_TSTAMP))
  361. nskb->tstamp.tv64 = 0;
  362. /* send to netdevice */
  363. if (can_send(nskb, gwj->flags & CGW_FLAGS_CAN_ECHO))
  364. gwj->dropped_frames++;
  365. else
  366. gwj->handled_frames++;
  367. }
  368. static inline int cgw_register_filter(struct cgw_job *gwj)
  369. {
  370. return can_rx_register(gwj->src.dev, gwj->ccgw.filter.can_id,
  371. gwj->ccgw.filter.can_mask, can_can_gw_rcv,
  372. gwj, "gw");
  373. }
  374. static inline void cgw_unregister_filter(struct cgw_job *gwj)
  375. {
  376. can_rx_unregister(gwj->src.dev, gwj->ccgw.filter.can_id,
  377. gwj->ccgw.filter.can_mask, can_can_gw_rcv, gwj);
  378. }
  379. static int cgw_notifier(struct notifier_block *nb,
  380. unsigned long msg, void *ptr)
  381. {
  382. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  383. if (!net_eq(dev_net(dev), &init_net))
  384. return NOTIFY_DONE;
  385. if (dev->type != ARPHRD_CAN)
  386. return NOTIFY_DONE;
  387. if (msg == NETDEV_UNREGISTER) {
  388. struct cgw_job *gwj = NULL;
  389. struct hlist_node *nx;
  390. ASSERT_RTNL();
  391. hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
  392. if (gwj->src.dev == dev || gwj->dst.dev == dev) {
  393. hlist_del(&gwj->list);
  394. cgw_unregister_filter(gwj);
  395. kmem_cache_free(cgw_cache, gwj);
  396. }
  397. }
  398. }
  399. return NOTIFY_DONE;
  400. }
  401. static int cgw_put_job(struct sk_buff *skb, struct cgw_job *gwj, int type,
  402. u32 pid, u32 seq, int flags)
  403. {
  404. struct cgw_frame_mod mb;
  405. struct rtcanmsg *rtcan;
  406. struct nlmsghdr *nlh;
  407. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*rtcan), flags);
  408. if (!nlh)
  409. return -EMSGSIZE;
  410. rtcan = nlmsg_data(nlh);
  411. rtcan->can_family = AF_CAN;
  412. rtcan->gwtype = gwj->gwtype;
  413. rtcan->flags = gwj->flags;
  414. /* add statistics if available */
  415. if (gwj->handled_frames) {
  416. if (nla_put_u32(skb, CGW_HANDLED, gwj->handled_frames) < 0)
  417. goto cancel;
  418. }
  419. if (gwj->dropped_frames) {
  420. if (nla_put_u32(skb, CGW_DROPPED, gwj->dropped_frames) < 0)
  421. goto cancel;
  422. }
  423. if (gwj->deleted_frames) {
  424. if (nla_put_u32(skb, CGW_DELETED, gwj->deleted_frames) < 0)
  425. goto cancel;
  426. }
  427. /* check non default settings of attributes */
  428. if (gwj->limit_hops) {
  429. if (nla_put_u8(skb, CGW_LIM_HOPS, gwj->limit_hops) < 0)
  430. goto cancel;
  431. }
  432. if (gwj->mod.modtype.and) {
  433. memcpy(&mb.cf, &gwj->mod.modframe.and, sizeof(mb.cf));
  434. mb.modtype = gwj->mod.modtype.and;
  435. if (nla_put(skb, CGW_MOD_AND, sizeof(mb), &mb) < 0)
  436. goto cancel;
  437. }
  438. if (gwj->mod.modtype.or) {
  439. memcpy(&mb.cf, &gwj->mod.modframe.or, sizeof(mb.cf));
  440. mb.modtype = gwj->mod.modtype.or;
  441. if (nla_put(skb, CGW_MOD_OR, sizeof(mb), &mb) < 0)
  442. goto cancel;
  443. }
  444. if (gwj->mod.modtype.xor) {
  445. memcpy(&mb.cf, &gwj->mod.modframe.xor, sizeof(mb.cf));
  446. mb.modtype = gwj->mod.modtype.xor;
  447. if (nla_put(skb, CGW_MOD_XOR, sizeof(mb), &mb) < 0)
  448. goto cancel;
  449. }
  450. if (gwj->mod.modtype.set) {
  451. memcpy(&mb.cf, &gwj->mod.modframe.set, sizeof(mb.cf));
  452. mb.modtype = gwj->mod.modtype.set;
  453. if (nla_put(skb, CGW_MOD_SET, sizeof(mb), &mb) < 0)
  454. goto cancel;
  455. }
  456. if (gwj->mod.csumfunc.crc8) {
  457. if (nla_put(skb, CGW_CS_CRC8, CGW_CS_CRC8_LEN,
  458. &gwj->mod.csum.crc8) < 0)
  459. goto cancel;
  460. }
  461. if (gwj->mod.csumfunc.xor) {
  462. if (nla_put(skb, CGW_CS_XOR, CGW_CS_XOR_LEN,
  463. &gwj->mod.csum.xor) < 0)
  464. goto cancel;
  465. }
  466. if (gwj->gwtype == CGW_TYPE_CAN_CAN) {
  467. if (gwj->ccgw.filter.can_id || gwj->ccgw.filter.can_mask) {
  468. if (nla_put(skb, CGW_FILTER, sizeof(struct can_filter),
  469. &gwj->ccgw.filter) < 0)
  470. goto cancel;
  471. }
  472. if (nla_put_u32(skb, CGW_SRC_IF, gwj->ccgw.src_idx) < 0)
  473. goto cancel;
  474. if (nla_put_u32(skb, CGW_DST_IF, gwj->ccgw.dst_idx) < 0)
  475. goto cancel;
  476. }
  477. return nlmsg_end(skb, nlh);
  478. cancel:
  479. nlmsg_cancel(skb, nlh);
  480. return -EMSGSIZE;
  481. }
  482. /* Dump information about all CAN gateway jobs, in response to RTM_GETROUTE */
  483. static int cgw_dump_jobs(struct sk_buff *skb, struct netlink_callback *cb)
  484. {
  485. struct cgw_job *gwj = NULL;
  486. int idx = 0;
  487. int s_idx = cb->args[0];
  488. rcu_read_lock();
  489. hlist_for_each_entry_rcu(gwj, &cgw_list, list) {
  490. if (idx < s_idx)
  491. goto cont;
  492. if (cgw_put_job(skb, gwj, RTM_NEWROUTE, NETLINK_CB(cb->skb).portid,
  493. cb->nlh->nlmsg_seq, NLM_F_MULTI) < 0)
  494. break;
  495. cont:
  496. idx++;
  497. }
  498. rcu_read_unlock();
  499. cb->args[0] = idx;
  500. return skb->len;
  501. }
  502. static const struct nla_policy cgw_policy[CGW_MAX+1] = {
  503. [CGW_MOD_AND] = { .len = sizeof(struct cgw_frame_mod) },
  504. [CGW_MOD_OR] = { .len = sizeof(struct cgw_frame_mod) },
  505. [CGW_MOD_XOR] = { .len = sizeof(struct cgw_frame_mod) },
  506. [CGW_MOD_SET] = { .len = sizeof(struct cgw_frame_mod) },
  507. [CGW_CS_XOR] = { .len = sizeof(struct cgw_csum_xor) },
  508. [CGW_CS_CRC8] = { .len = sizeof(struct cgw_csum_crc8) },
  509. [CGW_SRC_IF] = { .type = NLA_U32 },
  510. [CGW_DST_IF] = { .type = NLA_U32 },
  511. [CGW_FILTER] = { .len = sizeof(struct can_filter) },
  512. [CGW_LIM_HOPS] = { .type = NLA_U8 },
  513. };
  514. /* check for common and gwtype specific attributes */
  515. static int cgw_parse_attr(struct nlmsghdr *nlh, struct cf_mod *mod,
  516. u8 gwtype, void *gwtypeattr, u8 *limhops)
  517. {
  518. struct nlattr *tb[CGW_MAX+1];
  519. struct cgw_frame_mod mb;
  520. int modidx = 0;
  521. int err = 0;
  522. /* initialize modification & checksum data space */
  523. memset(mod, 0, sizeof(*mod));
  524. err = nlmsg_parse(nlh, sizeof(struct rtcanmsg), tb, CGW_MAX,
  525. cgw_policy);
  526. if (err < 0)
  527. return err;
  528. if (tb[CGW_LIM_HOPS]) {
  529. *limhops = nla_get_u8(tb[CGW_LIM_HOPS]);
  530. if (*limhops < 1 || *limhops > max_hops)
  531. return -EINVAL;
  532. }
  533. /* check for AND/OR/XOR/SET modifications */
  534. if (tb[CGW_MOD_AND]) {
  535. nla_memcpy(&mb, tb[CGW_MOD_AND], CGW_MODATTR_LEN);
  536. canframecpy(&mod->modframe.and, &mb.cf);
  537. mod->modtype.and = mb.modtype;
  538. if (mb.modtype & CGW_MOD_ID)
  539. mod->modfunc[modidx++] = mod_and_id;
  540. if (mb.modtype & CGW_MOD_DLC)
  541. mod->modfunc[modidx++] = mod_and_dlc;
  542. if (mb.modtype & CGW_MOD_DATA)
  543. mod->modfunc[modidx++] = mod_and_data;
  544. }
  545. if (tb[CGW_MOD_OR]) {
  546. nla_memcpy(&mb, tb[CGW_MOD_OR], CGW_MODATTR_LEN);
  547. canframecpy(&mod->modframe.or, &mb.cf);
  548. mod->modtype.or = mb.modtype;
  549. if (mb.modtype & CGW_MOD_ID)
  550. mod->modfunc[modidx++] = mod_or_id;
  551. if (mb.modtype & CGW_MOD_DLC)
  552. mod->modfunc[modidx++] = mod_or_dlc;
  553. if (mb.modtype & CGW_MOD_DATA)
  554. mod->modfunc[modidx++] = mod_or_data;
  555. }
  556. if (tb[CGW_MOD_XOR]) {
  557. nla_memcpy(&mb, tb[CGW_MOD_XOR], CGW_MODATTR_LEN);
  558. canframecpy(&mod->modframe.xor, &mb.cf);
  559. mod->modtype.xor = mb.modtype;
  560. if (mb.modtype & CGW_MOD_ID)
  561. mod->modfunc[modidx++] = mod_xor_id;
  562. if (mb.modtype & CGW_MOD_DLC)
  563. mod->modfunc[modidx++] = mod_xor_dlc;
  564. if (mb.modtype & CGW_MOD_DATA)
  565. mod->modfunc[modidx++] = mod_xor_data;
  566. }
  567. if (tb[CGW_MOD_SET]) {
  568. nla_memcpy(&mb, tb[CGW_MOD_SET], CGW_MODATTR_LEN);
  569. canframecpy(&mod->modframe.set, &mb.cf);
  570. mod->modtype.set = mb.modtype;
  571. if (mb.modtype & CGW_MOD_ID)
  572. mod->modfunc[modidx++] = mod_set_id;
  573. if (mb.modtype & CGW_MOD_DLC)
  574. mod->modfunc[modidx++] = mod_set_dlc;
  575. if (mb.modtype & CGW_MOD_DATA)
  576. mod->modfunc[modidx++] = mod_set_data;
  577. }
  578. /* check for checksum operations after CAN frame modifications */
  579. if (modidx) {
  580. if (tb[CGW_CS_CRC8]) {
  581. struct cgw_csum_crc8 *c = nla_data(tb[CGW_CS_CRC8]);
  582. err = cgw_chk_csum_parms(c->from_idx, c->to_idx,
  583. c->result_idx);
  584. if (err)
  585. return err;
  586. nla_memcpy(&mod->csum.crc8, tb[CGW_CS_CRC8],
  587. CGW_CS_CRC8_LEN);
  588. /*
  589. * select dedicated processing function to reduce
  590. * runtime operations in receive hot path.
  591. */
  592. if (c->from_idx < 0 || c->to_idx < 0 ||
  593. c->result_idx < 0)
  594. mod->csumfunc.crc8 = cgw_csum_crc8_rel;
  595. else if (c->from_idx <= c->to_idx)
  596. mod->csumfunc.crc8 = cgw_csum_crc8_pos;
  597. else
  598. mod->csumfunc.crc8 = cgw_csum_crc8_neg;
  599. }
  600. if (tb[CGW_CS_XOR]) {
  601. struct cgw_csum_xor *c = nla_data(tb[CGW_CS_XOR]);
  602. err = cgw_chk_csum_parms(c->from_idx, c->to_idx,
  603. c->result_idx);
  604. if (err)
  605. return err;
  606. nla_memcpy(&mod->csum.xor, tb[CGW_CS_XOR],
  607. CGW_CS_XOR_LEN);
  608. /*
  609. * select dedicated processing function to reduce
  610. * runtime operations in receive hot path.
  611. */
  612. if (c->from_idx < 0 || c->to_idx < 0 ||
  613. c->result_idx < 0)
  614. mod->csumfunc.xor = cgw_csum_xor_rel;
  615. else if (c->from_idx <= c->to_idx)
  616. mod->csumfunc.xor = cgw_csum_xor_pos;
  617. else
  618. mod->csumfunc.xor = cgw_csum_xor_neg;
  619. }
  620. }
  621. if (gwtype == CGW_TYPE_CAN_CAN) {
  622. /* check CGW_TYPE_CAN_CAN specific attributes */
  623. struct can_can_gw *ccgw = (struct can_can_gw *)gwtypeattr;
  624. memset(ccgw, 0, sizeof(*ccgw));
  625. /* check for can_filter in attributes */
  626. if (tb[CGW_FILTER])
  627. nla_memcpy(&ccgw->filter, tb[CGW_FILTER],
  628. sizeof(struct can_filter));
  629. err = -ENODEV;
  630. /* specifying two interfaces is mandatory */
  631. if (!tb[CGW_SRC_IF] || !tb[CGW_DST_IF])
  632. return err;
  633. ccgw->src_idx = nla_get_u32(tb[CGW_SRC_IF]);
  634. ccgw->dst_idx = nla_get_u32(tb[CGW_DST_IF]);
  635. /* both indices set to 0 for flushing all routing entries */
  636. if (!ccgw->src_idx && !ccgw->dst_idx)
  637. return 0;
  638. /* only one index set to 0 is an error */
  639. if (!ccgw->src_idx || !ccgw->dst_idx)
  640. return err;
  641. }
  642. /* add the checks for other gwtypes here */
  643. return 0;
  644. }
  645. static int cgw_create_job(struct sk_buff *skb, struct nlmsghdr *nlh)
  646. {
  647. struct rtcanmsg *r;
  648. struct cgw_job *gwj;
  649. u8 limhops = 0;
  650. int err = 0;
  651. if (!capable(CAP_NET_ADMIN))
  652. return -EPERM;
  653. if (nlmsg_len(nlh) < sizeof(*r))
  654. return -EINVAL;
  655. r = nlmsg_data(nlh);
  656. if (r->can_family != AF_CAN)
  657. return -EPFNOSUPPORT;
  658. /* so far we only support CAN -> CAN routings */
  659. if (r->gwtype != CGW_TYPE_CAN_CAN)
  660. return -EINVAL;
  661. gwj = kmem_cache_alloc(cgw_cache, GFP_KERNEL);
  662. if (!gwj)
  663. return -ENOMEM;
  664. gwj->handled_frames = 0;
  665. gwj->dropped_frames = 0;
  666. gwj->deleted_frames = 0;
  667. gwj->flags = r->flags;
  668. gwj->gwtype = r->gwtype;
  669. err = cgw_parse_attr(nlh, &gwj->mod, CGW_TYPE_CAN_CAN, &gwj->ccgw,
  670. &limhops);
  671. if (err < 0)
  672. goto out;
  673. err = -ENODEV;
  674. /* ifindex == 0 is not allowed for job creation */
  675. if (!gwj->ccgw.src_idx || !gwj->ccgw.dst_idx)
  676. goto out;
  677. gwj->src.dev = dev_get_by_index(&init_net, gwj->ccgw.src_idx);
  678. if (!gwj->src.dev)
  679. goto out;
  680. /* check for CAN netdev not using header_ops - see gw_rcv() */
  681. if (gwj->src.dev->type != ARPHRD_CAN || gwj->src.dev->header_ops)
  682. goto put_src_out;
  683. gwj->dst.dev = dev_get_by_index(&init_net, gwj->ccgw.dst_idx);
  684. if (!gwj->dst.dev)
  685. goto put_src_out;
  686. /* check for CAN netdev not using header_ops - see gw_rcv() */
  687. if (gwj->dst.dev->type != ARPHRD_CAN || gwj->dst.dev->header_ops)
  688. goto put_src_dst_out;
  689. gwj->limit_hops = limhops;
  690. ASSERT_RTNL();
  691. err = cgw_register_filter(gwj);
  692. if (!err)
  693. hlist_add_head_rcu(&gwj->list, &cgw_list);
  694. put_src_dst_out:
  695. dev_put(gwj->dst.dev);
  696. put_src_out:
  697. dev_put(gwj->src.dev);
  698. out:
  699. if (err)
  700. kmem_cache_free(cgw_cache, gwj);
  701. return err;
  702. }
  703. static void cgw_remove_all_jobs(void)
  704. {
  705. struct cgw_job *gwj = NULL;
  706. struct hlist_node *nx;
  707. ASSERT_RTNL();
  708. hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
  709. hlist_del(&gwj->list);
  710. cgw_unregister_filter(gwj);
  711. kmem_cache_free(cgw_cache, gwj);
  712. }
  713. }
  714. static int cgw_remove_job(struct sk_buff *skb, struct nlmsghdr *nlh)
  715. {
  716. struct cgw_job *gwj = NULL;
  717. struct hlist_node *nx;
  718. struct rtcanmsg *r;
  719. struct cf_mod mod;
  720. struct can_can_gw ccgw;
  721. u8 limhops = 0;
  722. int err = 0;
  723. if (!capable(CAP_NET_ADMIN))
  724. return -EPERM;
  725. if (nlmsg_len(nlh) < sizeof(*r))
  726. return -EINVAL;
  727. r = nlmsg_data(nlh);
  728. if (r->can_family != AF_CAN)
  729. return -EPFNOSUPPORT;
  730. /* so far we only support CAN -> CAN routings */
  731. if (r->gwtype != CGW_TYPE_CAN_CAN)
  732. return -EINVAL;
  733. err = cgw_parse_attr(nlh, &mod, CGW_TYPE_CAN_CAN, &ccgw, &limhops);
  734. if (err < 0)
  735. return err;
  736. /* two interface indices both set to 0 => remove all entries */
  737. if (!ccgw.src_idx && !ccgw.dst_idx) {
  738. cgw_remove_all_jobs();
  739. return 0;
  740. }
  741. err = -EINVAL;
  742. ASSERT_RTNL();
  743. /* remove only the first matching entry */
  744. hlist_for_each_entry_safe(gwj, nx, &cgw_list, list) {
  745. if (gwj->flags != r->flags)
  746. continue;
  747. if (gwj->limit_hops != limhops)
  748. continue;
  749. if (memcmp(&gwj->mod, &mod, sizeof(mod)))
  750. continue;
  751. /* if (r->gwtype == CGW_TYPE_CAN_CAN) - is made sure here */
  752. if (memcmp(&gwj->ccgw, &ccgw, sizeof(ccgw)))
  753. continue;
  754. hlist_del(&gwj->list);
  755. cgw_unregister_filter(gwj);
  756. kmem_cache_free(cgw_cache, gwj);
  757. err = 0;
  758. break;
  759. }
  760. return err;
  761. }
  762. static __init int cgw_module_init(void)
  763. {
  764. /* sanitize given module parameter */
  765. max_hops = clamp_t(unsigned int, max_hops, CGW_MIN_HOPS, CGW_MAX_HOPS);
  766. pr_info("can: netlink gateway (rev " CAN_GW_VERSION ") max_hops=%d\n",
  767. max_hops);
  768. cgw_cache = kmem_cache_create("can_gw", sizeof(struct cgw_job),
  769. 0, 0, NULL);
  770. if (!cgw_cache)
  771. return -ENOMEM;
  772. /* set notifier */
  773. notifier.notifier_call = cgw_notifier;
  774. register_netdevice_notifier(&notifier);
  775. if (__rtnl_register(PF_CAN, RTM_GETROUTE, NULL, cgw_dump_jobs, NULL)) {
  776. unregister_netdevice_notifier(&notifier);
  777. kmem_cache_destroy(cgw_cache);
  778. return -ENOBUFS;
  779. }
  780. /* Only the first call to __rtnl_register can fail */
  781. __rtnl_register(PF_CAN, RTM_NEWROUTE, cgw_create_job, NULL, NULL);
  782. __rtnl_register(PF_CAN, RTM_DELROUTE, cgw_remove_job, NULL, NULL);
  783. return 0;
  784. }
  785. static __exit void cgw_module_exit(void)
  786. {
  787. rtnl_unregister_all(PF_CAN);
  788. unregister_netdevice_notifier(&notifier);
  789. rtnl_lock();
  790. cgw_remove_all_jobs();
  791. rtnl_unlock();
  792. rcu_barrier(); /* Wait for completion of call_rcu()'s */
  793. kmem_cache_destroy(cgw_cache);
  794. }
  795. module_init(cgw_module_init);
  796. module_exit(cgw_module_exit);