netlink.c 41 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* Copyright (C) 2016-2020 B.A.T.M.A.N. contributors:
  3. *
  4. * Matthias Schiffer
  5. */
  6. #include "netlink.h"
  7. #include "main.h"
  8. #include <linux/atomic.h>
  9. #include <linux/bitops.h>
  10. #include <linux/bug.h>
  11. #include <linux/byteorder/generic.h>
  12. #include <linux/cache.h>
  13. #include <linux/err.h>
  14. #include <linux/errno.h>
  15. #include <linux/export.h>
  16. #include <linux/genetlink.h>
  17. #include <linux/gfp.h>
  18. #include <linux/if_ether.h>
  19. #include <linux/if_vlan.h>
  20. #include <linux/init.h>
  21. #include <linux/kernel.h>
  22. #include <linux/limits.h>
  23. #include <linux/list.h>
  24. #include <linux/netdevice.h>
  25. #include <linux/netlink.h>
  26. #include <linux/printk.h>
  27. #include <linux/rtnetlink.h>
  28. #include <linux/skbuff.h>
  29. #include <linux/stddef.h>
  30. #include <linux/types.h>
  31. #include <net/genetlink.h>
  32. #include <net/net_namespace.h>
  33. #include <net/netlink.h>
  34. #include <net/sock.h>
  35. #include <uapi/linux/batadv_packet.h>
  36. #include <uapi/linux/batman_adv.h>
  37. #include "bat_algo.h"
  38. #include "bridge_loop_avoidance.h"
  39. #include "distributed-arp-table.h"
  40. #include "gateway_client.h"
  41. #include "gateway_common.h"
  42. #include "hard-interface.h"
  43. #include "log.h"
  44. #include "multicast.h"
  45. #include "network-coding.h"
  46. #include "originator.h"
  47. #include "soft-interface.h"
  48. #include "tp_meter.h"
  49. #include "translation-table.h"
  50. struct genl_family batadv_netlink_family;
  51. /* multicast groups */
  52. enum batadv_netlink_multicast_groups {
  53. BATADV_NL_MCGRP_CONFIG,
  54. BATADV_NL_MCGRP_TPMETER,
  55. };
  56. /**
  57. * enum batadv_genl_ops_flags - flags for genl_ops's internal_flags
  58. */
  59. enum batadv_genl_ops_flags {
  60. /**
  61. * @BATADV_FLAG_NEED_MESH: request requires valid soft interface in
  62. * attribute BATADV_ATTR_MESH_IFINDEX and expects a pointer to it to be
  63. * saved in info->user_ptr[0]
  64. */
  65. BATADV_FLAG_NEED_MESH = BIT(0),
  66. /**
  67. * @BATADV_FLAG_NEED_HARDIF: request requires valid hard interface in
  68. * attribute BATADV_ATTR_HARD_IFINDEX and expects a pointer to it to be
  69. * saved in info->user_ptr[1]
  70. */
  71. BATADV_FLAG_NEED_HARDIF = BIT(1),
  72. /**
  73. * @BATADV_FLAG_NEED_VLAN: request requires valid vlan in
  74. * attribute BATADV_ATTR_VLANID and expects a pointer to it to be
  75. * saved in info->user_ptr[1]
  76. */
  77. BATADV_FLAG_NEED_VLAN = BIT(2),
  78. };
  79. static const struct genl_multicast_group batadv_netlink_mcgrps[] = {
  80. [BATADV_NL_MCGRP_CONFIG] = { .name = BATADV_NL_MCAST_GROUP_CONFIG },
  81. [BATADV_NL_MCGRP_TPMETER] = { .name = BATADV_NL_MCAST_GROUP_TPMETER },
  82. };
  83. static const struct nla_policy batadv_netlink_policy[NUM_BATADV_ATTR] = {
  84. [BATADV_ATTR_VERSION] = { .type = NLA_STRING },
  85. [BATADV_ATTR_ALGO_NAME] = { .type = NLA_STRING },
  86. [BATADV_ATTR_MESH_IFINDEX] = { .type = NLA_U32 },
  87. [BATADV_ATTR_MESH_IFNAME] = { .type = NLA_STRING },
  88. [BATADV_ATTR_MESH_ADDRESS] = { .len = ETH_ALEN },
  89. [BATADV_ATTR_HARD_IFINDEX] = { .type = NLA_U32 },
  90. [BATADV_ATTR_HARD_IFNAME] = { .type = NLA_STRING },
  91. [BATADV_ATTR_HARD_ADDRESS] = { .len = ETH_ALEN },
  92. [BATADV_ATTR_ORIG_ADDRESS] = { .len = ETH_ALEN },
  93. [BATADV_ATTR_TPMETER_RESULT] = { .type = NLA_U8 },
  94. [BATADV_ATTR_TPMETER_TEST_TIME] = { .type = NLA_U32 },
  95. [BATADV_ATTR_TPMETER_BYTES] = { .type = NLA_U64 },
  96. [BATADV_ATTR_TPMETER_COOKIE] = { .type = NLA_U32 },
  97. [BATADV_ATTR_ACTIVE] = { .type = NLA_FLAG },
  98. [BATADV_ATTR_TT_ADDRESS] = { .len = ETH_ALEN },
  99. [BATADV_ATTR_TT_TTVN] = { .type = NLA_U8 },
  100. [BATADV_ATTR_TT_LAST_TTVN] = { .type = NLA_U8 },
  101. [BATADV_ATTR_TT_CRC32] = { .type = NLA_U32 },
  102. [BATADV_ATTR_TT_VID] = { .type = NLA_U16 },
  103. [BATADV_ATTR_TT_FLAGS] = { .type = NLA_U32 },
  104. [BATADV_ATTR_FLAG_BEST] = { .type = NLA_FLAG },
  105. [BATADV_ATTR_LAST_SEEN_MSECS] = { .type = NLA_U32 },
  106. [BATADV_ATTR_NEIGH_ADDRESS] = { .len = ETH_ALEN },
  107. [BATADV_ATTR_TQ] = { .type = NLA_U8 },
  108. [BATADV_ATTR_THROUGHPUT] = { .type = NLA_U32 },
  109. [BATADV_ATTR_BANDWIDTH_UP] = { .type = NLA_U32 },
  110. [BATADV_ATTR_BANDWIDTH_DOWN] = { .type = NLA_U32 },
  111. [BATADV_ATTR_ROUTER] = { .len = ETH_ALEN },
  112. [BATADV_ATTR_BLA_OWN] = { .type = NLA_FLAG },
  113. [BATADV_ATTR_BLA_ADDRESS] = { .len = ETH_ALEN },
  114. [BATADV_ATTR_BLA_VID] = { .type = NLA_U16 },
  115. [BATADV_ATTR_BLA_BACKBONE] = { .len = ETH_ALEN },
  116. [BATADV_ATTR_BLA_CRC] = { .type = NLA_U16 },
  117. [BATADV_ATTR_DAT_CACHE_IP4ADDRESS] = { .type = NLA_U32 },
  118. [BATADV_ATTR_DAT_CACHE_HWADDRESS] = { .len = ETH_ALEN },
  119. [BATADV_ATTR_DAT_CACHE_VID] = { .type = NLA_U16 },
  120. [BATADV_ATTR_MCAST_FLAGS] = { .type = NLA_U32 },
  121. [BATADV_ATTR_MCAST_FLAGS_PRIV] = { .type = NLA_U32 },
  122. [BATADV_ATTR_VLANID] = { .type = NLA_U16 },
  123. [BATADV_ATTR_AGGREGATED_OGMS_ENABLED] = { .type = NLA_U8 },
  124. [BATADV_ATTR_AP_ISOLATION_ENABLED] = { .type = NLA_U8 },
  125. [BATADV_ATTR_ISOLATION_MARK] = { .type = NLA_U32 },
  126. [BATADV_ATTR_ISOLATION_MASK] = { .type = NLA_U32 },
  127. [BATADV_ATTR_BONDING_ENABLED] = { .type = NLA_U8 },
  128. [BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED] = { .type = NLA_U8 },
  129. [BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED] = { .type = NLA_U8 },
  130. [BATADV_ATTR_FRAGMENTATION_ENABLED] = { .type = NLA_U8 },
  131. [BATADV_ATTR_GW_BANDWIDTH_DOWN] = { .type = NLA_U32 },
  132. [BATADV_ATTR_GW_BANDWIDTH_UP] = { .type = NLA_U32 },
  133. [BATADV_ATTR_GW_MODE] = { .type = NLA_U8 },
  134. [BATADV_ATTR_GW_SEL_CLASS] = { .type = NLA_U32 },
  135. [BATADV_ATTR_HOP_PENALTY] = { .type = NLA_U8 },
  136. [BATADV_ATTR_LOG_LEVEL] = { .type = NLA_U32 },
  137. [BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED] = { .type = NLA_U8 },
  138. [BATADV_ATTR_MULTICAST_FANOUT] = { .type = NLA_U32 },
  139. [BATADV_ATTR_NETWORK_CODING_ENABLED] = { .type = NLA_U8 },
  140. [BATADV_ATTR_ORIG_INTERVAL] = { .type = NLA_U32 },
  141. [BATADV_ATTR_ELP_INTERVAL] = { .type = NLA_U32 },
  142. [BATADV_ATTR_THROUGHPUT_OVERRIDE] = { .type = NLA_U32 },
  143. };
  144. /**
  145. * batadv_netlink_get_ifindex() - Extract an interface index from a message
  146. * @nlh: Message header
  147. * @attrtype: Attribute which holds an interface index
  148. *
  149. * Return: interface index, or 0.
  150. */
  151. int
  152. batadv_netlink_get_ifindex(const struct nlmsghdr *nlh, int attrtype)
  153. {
  154. struct nlattr *attr = nlmsg_find_attr(nlh, GENL_HDRLEN, attrtype);
  155. return (attr && nla_len(attr) == sizeof(u32)) ? nla_get_u32(attr) : 0;
  156. }
  157. /**
  158. * batadv_netlink_mesh_fill_ap_isolation() - Add ap_isolation softif attribute
  159. * @msg: Netlink message to dump into
  160. * @bat_priv: the bat priv with all the soft interface information
  161. *
  162. * Return: 0 on success or negative error number in case of failure
  163. */
  164. static int batadv_netlink_mesh_fill_ap_isolation(struct sk_buff *msg,
  165. struct batadv_priv *bat_priv)
  166. {
  167. struct batadv_softif_vlan *vlan;
  168. u8 ap_isolation;
  169. vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
  170. if (!vlan)
  171. return 0;
  172. ap_isolation = atomic_read(&vlan->ap_isolation);
  173. batadv_softif_vlan_put(vlan);
  174. return nla_put_u8(msg, BATADV_ATTR_AP_ISOLATION_ENABLED,
  175. !!ap_isolation);
  176. }
  177. /**
  178. * batadv_option_set_ap_isolation() - Set ap_isolation from genl msg
  179. * @attr: parsed BATADV_ATTR_AP_ISOLATION_ENABLED attribute
  180. * @bat_priv: the bat priv with all the soft interface information
  181. *
  182. * Return: 0 on success or negative error number in case of failure
  183. */
  184. static int batadv_netlink_set_mesh_ap_isolation(struct nlattr *attr,
  185. struct batadv_priv *bat_priv)
  186. {
  187. struct batadv_softif_vlan *vlan;
  188. vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
  189. if (!vlan)
  190. return -ENOENT;
  191. atomic_set(&vlan->ap_isolation, !!nla_get_u8(attr));
  192. batadv_softif_vlan_put(vlan);
  193. return 0;
  194. }
  195. /**
  196. * batadv_netlink_mesh_fill() - Fill message with mesh attributes
  197. * @msg: Netlink message to dump into
  198. * @bat_priv: the bat priv with all the soft interface information
  199. * @cmd: type of message to generate
  200. * @portid: Port making netlink request
  201. * @seq: sequence number for message
  202. * @flags: Additional flags for message
  203. *
  204. * Return: 0 on success or negative error number in case of failure
  205. */
  206. static int batadv_netlink_mesh_fill(struct sk_buff *msg,
  207. struct batadv_priv *bat_priv,
  208. enum batadv_nl_commands cmd,
  209. u32 portid, u32 seq, int flags)
  210. {
  211. struct net_device *soft_iface = bat_priv->soft_iface;
  212. struct batadv_hard_iface *primary_if = NULL;
  213. struct net_device *hard_iface;
  214. void *hdr;
  215. hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
  216. if (!hdr)
  217. return -ENOBUFS;
  218. if (nla_put_string(msg, BATADV_ATTR_VERSION, BATADV_SOURCE_VERSION) ||
  219. nla_put_string(msg, BATADV_ATTR_ALGO_NAME,
  220. bat_priv->algo_ops->name) ||
  221. nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX, soft_iface->ifindex) ||
  222. nla_put_string(msg, BATADV_ATTR_MESH_IFNAME, soft_iface->name) ||
  223. nla_put(msg, BATADV_ATTR_MESH_ADDRESS, ETH_ALEN,
  224. soft_iface->dev_addr) ||
  225. nla_put_u8(msg, BATADV_ATTR_TT_TTVN,
  226. (u8)atomic_read(&bat_priv->tt.vn)))
  227. goto nla_put_failure;
  228. #ifdef CONFIG_BATMAN_ADV_BLA
  229. if (nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
  230. ntohs(bat_priv->bla.claim_dest.group)))
  231. goto nla_put_failure;
  232. #endif
  233. if (batadv_mcast_mesh_info_put(msg, bat_priv))
  234. goto nla_put_failure;
  235. primary_if = batadv_primary_if_get_selected(bat_priv);
  236. if (primary_if && primary_if->if_status == BATADV_IF_ACTIVE) {
  237. hard_iface = primary_if->net_dev;
  238. if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
  239. hard_iface->ifindex) ||
  240. nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
  241. hard_iface->name) ||
  242. nla_put(msg, BATADV_ATTR_HARD_ADDRESS, ETH_ALEN,
  243. hard_iface->dev_addr))
  244. goto nla_put_failure;
  245. }
  246. if (nla_put_u8(msg, BATADV_ATTR_AGGREGATED_OGMS_ENABLED,
  247. !!atomic_read(&bat_priv->aggregated_ogms)))
  248. goto nla_put_failure;
  249. if (batadv_netlink_mesh_fill_ap_isolation(msg, bat_priv))
  250. goto nla_put_failure;
  251. if (nla_put_u32(msg, BATADV_ATTR_ISOLATION_MARK,
  252. bat_priv->isolation_mark))
  253. goto nla_put_failure;
  254. if (nla_put_u32(msg, BATADV_ATTR_ISOLATION_MASK,
  255. bat_priv->isolation_mark_mask))
  256. goto nla_put_failure;
  257. if (nla_put_u8(msg, BATADV_ATTR_BONDING_ENABLED,
  258. !!atomic_read(&bat_priv->bonding)))
  259. goto nla_put_failure;
  260. #ifdef CONFIG_BATMAN_ADV_BLA
  261. if (nla_put_u8(msg, BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED,
  262. !!atomic_read(&bat_priv->bridge_loop_avoidance)))
  263. goto nla_put_failure;
  264. #endif /* CONFIG_BATMAN_ADV_BLA */
  265. #ifdef CONFIG_BATMAN_ADV_DAT
  266. if (nla_put_u8(msg, BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED,
  267. !!atomic_read(&bat_priv->distributed_arp_table)))
  268. goto nla_put_failure;
  269. #endif /* CONFIG_BATMAN_ADV_DAT */
  270. if (nla_put_u8(msg, BATADV_ATTR_FRAGMENTATION_ENABLED,
  271. !!atomic_read(&bat_priv->fragmentation)))
  272. goto nla_put_failure;
  273. if (nla_put_u32(msg, BATADV_ATTR_GW_BANDWIDTH_DOWN,
  274. atomic_read(&bat_priv->gw.bandwidth_down)))
  275. goto nla_put_failure;
  276. if (nla_put_u32(msg, BATADV_ATTR_GW_BANDWIDTH_UP,
  277. atomic_read(&bat_priv->gw.bandwidth_up)))
  278. goto nla_put_failure;
  279. if (nla_put_u8(msg, BATADV_ATTR_GW_MODE,
  280. atomic_read(&bat_priv->gw.mode)))
  281. goto nla_put_failure;
  282. if (bat_priv->algo_ops->gw.get_best_gw_node &&
  283. bat_priv->algo_ops->gw.is_eligible) {
  284. /* GW selection class is not available if the routing algorithm
  285. * in use does not implement the GW API
  286. */
  287. if (nla_put_u32(msg, BATADV_ATTR_GW_SEL_CLASS,
  288. atomic_read(&bat_priv->gw.sel_class)))
  289. goto nla_put_failure;
  290. }
  291. if (nla_put_u8(msg, BATADV_ATTR_HOP_PENALTY,
  292. atomic_read(&bat_priv->hop_penalty)))
  293. goto nla_put_failure;
  294. #ifdef CONFIG_BATMAN_ADV_DEBUG
  295. if (nla_put_u32(msg, BATADV_ATTR_LOG_LEVEL,
  296. atomic_read(&bat_priv->log_level)))
  297. goto nla_put_failure;
  298. #endif /* CONFIG_BATMAN_ADV_DEBUG */
  299. #ifdef CONFIG_BATMAN_ADV_MCAST
  300. if (nla_put_u8(msg, BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED,
  301. !atomic_read(&bat_priv->multicast_mode)))
  302. goto nla_put_failure;
  303. if (nla_put_u32(msg, BATADV_ATTR_MULTICAST_FANOUT,
  304. atomic_read(&bat_priv->multicast_fanout)))
  305. goto nla_put_failure;
  306. #endif /* CONFIG_BATMAN_ADV_MCAST */
  307. #ifdef CONFIG_BATMAN_ADV_NC
  308. if (nla_put_u8(msg, BATADV_ATTR_NETWORK_CODING_ENABLED,
  309. !!atomic_read(&bat_priv->network_coding)))
  310. goto nla_put_failure;
  311. #endif /* CONFIG_BATMAN_ADV_NC */
  312. if (nla_put_u32(msg, BATADV_ATTR_ORIG_INTERVAL,
  313. atomic_read(&bat_priv->orig_interval)))
  314. goto nla_put_failure;
  315. if (primary_if)
  316. batadv_hardif_put(primary_if);
  317. genlmsg_end(msg, hdr);
  318. return 0;
  319. nla_put_failure:
  320. if (primary_if)
  321. batadv_hardif_put(primary_if);
  322. genlmsg_cancel(msg, hdr);
  323. return -EMSGSIZE;
  324. }
  325. /**
  326. * batadv_netlink_notify_mesh() - send softif attributes to listener
  327. * @bat_priv: the bat priv with all the soft interface information
  328. *
  329. * Return: 0 on success, < 0 on error
  330. */
  331. int batadv_netlink_notify_mesh(struct batadv_priv *bat_priv)
  332. {
  333. struct sk_buff *msg;
  334. int ret;
  335. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  336. if (!msg)
  337. return -ENOMEM;
  338. ret = batadv_netlink_mesh_fill(msg, bat_priv, BATADV_CMD_SET_MESH,
  339. 0, 0, 0);
  340. if (ret < 0) {
  341. nlmsg_free(msg);
  342. return ret;
  343. }
  344. genlmsg_multicast_netns(&batadv_netlink_family,
  345. dev_net(bat_priv->soft_iface), msg, 0,
  346. BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
  347. return 0;
  348. }
  349. /**
  350. * batadv_netlink_get_mesh() - Get softif attributes
  351. * @skb: Netlink message with request data
  352. * @info: receiver information
  353. *
  354. * Return: 0 on success or negative error number in case of failure
  355. */
  356. static int batadv_netlink_get_mesh(struct sk_buff *skb, struct genl_info *info)
  357. {
  358. struct batadv_priv *bat_priv = info->user_ptr[0];
  359. struct sk_buff *msg;
  360. int ret;
  361. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  362. if (!msg)
  363. return -ENOMEM;
  364. ret = batadv_netlink_mesh_fill(msg, bat_priv, BATADV_CMD_GET_MESH,
  365. info->snd_portid, info->snd_seq, 0);
  366. if (ret < 0) {
  367. nlmsg_free(msg);
  368. return ret;
  369. }
  370. ret = genlmsg_reply(msg, info);
  371. return ret;
  372. }
  373. /**
  374. * batadv_netlink_set_mesh() - Set softif attributes
  375. * @skb: Netlink message with request data
  376. * @info: receiver information
  377. *
  378. * Return: 0 on success or negative error number in case of failure
  379. */
  380. static int batadv_netlink_set_mesh(struct sk_buff *skb, struct genl_info *info)
  381. {
  382. struct batadv_priv *bat_priv = info->user_ptr[0];
  383. struct nlattr *attr;
  384. if (info->attrs[BATADV_ATTR_AGGREGATED_OGMS_ENABLED]) {
  385. attr = info->attrs[BATADV_ATTR_AGGREGATED_OGMS_ENABLED];
  386. atomic_set(&bat_priv->aggregated_ogms, !!nla_get_u8(attr));
  387. }
  388. if (info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED]) {
  389. attr = info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED];
  390. batadv_netlink_set_mesh_ap_isolation(attr, bat_priv);
  391. }
  392. if (info->attrs[BATADV_ATTR_ISOLATION_MARK]) {
  393. attr = info->attrs[BATADV_ATTR_ISOLATION_MARK];
  394. bat_priv->isolation_mark = nla_get_u32(attr);
  395. }
  396. if (info->attrs[BATADV_ATTR_ISOLATION_MASK]) {
  397. attr = info->attrs[BATADV_ATTR_ISOLATION_MASK];
  398. bat_priv->isolation_mark_mask = nla_get_u32(attr);
  399. }
  400. if (info->attrs[BATADV_ATTR_BONDING_ENABLED]) {
  401. attr = info->attrs[BATADV_ATTR_BONDING_ENABLED];
  402. atomic_set(&bat_priv->bonding, !!nla_get_u8(attr));
  403. }
  404. #ifdef CONFIG_BATMAN_ADV_BLA
  405. if (info->attrs[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED]) {
  406. attr = info->attrs[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED];
  407. atomic_set(&bat_priv->bridge_loop_avoidance,
  408. !!nla_get_u8(attr));
  409. batadv_bla_status_update(bat_priv->soft_iface);
  410. }
  411. #endif /* CONFIG_BATMAN_ADV_BLA */
  412. #ifdef CONFIG_BATMAN_ADV_DAT
  413. if (info->attrs[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED]) {
  414. attr = info->attrs[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED];
  415. atomic_set(&bat_priv->distributed_arp_table,
  416. !!nla_get_u8(attr));
  417. batadv_dat_status_update(bat_priv->soft_iface);
  418. }
  419. #endif /* CONFIG_BATMAN_ADV_DAT */
  420. if (info->attrs[BATADV_ATTR_FRAGMENTATION_ENABLED]) {
  421. attr = info->attrs[BATADV_ATTR_FRAGMENTATION_ENABLED];
  422. atomic_set(&bat_priv->fragmentation, !!nla_get_u8(attr));
  423. batadv_update_min_mtu(bat_priv->soft_iface);
  424. }
  425. if (info->attrs[BATADV_ATTR_GW_BANDWIDTH_DOWN]) {
  426. attr = info->attrs[BATADV_ATTR_GW_BANDWIDTH_DOWN];
  427. atomic_set(&bat_priv->gw.bandwidth_down, nla_get_u32(attr));
  428. batadv_gw_tvlv_container_update(bat_priv);
  429. }
  430. if (info->attrs[BATADV_ATTR_GW_BANDWIDTH_UP]) {
  431. attr = info->attrs[BATADV_ATTR_GW_BANDWIDTH_UP];
  432. atomic_set(&bat_priv->gw.bandwidth_up, nla_get_u32(attr));
  433. batadv_gw_tvlv_container_update(bat_priv);
  434. }
  435. if (info->attrs[BATADV_ATTR_GW_MODE]) {
  436. u8 gw_mode;
  437. attr = info->attrs[BATADV_ATTR_GW_MODE];
  438. gw_mode = nla_get_u8(attr);
  439. if (gw_mode <= BATADV_GW_MODE_SERVER) {
  440. /* Invoking batadv_gw_reselect() is not enough to really
  441. * de-select the current GW. It will only instruct the
  442. * gateway client code to perform a re-election the next
  443. * time that this is needed.
  444. *
  445. * When gw client mode is being switched off the current
  446. * GW must be de-selected explicitly otherwise no GW_ADD
  447. * uevent is thrown on client mode re-activation. This
  448. * is operation is performed in
  449. * batadv_gw_check_client_stop().
  450. */
  451. batadv_gw_reselect(bat_priv);
  452. /* always call batadv_gw_check_client_stop() before
  453. * changing the gateway state
  454. */
  455. batadv_gw_check_client_stop(bat_priv);
  456. atomic_set(&bat_priv->gw.mode, gw_mode);
  457. batadv_gw_tvlv_container_update(bat_priv);
  458. }
  459. }
  460. if (info->attrs[BATADV_ATTR_GW_SEL_CLASS] &&
  461. bat_priv->algo_ops->gw.get_best_gw_node &&
  462. bat_priv->algo_ops->gw.is_eligible) {
  463. /* setting the GW selection class is allowed only if the routing
  464. * algorithm in use implements the GW API
  465. */
  466. u32 sel_class_max = 0xffffffffu;
  467. u32 sel_class;
  468. attr = info->attrs[BATADV_ATTR_GW_SEL_CLASS];
  469. sel_class = nla_get_u32(attr);
  470. if (!bat_priv->algo_ops->gw.store_sel_class)
  471. sel_class_max = BATADV_TQ_MAX_VALUE;
  472. if (sel_class >= 1 && sel_class <= sel_class_max) {
  473. atomic_set(&bat_priv->gw.sel_class, sel_class);
  474. batadv_gw_reselect(bat_priv);
  475. }
  476. }
  477. if (info->attrs[BATADV_ATTR_HOP_PENALTY]) {
  478. attr = info->attrs[BATADV_ATTR_HOP_PENALTY];
  479. atomic_set(&bat_priv->hop_penalty, nla_get_u8(attr));
  480. }
  481. #ifdef CONFIG_BATMAN_ADV_DEBUG
  482. if (info->attrs[BATADV_ATTR_LOG_LEVEL]) {
  483. attr = info->attrs[BATADV_ATTR_LOG_LEVEL];
  484. atomic_set(&bat_priv->log_level,
  485. nla_get_u32(attr) & BATADV_DBG_ALL);
  486. }
  487. #endif /* CONFIG_BATMAN_ADV_DEBUG */
  488. #ifdef CONFIG_BATMAN_ADV_MCAST
  489. if (info->attrs[BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED]) {
  490. attr = info->attrs[BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED];
  491. atomic_set(&bat_priv->multicast_mode, !nla_get_u8(attr));
  492. }
  493. if (info->attrs[BATADV_ATTR_MULTICAST_FANOUT]) {
  494. attr = info->attrs[BATADV_ATTR_MULTICAST_FANOUT];
  495. atomic_set(&bat_priv->multicast_fanout, nla_get_u32(attr));
  496. }
  497. #endif /* CONFIG_BATMAN_ADV_MCAST */
  498. #ifdef CONFIG_BATMAN_ADV_NC
  499. if (info->attrs[BATADV_ATTR_NETWORK_CODING_ENABLED]) {
  500. attr = info->attrs[BATADV_ATTR_NETWORK_CODING_ENABLED];
  501. atomic_set(&bat_priv->network_coding, !!nla_get_u8(attr));
  502. batadv_nc_status_update(bat_priv->soft_iface);
  503. }
  504. #endif /* CONFIG_BATMAN_ADV_NC */
  505. if (info->attrs[BATADV_ATTR_ORIG_INTERVAL]) {
  506. u32 orig_interval;
  507. attr = info->attrs[BATADV_ATTR_ORIG_INTERVAL];
  508. orig_interval = nla_get_u32(attr);
  509. orig_interval = min_t(u32, orig_interval, INT_MAX);
  510. orig_interval = max_t(u32, orig_interval, 2 * BATADV_JITTER);
  511. atomic_set(&bat_priv->orig_interval, orig_interval);
  512. }
  513. batadv_netlink_notify_mesh(bat_priv);
  514. return 0;
  515. }
  516. /**
  517. * batadv_netlink_tp_meter_put() - Fill information of started tp_meter session
  518. * @msg: netlink message to be sent back
  519. * @cookie: tp meter session cookie
  520. *
  521. * Return: 0 on success, < 0 on error
  522. */
  523. static int
  524. batadv_netlink_tp_meter_put(struct sk_buff *msg, u32 cookie)
  525. {
  526. if (nla_put_u32(msg, BATADV_ATTR_TPMETER_COOKIE, cookie))
  527. return -ENOBUFS;
  528. return 0;
  529. }
  530. /**
  531. * batadv_netlink_tpmeter_notify() - send tp_meter result via netlink to client
  532. * @bat_priv: the bat priv with all the soft interface information
  533. * @dst: destination of tp_meter session
  534. * @result: reason for tp meter session stop
  535. * @test_time: total time of the tp_meter session
  536. * @total_bytes: bytes acked to the receiver
  537. * @cookie: cookie of tp_meter session
  538. *
  539. * Return: 0 on success, < 0 on error
  540. */
  541. int batadv_netlink_tpmeter_notify(struct batadv_priv *bat_priv, const u8 *dst,
  542. u8 result, u32 test_time, u64 total_bytes,
  543. u32 cookie)
  544. {
  545. struct sk_buff *msg;
  546. void *hdr;
  547. int ret;
  548. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  549. if (!msg)
  550. return -ENOMEM;
  551. hdr = genlmsg_put(msg, 0, 0, &batadv_netlink_family, 0,
  552. BATADV_CMD_TP_METER);
  553. if (!hdr) {
  554. ret = -ENOBUFS;
  555. goto err_genlmsg;
  556. }
  557. if (nla_put_u32(msg, BATADV_ATTR_TPMETER_COOKIE, cookie))
  558. goto nla_put_failure;
  559. if (nla_put_u32(msg, BATADV_ATTR_TPMETER_TEST_TIME, test_time))
  560. goto nla_put_failure;
  561. if (nla_put_u64_64bit(msg, BATADV_ATTR_TPMETER_BYTES, total_bytes,
  562. BATADV_ATTR_PAD))
  563. goto nla_put_failure;
  564. if (nla_put_u8(msg, BATADV_ATTR_TPMETER_RESULT, result))
  565. goto nla_put_failure;
  566. if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, dst))
  567. goto nla_put_failure;
  568. genlmsg_end(msg, hdr);
  569. genlmsg_multicast_netns(&batadv_netlink_family,
  570. dev_net(bat_priv->soft_iface), msg, 0,
  571. BATADV_NL_MCGRP_TPMETER, GFP_KERNEL);
  572. return 0;
  573. nla_put_failure:
  574. genlmsg_cancel(msg, hdr);
  575. ret = -EMSGSIZE;
  576. err_genlmsg:
  577. nlmsg_free(msg);
  578. return ret;
  579. }
  580. /**
  581. * batadv_netlink_tp_meter_start() - Start a new tp_meter session
  582. * @skb: received netlink message
  583. * @info: receiver information
  584. *
  585. * Return: 0 on success, < 0 on error
  586. */
  587. static int
  588. batadv_netlink_tp_meter_start(struct sk_buff *skb, struct genl_info *info)
  589. {
  590. struct batadv_priv *bat_priv = info->user_ptr[0];
  591. struct sk_buff *msg = NULL;
  592. u32 test_length;
  593. void *msg_head;
  594. u32 cookie;
  595. u8 *dst;
  596. int ret;
  597. if (!info->attrs[BATADV_ATTR_ORIG_ADDRESS])
  598. return -EINVAL;
  599. if (!info->attrs[BATADV_ATTR_TPMETER_TEST_TIME])
  600. return -EINVAL;
  601. dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);
  602. test_length = nla_get_u32(info->attrs[BATADV_ATTR_TPMETER_TEST_TIME]);
  603. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  604. if (!msg) {
  605. ret = -ENOMEM;
  606. goto out;
  607. }
  608. msg_head = genlmsg_put(msg, info->snd_portid, info->snd_seq,
  609. &batadv_netlink_family, 0,
  610. BATADV_CMD_TP_METER);
  611. if (!msg_head) {
  612. ret = -ENOBUFS;
  613. goto out;
  614. }
  615. batadv_tp_start(bat_priv, dst, test_length, &cookie);
  616. ret = batadv_netlink_tp_meter_put(msg, cookie);
  617. out:
  618. if (ret) {
  619. if (msg)
  620. nlmsg_free(msg);
  621. return ret;
  622. }
  623. genlmsg_end(msg, msg_head);
  624. return genlmsg_reply(msg, info);
  625. }
  626. /**
  627. * batadv_netlink_tp_meter_start() - Cancel a running tp_meter session
  628. * @skb: received netlink message
  629. * @info: receiver information
  630. *
  631. * Return: 0 on success, < 0 on error
  632. */
  633. static int
  634. batadv_netlink_tp_meter_cancel(struct sk_buff *skb, struct genl_info *info)
  635. {
  636. struct batadv_priv *bat_priv = info->user_ptr[0];
  637. u8 *dst;
  638. int ret = 0;
  639. if (!info->attrs[BATADV_ATTR_ORIG_ADDRESS])
  640. return -EINVAL;
  641. dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);
  642. batadv_tp_stop(bat_priv, dst, BATADV_TP_REASON_CANCEL);
  643. return ret;
  644. }
  645. /**
  646. * batadv_netlink_hardif_fill() - Fill message with hardif attributes
  647. * @msg: Netlink message to dump into
  648. * @bat_priv: the bat priv with all the soft interface information
  649. * @hard_iface: hard interface which was modified
  650. * @cmd: type of message to generate
  651. * @portid: Port making netlink request
  652. * @seq: sequence number for message
  653. * @flags: Additional flags for message
  654. * @cb: Control block containing additional options
  655. *
  656. * Return: 0 on success or negative error number in case of failure
  657. */
  658. static int batadv_netlink_hardif_fill(struct sk_buff *msg,
  659. struct batadv_priv *bat_priv,
  660. struct batadv_hard_iface *hard_iface,
  661. enum batadv_nl_commands cmd,
  662. u32 portid, u32 seq, int flags,
  663. struct netlink_callback *cb)
  664. {
  665. struct net_device *net_dev = hard_iface->net_dev;
  666. void *hdr;
  667. hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
  668. if (!hdr)
  669. return -ENOBUFS;
  670. if (cb)
  671. genl_dump_check_consistent(cb, hdr);
  672. if (nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX,
  673. bat_priv->soft_iface->ifindex))
  674. goto nla_put_failure;
  675. if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
  676. net_dev->ifindex) ||
  677. nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
  678. net_dev->name) ||
  679. nla_put(msg, BATADV_ATTR_HARD_ADDRESS, ETH_ALEN,
  680. net_dev->dev_addr))
  681. goto nla_put_failure;
  682. if (hard_iface->if_status == BATADV_IF_ACTIVE) {
  683. if (nla_put_flag(msg, BATADV_ATTR_ACTIVE))
  684. goto nla_put_failure;
  685. }
  686. if (nla_put_u8(msg, BATADV_ATTR_HOP_PENALTY,
  687. atomic_read(&hard_iface->hop_penalty)))
  688. goto nla_put_failure;
  689. #ifdef CONFIG_BATMAN_ADV_BATMAN_V
  690. if (nla_put_u32(msg, BATADV_ATTR_ELP_INTERVAL,
  691. atomic_read(&hard_iface->bat_v.elp_interval)))
  692. goto nla_put_failure;
  693. if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT_OVERRIDE,
  694. atomic_read(&hard_iface->bat_v.throughput_override)))
  695. goto nla_put_failure;
  696. #endif /* CONFIG_BATMAN_ADV_BATMAN_V */
  697. genlmsg_end(msg, hdr);
  698. return 0;
  699. nla_put_failure:
  700. genlmsg_cancel(msg, hdr);
  701. return -EMSGSIZE;
  702. }
  703. /**
  704. * batadv_netlink_notify_hardif() - send hardif attributes to listener
  705. * @bat_priv: the bat priv with all the soft interface information
  706. * @hard_iface: hard interface which was modified
  707. *
  708. * Return: 0 on success, < 0 on error
  709. */
  710. int batadv_netlink_notify_hardif(struct batadv_priv *bat_priv,
  711. struct batadv_hard_iface *hard_iface)
  712. {
  713. struct sk_buff *msg;
  714. int ret;
  715. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  716. if (!msg)
  717. return -ENOMEM;
  718. ret = batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
  719. BATADV_CMD_SET_HARDIF, 0, 0, 0, NULL);
  720. if (ret < 0) {
  721. nlmsg_free(msg);
  722. return ret;
  723. }
  724. genlmsg_multicast_netns(&batadv_netlink_family,
  725. dev_net(bat_priv->soft_iface), msg, 0,
  726. BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
  727. return 0;
  728. }
  729. /**
  730. * batadv_netlink_get_hardif() - Get hardif attributes
  731. * @skb: Netlink message with request data
  732. * @info: receiver information
  733. *
  734. * Return: 0 on success or negative error number in case of failure
  735. */
  736. static int batadv_netlink_get_hardif(struct sk_buff *skb,
  737. struct genl_info *info)
  738. {
  739. struct batadv_hard_iface *hard_iface = info->user_ptr[1];
  740. struct batadv_priv *bat_priv = info->user_ptr[0];
  741. struct sk_buff *msg;
  742. int ret;
  743. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  744. if (!msg)
  745. return -ENOMEM;
  746. ret = batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
  747. BATADV_CMD_GET_HARDIF,
  748. info->snd_portid, info->snd_seq, 0,
  749. NULL);
  750. if (ret < 0) {
  751. nlmsg_free(msg);
  752. return ret;
  753. }
  754. ret = genlmsg_reply(msg, info);
  755. return ret;
  756. }
  757. /**
  758. * batadv_netlink_set_hardif() - Set hardif attributes
  759. * @skb: Netlink message with request data
  760. * @info: receiver information
  761. *
  762. * Return: 0 on success or negative error number in case of failure
  763. */
  764. static int batadv_netlink_set_hardif(struct sk_buff *skb,
  765. struct genl_info *info)
  766. {
  767. struct batadv_hard_iface *hard_iface = info->user_ptr[1];
  768. struct batadv_priv *bat_priv = info->user_ptr[0];
  769. struct nlattr *attr;
  770. if (info->attrs[BATADV_ATTR_HOP_PENALTY]) {
  771. attr = info->attrs[BATADV_ATTR_HOP_PENALTY];
  772. atomic_set(&hard_iface->hop_penalty, nla_get_u8(attr));
  773. }
  774. #ifdef CONFIG_BATMAN_ADV_BATMAN_V
  775. if (info->attrs[BATADV_ATTR_ELP_INTERVAL]) {
  776. attr = info->attrs[BATADV_ATTR_ELP_INTERVAL];
  777. atomic_set(&hard_iface->bat_v.elp_interval, nla_get_u32(attr));
  778. }
  779. if (info->attrs[BATADV_ATTR_THROUGHPUT_OVERRIDE]) {
  780. attr = info->attrs[BATADV_ATTR_THROUGHPUT_OVERRIDE];
  781. atomic_set(&hard_iface->bat_v.throughput_override,
  782. nla_get_u32(attr));
  783. }
  784. #endif /* CONFIG_BATMAN_ADV_BATMAN_V */
  785. batadv_netlink_notify_hardif(bat_priv, hard_iface);
  786. return 0;
  787. }
  788. /**
  789. * batadv_netlink_dump_hardif() - Dump all hard interface into a messages
  790. * @msg: Netlink message to dump into
  791. * @cb: Parameters from query
  792. *
  793. * Return: error code, or length of reply message on success
  794. */
  795. static int
  796. batadv_netlink_dump_hardif(struct sk_buff *msg, struct netlink_callback *cb)
  797. {
  798. struct net *net = sock_net(cb->skb->sk);
  799. struct net_device *soft_iface;
  800. struct batadv_hard_iface *hard_iface;
  801. struct batadv_priv *bat_priv;
  802. int ifindex;
  803. int portid = NETLINK_CB(cb->skb).portid;
  804. int skip = cb->args[0];
  805. int i = 0;
  806. ifindex = batadv_netlink_get_ifindex(cb->nlh,
  807. BATADV_ATTR_MESH_IFINDEX);
  808. if (!ifindex)
  809. return -EINVAL;
  810. soft_iface = dev_get_by_index(net, ifindex);
  811. if (!soft_iface)
  812. return -ENODEV;
  813. if (!batadv_softif_is_valid(soft_iface)) {
  814. dev_put(soft_iface);
  815. return -ENODEV;
  816. }
  817. bat_priv = netdev_priv(soft_iface);
  818. rtnl_lock();
  819. cb->seq = batadv_hardif_generation << 1 | 1;
  820. list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
  821. if (hard_iface->soft_iface != soft_iface)
  822. continue;
  823. if (i++ < skip)
  824. continue;
  825. if (batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
  826. BATADV_CMD_GET_HARDIF,
  827. portid, cb->nlh->nlmsg_seq,
  828. NLM_F_MULTI, cb)) {
  829. i--;
  830. break;
  831. }
  832. }
  833. rtnl_unlock();
  834. dev_put(soft_iface);
  835. cb->args[0] = i;
  836. return msg->len;
  837. }
  838. /**
  839. * batadv_netlink_vlan_fill() - Fill message with vlan attributes
  840. * @msg: Netlink message to dump into
  841. * @bat_priv: the bat priv with all the soft interface information
  842. * @vlan: vlan which was modified
  843. * @cmd: type of message to generate
  844. * @portid: Port making netlink request
  845. * @seq: sequence number for message
  846. * @flags: Additional flags for message
  847. *
  848. * Return: 0 on success or negative error number in case of failure
  849. */
  850. static int batadv_netlink_vlan_fill(struct sk_buff *msg,
  851. struct batadv_priv *bat_priv,
  852. struct batadv_softif_vlan *vlan,
  853. enum batadv_nl_commands cmd,
  854. u32 portid, u32 seq, int flags)
  855. {
  856. void *hdr;
  857. hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
  858. if (!hdr)
  859. return -ENOBUFS;
  860. if (nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX,
  861. bat_priv->soft_iface->ifindex))
  862. goto nla_put_failure;
  863. if (nla_put_u32(msg, BATADV_ATTR_VLANID, vlan->vid & VLAN_VID_MASK))
  864. goto nla_put_failure;
  865. if (nla_put_u8(msg, BATADV_ATTR_AP_ISOLATION_ENABLED,
  866. !!atomic_read(&vlan->ap_isolation)))
  867. goto nla_put_failure;
  868. genlmsg_end(msg, hdr);
  869. return 0;
  870. nla_put_failure:
  871. genlmsg_cancel(msg, hdr);
  872. return -EMSGSIZE;
  873. }
  874. /**
  875. * batadv_netlink_notify_vlan() - send vlan attributes to listener
  876. * @bat_priv: the bat priv with all the soft interface information
  877. * @vlan: vlan which was modified
  878. *
  879. * Return: 0 on success, < 0 on error
  880. */
  881. int batadv_netlink_notify_vlan(struct batadv_priv *bat_priv,
  882. struct batadv_softif_vlan *vlan)
  883. {
  884. struct sk_buff *msg;
  885. int ret;
  886. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  887. if (!msg)
  888. return -ENOMEM;
  889. ret = batadv_netlink_vlan_fill(msg, bat_priv, vlan,
  890. BATADV_CMD_SET_VLAN, 0, 0, 0);
  891. if (ret < 0) {
  892. nlmsg_free(msg);
  893. return ret;
  894. }
  895. genlmsg_multicast_netns(&batadv_netlink_family,
  896. dev_net(bat_priv->soft_iface), msg, 0,
  897. BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
  898. return 0;
  899. }
  900. /**
  901. * batadv_netlink_get_vlan() - Get vlan attributes
  902. * @skb: Netlink message with request data
  903. * @info: receiver information
  904. *
  905. * Return: 0 on success or negative error number in case of failure
  906. */
  907. static int batadv_netlink_get_vlan(struct sk_buff *skb, struct genl_info *info)
  908. {
  909. struct batadv_softif_vlan *vlan = info->user_ptr[1];
  910. struct batadv_priv *bat_priv = info->user_ptr[0];
  911. struct sk_buff *msg;
  912. int ret;
  913. msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
  914. if (!msg)
  915. return -ENOMEM;
  916. ret = batadv_netlink_vlan_fill(msg, bat_priv, vlan, BATADV_CMD_GET_VLAN,
  917. info->snd_portid, info->snd_seq, 0);
  918. if (ret < 0) {
  919. nlmsg_free(msg);
  920. return ret;
  921. }
  922. ret = genlmsg_reply(msg, info);
  923. return ret;
  924. }
  925. /**
  926. * batadv_netlink_set_vlan() - Get vlan attributes
  927. * @skb: Netlink message with request data
  928. * @info: receiver information
  929. *
  930. * Return: 0 on success or negative error number in case of failure
  931. */
  932. static int batadv_netlink_set_vlan(struct sk_buff *skb, struct genl_info *info)
  933. {
  934. struct batadv_softif_vlan *vlan = info->user_ptr[1];
  935. struct batadv_priv *bat_priv = info->user_ptr[0];
  936. struct nlattr *attr;
  937. if (info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED]) {
  938. attr = info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED];
  939. atomic_set(&vlan->ap_isolation, !!nla_get_u8(attr));
  940. }
  941. batadv_netlink_notify_vlan(bat_priv, vlan);
  942. return 0;
  943. }
  944. /**
  945. * batadv_get_softif_from_info() - Retrieve soft interface from genl attributes
  946. * @net: the applicable net namespace
  947. * @info: receiver information
  948. *
  949. * Return: Pointer to soft interface (with increased refcnt) on success, error
  950. * pointer on error
  951. */
  952. static struct net_device *
  953. batadv_get_softif_from_info(struct net *net, struct genl_info *info)
  954. {
  955. struct net_device *soft_iface;
  956. int ifindex;
  957. if (!info->attrs[BATADV_ATTR_MESH_IFINDEX])
  958. return ERR_PTR(-EINVAL);
  959. ifindex = nla_get_u32(info->attrs[BATADV_ATTR_MESH_IFINDEX]);
  960. soft_iface = dev_get_by_index(net, ifindex);
  961. if (!soft_iface)
  962. return ERR_PTR(-ENODEV);
  963. if (!batadv_softif_is_valid(soft_iface))
  964. goto err_put_softif;
  965. return soft_iface;
  966. err_put_softif:
  967. dev_put(soft_iface);
  968. return ERR_PTR(-EINVAL);
  969. }
  970. /**
  971. * batadv_get_hardif_from_info() - Retrieve hardif from genl attributes
  972. * @bat_priv: the bat priv with all the soft interface information
  973. * @net: the applicable net namespace
  974. * @info: receiver information
  975. *
  976. * Return: Pointer to hard interface (with increased refcnt) on success, error
  977. * pointer on error
  978. */
  979. static struct batadv_hard_iface *
  980. batadv_get_hardif_from_info(struct batadv_priv *bat_priv, struct net *net,
  981. struct genl_info *info)
  982. {
  983. struct batadv_hard_iface *hard_iface;
  984. struct net_device *hard_dev;
  985. unsigned int hardif_index;
  986. if (!info->attrs[BATADV_ATTR_HARD_IFINDEX])
  987. return ERR_PTR(-EINVAL);
  988. hardif_index = nla_get_u32(info->attrs[BATADV_ATTR_HARD_IFINDEX]);
  989. hard_dev = dev_get_by_index(net, hardif_index);
  990. if (!hard_dev)
  991. return ERR_PTR(-ENODEV);
  992. hard_iface = batadv_hardif_get_by_netdev(hard_dev);
  993. if (!hard_iface)
  994. goto err_put_harddev;
  995. if (hard_iface->soft_iface != bat_priv->soft_iface)
  996. goto err_put_hardif;
  997. /* hard_dev is referenced by hard_iface and not needed here */
  998. dev_put(hard_dev);
  999. return hard_iface;
  1000. err_put_hardif:
  1001. batadv_hardif_put(hard_iface);
  1002. err_put_harddev:
  1003. dev_put(hard_dev);
  1004. return ERR_PTR(-EINVAL);
  1005. }
  1006. /**
  1007. * batadv_get_vlan_from_info() - Retrieve vlan from genl attributes
  1008. * @bat_priv: the bat priv with all the soft interface information
  1009. * @net: the applicable net namespace
  1010. * @info: receiver information
  1011. *
  1012. * Return: Pointer to vlan on success (with increased refcnt), error pointer
  1013. * on error
  1014. */
  1015. static struct batadv_softif_vlan *
  1016. batadv_get_vlan_from_info(struct batadv_priv *bat_priv, struct net *net,
  1017. struct genl_info *info)
  1018. {
  1019. struct batadv_softif_vlan *vlan;
  1020. u16 vid;
  1021. if (!info->attrs[BATADV_ATTR_VLANID])
  1022. return ERR_PTR(-EINVAL);
  1023. vid = nla_get_u16(info->attrs[BATADV_ATTR_VLANID]);
  1024. vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
  1025. if (!vlan)
  1026. return ERR_PTR(-ENOENT);
  1027. return vlan;
  1028. }
  1029. /**
  1030. * batadv_pre_doit() - Prepare batman-adv genl doit request
  1031. * @ops: requested netlink operation
  1032. * @skb: Netlink message with request data
  1033. * @info: receiver information
  1034. *
  1035. * Return: 0 on success or negative error number in case of failure
  1036. */
  1037. static int batadv_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
  1038. struct genl_info *info)
  1039. {
  1040. struct net *net = genl_info_net(info);
  1041. struct batadv_hard_iface *hard_iface;
  1042. struct batadv_priv *bat_priv = NULL;
  1043. struct batadv_softif_vlan *vlan;
  1044. struct net_device *soft_iface;
  1045. u8 user_ptr1_flags;
  1046. u8 mesh_dep_flags;
  1047. int ret;
  1048. user_ptr1_flags = BATADV_FLAG_NEED_HARDIF | BATADV_FLAG_NEED_VLAN;
  1049. if (WARN_ON(hweight8(ops->internal_flags & user_ptr1_flags) > 1))
  1050. return -EINVAL;
  1051. mesh_dep_flags = BATADV_FLAG_NEED_HARDIF | BATADV_FLAG_NEED_VLAN;
  1052. if (WARN_ON((ops->internal_flags & mesh_dep_flags) &&
  1053. (~ops->internal_flags & BATADV_FLAG_NEED_MESH)))
  1054. return -EINVAL;
  1055. if (ops->internal_flags & BATADV_FLAG_NEED_MESH) {
  1056. soft_iface = batadv_get_softif_from_info(net, info);
  1057. if (IS_ERR(soft_iface))
  1058. return PTR_ERR(soft_iface);
  1059. bat_priv = netdev_priv(soft_iface);
  1060. info->user_ptr[0] = bat_priv;
  1061. }
  1062. if (ops->internal_flags & BATADV_FLAG_NEED_HARDIF) {
  1063. hard_iface = batadv_get_hardif_from_info(bat_priv, net, info);
  1064. if (IS_ERR(hard_iface)) {
  1065. ret = PTR_ERR(hard_iface);
  1066. goto err_put_softif;
  1067. }
  1068. info->user_ptr[1] = hard_iface;
  1069. }
  1070. if (ops->internal_flags & BATADV_FLAG_NEED_VLAN) {
  1071. vlan = batadv_get_vlan_from_info(bat_priv, net, info);
  1072. if (IS_ERR(vlan)) {
  1073. ret = PTR_ERR(vlan);
  1074. goto err_put_softif;
  1075. }
  1076. info->user_ptr[1] = vlan;
  1077. }
  1078. return 0;
  1079. err_put_softif:
  1080. if (bat_priv)
  1081. dev_put(bat_priv->soft_iface);
  1082. return ret;
  1083. }
  1084. /**
  1085. * batadv_post_doit() - End batman-adv genl doit request
  1086. * @ops: requested netlink operation
  1087. * @skb: Netlink message with request data
  1088. * @info: receiver information
  1089. */
  1090. static void batadv_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
  1091. struct genl_info *info)
  1092. {
  1093. struct batadv_hard_iface *hard_iface;
  1094. struct batadv_softif_vlan *vlan;
  1095. struct batadv_priv *bat_priv;
  1096. if (ops->internal_flags & BATADV_FLAG_NEED_HARDIF &&
  1097. info->user_ptr[1]) {
  1098. hard_iface = info->user_ptr[1];
  1099. batadv_hardif_put(hard_iface);
  1100. }
  1101. if (ops->internal_flags & BATADV_FLAG_NEED_VLAN && info->user_ptr[1]) {
  1102. vlan = info->user_ptr[1];
  1103. batadv_softif_vlan_put(vlan);
  1104. }
  1105. if (ops->internal_flags & BATADV_FLAG_NEED_MESH && info->user_ptr[0]) {
  1106. bat_priv = info->user_ptr[0];
  1107. dev_put(bat_priv->soft_iface);
  1108. }
  1109. }
  1110. static const struct genl_small_ops batadv_netlink_ops[] = {
  1111. {
  1112. .cmd = BATADV_CMD_GET_MESH,
  1113. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1114. /* can be retrieved by unprivileged users */
  1115. .doit = batadv_netlink_get_mesh,
  1116. .internal_flags = BATADV_FLAG_NEED_MESH,
  1117. },
  1118. {
  1119. .cmd = BATADV_CMD_TP_METER,
  1120. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1121. .flags = GENL_UNS_ADMIN_PERM,
  1122. .doit = batadv_netlink_tp_meter_start,
  1123. .internal_flags = BATADV_FLAG_NEED_MESH,
  1124. },
  1125. {
  1126. .cmd = BATADV_CMD_TP_METER_CANCEL,
  1127. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1128. .flags = GENL_UNS_ADMIN_PERM,
  1129. .doit = batadv_netlink_tp_meter_cancel,
  1130. .internal_flags = BATADV_FLAG_NEED_MESH,
  1131. },
  1132. {
  1133. .cmd = BATADV_CMD_GET_ROUTING_ALGOS,
  1134. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1135. .flags = GENL_UNS_ADMIN_PERM,
  1136. .dumpit = batadv_algo_dump,
  1137. },
  1138. {
  1139. .cmd = BATADV_CMD_GET_HARDIF,
  1140. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1141. /* can be retrieved by unprivileged users */
  1142. .dumpit = batadv_netlink_dump_hardif,
  1143. .doit = batadv_netlink_get_hardif,
  1144. .internal_flags = BATADV_FLAG_NEED_MESH |
  1145. BATADV_FLAG_NEED_HARDIF,
  1146. },
  1147. {
  1148. .cmd = BATADV_CMD_GET_TRANSTABLE_LOCAL,
  1149. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1150. .flags = GENL_UNS_ADMIN_PERM,
  1151. .dumpit = batadv_tt_local_dump,
  1152. },
  1153. {
  1154. .cmd = BATADV_CMD_GET_TRANSTABLE_GLOBAL,
  1155. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1156. .flags = GENL_UNS_ADMIN_PERM,
  1157. .dumpit = batadv_tt_global_dump,
  1158. },
  1159. {
  1160. .cmd = BATADV_CMD_GET_ORIGINATORS,
  1161. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1162. .flags = GENL_UNS_ADMIN_PERM,
  1163. .dumpit = batadv_orig_dump,
  1164. },
  1165. {
  1166. .cmd = BATADV_CMD_GET_NEIGHBORS,
  1167. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1168. .flags = GENL_UNS_ADMIN_PERM,
  1169. .dumpit = batadv_hardif_neigh_dump,
  1170. },
  1171. {
  1172. .cmd = BATADV_CMD_GET_GATEWAYS,
  1173. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1174. .flags = GENL_UNS_ADMIN_PERM,
  1175. .dumpit = batadv_gw_dump,
  1176. },
  1177. {
  1178. .cmd = BATADV_CMD_GET_BLA_CLAIM,
  1179. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1180. .flags = GENL_UNS_ADMIN_PERM,
  1181. .dumpit = batadv_bla_claim_dump,
  1182. },
  1183. {
  1184. .cmd = BATADV_CMD_GET_BLA_BACKBONE,
  1185. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1186. .flags = GENL_UNS_ADMIN_PERM,
  1187. .dumpit = batadv_bla_backbone_dump,
  1188. },
  1189. {
  1190. .cmd = BATADV_CMD_GET_DAT_CACHE,
  1191. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1192. .flags = GENL_UNS_ADMIN_PERM,
  1193. .dumpit = batadv_dat_cache_dump,
  1194. },
  1195. {
  1196. .cmd = BATADV_CMD_GET_MCAST_FLAGS,
  1197. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1198. .flags = GENL_UNS_ADMIN_PERM,
  1199. .dumpit = batadv_mcast_flags_dump,
  1200. },
  1201. {
  1202. .cmd = BATADV_CMD_SET_MESH,
  1203. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1204. .flags = GENL_UNS_ADMIN_PERM,
  1205. .doit = batadv_netlink_set_mesh,
  1206. .internal_flags = BATADV_FLAG_NEED_MESH,
  1207. },
  1208. {
  1209. .cmd = BATADV_CMD_SET_HARDIF,
  1210. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1211. .flags = GENL_UNS_ADMIN_PERM,
  1212. .doit = batadv_netlink_set_hardif,
  1213. .internal_flags = BATADV_FLAG_NEED_MESH |
  1214. BATADV_FLAG_NEED_HARDIF,
  1215. },
  1216. {
  1217. .cmd = BATADV_CMD_GET_VLAN,
  1218. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1219. /* can be retrieved by unprivileged users */
  1220. .doit = batadv_netlink_get_vlan,
  1221. .internal_flags = BATADV_FLAG_NEED_MESH |
  1222. BATADV_FLAG_NEED_VLAN,
  1223. },
  1224. {
  1225. .cmd = BATADV_CMD_SET_VLAN,
  1226. .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
  1227. .flags = GENL_UNS_ADMIN_PERM,
  1228. .doit = batadv_netlink_set_vlan,
  1229. .internal_flags = BATADV_FLAG_NEED_MESH |
  1230. BATADV_FLAG_NEED_VLAN,
  1231. },
  1232. };
  1233. struct genl_family batadv_netlink_family __ro_after_init = {
  1234. .hdrsize = 0,
  1235. .name = BATADV_NL_NAME,
  1236. .version = 1,
  1237. .maxattr = BATADV_ATTR_MAX,
  1238. .policy = batadv_netlink_policy,
  1239. .netnsok = true,
  1240. .pre_doit = batadv_pre_doit,
  1241. .post_doit = batadv_post_doit,
  1242. .module = THIS_MODULE,
  1243. .small_ops = batadv_netlink_ops,
  1244. .n_small_ops = ARRAY_SIZE(batadv_netlink_ops),
  1245. .mcgrps = batadv_netlink_mcgrps,
  1246. .n_mcgrps = ARRAY_SIZE(batadv_netlink_mcgrps),
  1247. };
  1248. /**
  1249. * batadv_netlink_register() - register batadv genl netlink family
  1250. */
  1251. void __init batadv_netlink_register(void)
  1252. {
  1253. int ret;
  1254. ret = genl_register_family(&batadv_netlink_family);
  1255. if (ret)
  1256. pr_warn("unable to register netlink family");
  1257. }
  1258. /**
  1259. * batadv_netlink_unregister() - unregister batadv genl netlink family
  1260. */
  1261. void batadv_netlink_unregister(void)
  1262. {
  1263. genl_unregister_family(&batadv_netlink_family);
  1264. }