ipmr.c 64 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773
  1. /*
  2. * IP multicast routing support for mrouted 3.6/3.8
  3. *
  4. * (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
  5. * Linux Consultancy and Custom Driver Development
  6. *
  7. * This program is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License
  9. * as published by the Free Software Foundation; either version
  10. * 2 of the License, or (at your option) any later version.
  11. *
  12. * Fixes:
  13. * Michael Chastain : Incorrect size of copying.
  14. * Alan Cox : Added the cache manager code
  15. * Alan Cox : Fixed the clone/copy bug and device race.
  16. * Mike McLagan : Routing by source
  17. * Malcolm Beattie : Buffer handling fixes.
  18. * Alexey Kuznetsov : Double buffer free and other fixes.
  19. * SVR Anand : Fixed several multicast bugs and problems.
  20. * Alexey Kuznetsov : Status, optimisations and more.
  21. * Brad Parker : Better behaviour on mrouted upcall
  22. * overflow.
  23. * Carlos Picoto : PIMv1 Support
  24. * Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
  25. * Relax this requirement to work with older peers.
  26. *
  27. */
  28. #include <asm/uaccess.h>
  29. #include <linux/types.h>
  30. #include <linux/capability.h>
  31. #include <linux/errno.h>
  32. #include <linux/timer.h>
  33. #include <linux/mm.h>
  34. #include <linux/kernel.h>
  35. #include <linux/fcntl.h>
  36. #include <linux/stat.h>
  37. #include <linux/socket.h>
  38. #include <linux/in.h>
  39. #include <linux/inet.h>
  40. #include <linux/netdevice.h>
  41. #include <linux/inetdevice.h>
  42. #include <linux/igmp.h>
  43. #include <linux/proc_fs.h>
  44. #include <linux/seq_file.h>
  45. #include <linux/mroute.h>
  46. #include <linux/init.h>
  47. #include <linux/if_ether.h>
  48. #include <linux/slab.h>
  49. #include <net/net_namespace.h>
  50. #include <net/ip.h>
  51. #include <net/protocol.h>
  52. #include <linux/skbuff.h>
  53. #include <net/route.h>
  54. #include <net/sock.h>
  55. #include <net/icmp.h>
  56. #include <net/udp.h>
  57. #include <net/raw.h>
  58. #include <linux/notifier.h>
  59. #include <linux/if_arp.h>
  60. #include <linux/netfilter_ipv4.h>
  61. #include <linux/compat.h>
  62. #include <linux/export.h>
  63. #include <net/ip_tunnels.h>
  64. #include <net/checksum.h>
  65. #include <net/netlink.h>
  66. #include <net/fib_rules.h>
  67. #include <linux/netconf.h>
  68. #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
  69. #define CONFIG_IP_PIMSM 1
  70. #endif
  71. struct mr_table {
  72. struct list_head list;
  73. #ifdef CONFIG_NET_NS
  74. struct net *net;
  75. #endif
  76. u32 id;
  77. struct sock __rcu *mroute_sk;
  78. struct timer_list ipmr_expire_timer;
  79. struct list_head mfc_unres_queue;
  80. struct list_head mfc_cache_array[MFC_LINES];
  81. struct vif_device vif_table[MAXVIFS];
  82. int maxvif;
  83. atomic_t cache_resolve_queue_len;
  84. bool mroute_do_assert;
  85. bool mroute_do_pim;
  86. #if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
  87. int mroute_reg_vif_num;
  88. #endif
  89. };
  90. struct ipmr_rule {
  91. struct fib_rule common;
  92. };
  93. struct ipmr_result {
  94. struct mr_table *mrt;
  95. };
  96. /* Big lock, protecting vif table, mrt cache and mroute socket state.
  97. * Note that the changes are semaphored via rtnl_lock.
  98. */
  99. static DEFINE_RWLOCK(mrt_lock);
  100. /*
  101. * Multicast router control variables
  102. */
  103. #define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
  104. /* Special spinlock for queue of unresolved entries */
  105. static DEFINE_SPINLOCK(mfc_unres_lock);
  106. /* We return to original Alan's scheme. Hash table of resolved
  107. * entries is changed only in process context and protected
  108. * with weak lock mrt_lock. Queue of unresolved entries is protected
  109. * with strong spinlock mfc_unres_lock.
  110. *
  111. * In this case data path is free of exclusive locks at all.
  112. */
  113. static struct kmem_cache *mrt_cachep __read_mostly;
  114. static struct mr_table *ipmr_new_table(struct net *net, u32 id);
  115. static void ipmr_free_table(struct mr_table *mrt);
  116. static void ip_mr_forward(struct net *net, struct mr_table *mrt,
  117. struct sk_buff *skb, struct mfc_cache *cache,
  118. int local);
  119. static int ipmr_cache_report(struct mr_table *mrt,
  120. struct sk_buff *pkt, vifi_t vifi, int assert);
  121. static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
  122. struct mfc_cache *c, struct rtmsg *rtm);
  123. static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
  124. int cmd);
  125. static void mroute_clean_tables(struct mr_table *mrt);
  126. static void ipmr_expire_process(unsigned long arg);
  127. #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
  128. #define ipmr_for_each_table(mrt, net) \
  129. list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
  130. static struct mr_table *ipmr_get_table(struct net *net, u32 id)
  131. {
  132. struct mr_table *mrt;
  133. ipmr_for_each_table(mrt, net) {
  134. if (mrt->id == id)
  135. return mrt;
  136. }
  137. return NULL;
  138. }
  139. static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
  140. struct mr_table **mrt)
  141. {
  142. struct ipmr_result res;
  143. struct fib_lookup_arg arg = { .result = &res, };
  144. int err;
  145. err = fib_rules_lookup(net->ipv4.mr_rules_ops,
  146. flowi4_to_flowi(flp4), 0, &arg);
  147. if (err < 0)
  148. return err;
  149. *mrt = res.mrt;
  150. return 0;
  151. }
  152. static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
  153. int flags, struct fib_lookup_arg *arg)
  154. {
  155. struct ipmr_result *res = arg->result;
  156. struct mr_table *mrt;
  157. switch (rule->action) {
  158. case FR_ACT_TO_TBL:
  159. break;
  160. case FR_ACT_UNREACHABLE:
  161. return -ENETUNREACH;
  162. case FR_ACT_PROHIBIT:
  163. return -EACCES;
  164. case FR_ACT_BLACKHOLE:
  165. default:
  166. return -EINVAL;
  167. }
  168. mrt = ipmr_get_table(rule->fr_net, rule->table);
  169. if (mrt == NULL)
  170. return -EAGAIN;
  171. res->mrt = mrt;
  172. return 0;
  173. }
  174. static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
  175. {
  176. return 1;
  177. }
  178. static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
  179. FRA_GENERIC_POLICY,
  180. };
  181. static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
  182. struct fib_rule_hdr *frh, struct nlattr **tb)
  183. {
  184. return 0;
  185. }
  186. static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
  187. struct nlattr **tb)
  188. {
  189. return 1;
  190. }
  191. static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
  192. struct fib_rule_hdr *frh)
  193. {
  194. frh->dst_len = 0;
  195. frh->src_len = 0;
  196. frh->tos = 0;
  197. return 0;
  198. }
  199. static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
  200. .family = RTNL_FAMILY_IPMR,
  201. .rule_size = sizeof(struct ipmr_rule),
  202. .addr_size = sizeof(u32),
  203. .action = ipmr_rule_action,
  204. .match = ipmr_rule_match,
  205. .configure = ipmr_rule_configure,
  206. .compare = ipmr_rule_compare,
  207. .default_pref = fib_default_rule_pref,
  208. .fill = ipmr_rule_fill,
  209. .nlgroup = RTNLGRP_IPV4_RULE,
  210. .policy = ipmr_rule_policy,
  211. .owner = THIS_MODULE,
  212. };
  213. static int __net_init ipmr_rules_init(struct net *net)
  214. {
  215. struct fib_rules_ops *ops;
  216. struct mr_table *mrt;
  217. int err;
  218. ops = fib_rules_register(&ipmr_rules_ops_template, net);
  219. if (IS_ERR(ops))
  220. return PTR_ERR(ops);
  221. INIT_LIST_HEAD(&net->ipv4.mr_tables);
  222. mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
  223. if (mrt == NULL) {
  224. err = -ENOMEM;
  225. goto err1;
  226. }
  227. err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
  228. if (err < 0)
  229. goto err2;
  230. net->ipv4.mr_rules_ops = ops;
  231. return 0;
  232. err2:
  233. kfree(mrt);
  234. err1:
  235. fib_rules_unregister(ops);
  236. return err;
  237. }
  238. static void __net_exit ipmr_rules_exit(struct net *net)
  239. {
  240. struct mr_table *mrt, *next;
  241. list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
  242. list_del(&mrt->list);
  243. ipmr_free_table(mrt);
  244. }
  245. fib_rules_unregister(net->ipv4.mr_rules_ops);
  246. }
  247. #else
  248. #define ipmr_for_each_table(mrt, net) \
  249. for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
  250. static struct mr_table *ipmr_get_table(struct net *net, u32 id)
  251. {
  252. return net->ipv4.mrt;
  253. }
  254. static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
  255. struct mr_table **mrt)
  256. {
  257. *mrt = net->ipv4.mrt;
  258. return 0;
  259. }
  260. static int __net_init ipmr_rules_init(struct net *net)
  261. {
  262. net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
  263. return net->ipv4.mrt ? 0 : -ENOMEM;
  264. }
  265. static void __net_exit ipmr_rules_exit(struct net *net)
  266. {
  267. ipmr_free_table(net->ipv4.mrt);
  268. }
  269. #endif
  270. static struct mr_table *ipmr_new_table(struct net *net, u32 id)
  271. {
  272. struct mr_table *mrt;
  273. unsigned int i;
  274. mrt = ipmr_get_table(net, id);
  275. if (mrt != NULL)
  276. return mrt;
  277. mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
  278. if (mrt == NULL)
  279. return NULL;
  280. write_pnet(&mrt->net, net);
  281. mrt->id = id;
  282. /* Forwarding cache */
  283. for (i = 0; i < MFC_LINES; i++)
  284. INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);
  285. INIT_LIST_HEAD(&mrt->mfc_unres_queue);
  286. setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
  287. (unsigned long)mrt);
  288. #ifdef CONFIG_IP_PIMSM
  289. mrt->mroute_reg_vif_num = -1;
  290. #endif
  291. #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
  292. list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
  293. #endif
  294. return mrt;
  295. }
  296. static void ipmr_free_table(struct mr_table *mrt)
  297. {
  298. del_timer_sync(&mrt->ipmr_expire_timer);
  299. mroute_clean_tables(mrt);
  300. kfree(mrt);
  301. }
  302. /* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
  303. static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
  304. {
  305. struct net *net = dev_net(dev);
  306. dev_close(dev);
  307. dev = __dev_get_by_name(net, "tunl0");
  308. if (dev) {
  309. const struct net_device_ops *ops = dev->netdev_ops;
  310. struct ifreq ifr;
  311. struct ip_tunnel_parm p;
  312. memset(&p, 0, sizeof(p));
  313. p.iph.daddr = v->vifc_rmt_addr.s_addr;
  314. p.iph.saddr = v->vifc_lcl_addr.s_addr;
  315. p.iph.version = 4;
  316. p.iph.ihl = 5;
  317. p.iph.protocol = IPPROTO_IPIP;
  318. sprintf(p.name, "dvmrp%d", v->vifc_vifi);
  319. ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
  320. if (ops->ndo_do_ioctl) {
  321. mm_segment_t oldfs = get_fs();
  322. set_fs(KERNEL_DS);
  323. ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
  324. set_fs(oldfs);
  325. }
  326. }
  327. }
  328. static
  329. struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
  330. {
  331. struct net_device *dev;
  332. dev = __dev_get_by_name(net, "tunl0");
  333. if (dev) {
  334. const struct net_device_ops *ops = dev->netdev_ops;
  335. int err;
  336. struct ifreq ifr;
  337. struct ip_tunnel_parm p;
  338. struct in_device *in_dev;
  339. memset(&p, 0, sizeof(p));
  340. p.iph.daddr = v->vifc_rmt_addr.s_addr;
  341. p.iph.saddr = v->vifc_lcl_addr.s_addr;
  342. p.iph.version = 4;
  343. p.iph.ihl = 5;
  344. p.iph.protocol = IPPROTO_IPIP;
  345. sprintf(p.name, "dvmrp%d", v->vifc_vifi);
  346. ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
  347. if (ops->ndo_do_ioctl) {
  348. mm_segment_t oldfs = get_fs();
  349. set_fs(KERNEL_DS);
  350. err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
  351. set_fs(oldfs);
  352. } else {
  353. err = -EOPNOTSUPP;
  354. }
  355. dev = NULL;
  356. if (err == 0 &&
  357. (dev = __dev_get_by_name(net, p.name)) != NULL) {
  358. dev->flags |= IFF_MULTICAST;
  359. in_dev = __in_dev_get_rtnl(dev);
  360. if (in_dev == NULL)
  361. goto failure;
  362. ipv4_devconf_setall(in_dev);
  363. IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
  364. if (dev_open(dev))
  365. goto failure;
  366. dev_hold(dev);
  367. }
  368. }
  369. return dev;
  370. failure:
  371. /* allow the register to be completed before unregistering. */
  372. rtnl_unlock();
  373. rtnl_lock();
  374. unregister_netdevice(dev);
  375. return NULL;
  376. }
  377. #ifdef CONFIG_IP_PIMSM
  378. static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
  379. {
  380. struct net *net = dev_net(dev);
  381. struct mr_table *mrt;
  382. struct flowi4 fl4 = {
  383. .flowi4_oif = dev->ifindex,
  384. .flowi4_iif = skb->skb_iif,
  385. .flowi4_mark = skb->mark,
  386. };
  387. int err;
  388. err = ipmr_fib_lookup(net, &fl4, &mrt);
  389. if (err < 0) {
  390. kfree_skb(skb);
  391. return err;
  392. }
  393. read_lock(&mrt_lock);
  394. dev->stats.tx_bytes += skb->len;
  395. dev->stats.tx_packets++;
  396. ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
  397. read_unlock(&mrt_lock);
  398. kfree_skb(skb);
  399. return NETDEV_TX_OK;
  400. }
  401. static const struct net_device_ops reg_vif_netdev_ops = {
  402. .ndo_start_xmit = reg_vif_xmit,
  403. };
  404. static void reg_vif_setup(struct net_device *dev)
  405. {
  406. dev->type = ARPHRD_PIMREG;
  407. dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
  408. dev->flags = IFF_NOARP;
  409. dev->netdev_ops = &reg_vif_netdev_ops,
  410. dev->destructor = free_netdev;
  411. dev->features |= NETIF_F_NETNS_LOCAL;
  412. }
  413. static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
  414. {
  415. struct net_device *dev;
  416. struct in_device *in_dev;
  417. char name[IFNAMSIZ];
  418. if (mrt->id == RT_TABLE_DEFAULT)
  419. sprintf(name, "pimreg");
  420. else
  421. sprintf(name, "pimreg%u", mrt->id);
  422. dev = alloc_netdev(0, name, reg_vif_setup);
  423. if (dev == NULL)
  424. return NULL;
  425. dev_net_set(dev, net);
  426. if (register_netdevice(dev)) {
  427. free_netdev(dev);
  428. return NULL;
  429. }
  430. dev->iflink = 0;
  431. rcu_read_lock();
  432. in_dev = __in_dev_get_rcu(dev);
  433. if (!in_dev) {
  434. rcu_read_unlock();
  435. goto failure;
  436. }
  437. ipv4_devconf_setall(in_dev);
  438. IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
  439. rcu_read_unlock();
  440. if (dev_open(dev))
  441. goto failure;
  442. dev_hold(dev);
  443. return dev;
  444. failure:
  445. /* allow the register to be completed before unregistering. */
  446. rtnl_unlock();
  447. rtnl_lock();
  448. unregister_netdevice(dev);
  449. return NULL;
  450. }
  451. #endif
  452. /**
  453. * vif_delete - Delete a VIF entry
  454. * @notify: Set to 1, if the caller is a notifier_call
  455. */
  456. static int vif_delete(struct mr_table *mrt, int vifi, int notify,
  457. struct list_head *head)
  458. {
  459. struct vif_device *v;
  460. struct net_device *dev;
  461. struct in_device *in_dev;
  462. if (vifi < 0 || vifi >= mrt->maxvif)
  463. return -EADDRNOTAVAIL;
  464. v = &mrt->vif_table[vifi];
  465. write_lock_bh(&mrt_lock);
  466. dev = v->dev;
  467. v->dev = NULL;
  468. if (!dev) {
  469. write_unlock_bh(&mrt_lock);
  470. return -EADDRNOTAVAIL;
  471. }
  472. #ifdef CONFIG_IP_PIMSM
  473. if (vifi == mrt->mroute_reg_vif_num)
  474. mrt->mroute_reg_vif_num = -1;
  475. #endif
  476. if (vifi + 1 == mrt->maxvif) {
  477. int tmp;
  478. for (tmp = vifi - 1; tmp >= 0; tmp--) {
  479. if (VIF_EXISTS(mrt, tmp))
  480. break;
  481. }
  482. mrt->maxvif = tmp+1;
  483. }
  484. write_unlock_bh(&mrt_lock);
  485. dev_set_allmulti(dev, -1);
  486. in_dev = __in_dev_get_rtnl(dev);
  487. if (in_dev) {
  488. IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
  489. inet_netconf_notify_devconf(dev_net(dev),
  490. NETCONFA_MC_FORWARDING,
  491. dev->ifindex, &in_dev->cnf);
  492. ip_rt_multicast_event(in_dev);
  493. }
  494. if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
  495. unregister_netdevice_queue(dev, head);
  496. dev_put(dev);
  497. return 0;
  498. }
  499. static void ipmr_cache_free_rcu(struct rcu_head *head)
  500. {
  501. struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);
  502. kmem_cache_free(mrt_cachep, c);
  503. }
  504. static inline void ipmr_cache_free(struct mfc_cache *c)
  505. {
  506. call_rcu(&c->rcu, ipmr_cache_free_rcu);
  507. }
  508. /* Destroy an unresolved cache entry, killing queued skbs
  509. * and reporting error to netlink readers.
  510. */
  511. static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
  512. {
  513. struct net *net = read_pnet(&mrt->net);
  514. struct sk_buff *skb;
  515. struct nlmsgerr *e;
  516. atomic_dec(&mrt->cache_resolve_queue_len);
  517. while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
  518. if (ip_hdr(skb)->version == 0) {
  519. struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
  520. nlh->nlmsg_type = NLMSG_ERROR;
  521. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
  522. skb_trim(skb, nlh->nlmsg_len);
  523. e = nlmsg_data(nlh);
  524. e->error = -ETIMEDOUT;
  525. memset(&e->msg, 0, sizeof(e->msg));
  526. rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
  527. } else {
  528. kfree_skb(skb);
  529. }
  530. }
  531. ipmr_cache_free(c);
  532. }
  533. /* Timer process for the unresolved queue. */
  534. static void ipmr_expire_process(unsigned long arg)
  535. {
  536. struct mr_table *mrt = (struct mr_table *)arg;
  537. unsigned long now;
  538. unsigned long expires;
  539. struct mfc_cache *c, *next;
  540. if (!spin_trylock(&mfc_unres_lock)) {
  541. mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
  542. return;
  543. }
  544. if (list_empty(&mrt->mfc_unres_queue))
  545. goto out;
  546. now = jiffies;
  547. expires = 10*HZ;
  548. list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
  549. if (time_after(c->mfc_un.unres.expires, now)) {
  550. unsigned long interval = c->mfc_un.unres.expires - now;
  551. if (interval < expires)
  552. expires = interval;
  553. continue;
  554. }
  555. list_del(&c->list);
  556. mroute_netlink_event(mrt, c, RTM_DELROUTE);
  557. ipmr_destroy_unres(mrt, c);
  558. }
  559. if (!list_empty(&mrt->mfc_unres_queue))
  560. mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
  561. out:
  562. spin_unlock(&mfc_unres_lock);
  563. }
  564. /* Fill oifs list. It is called under write locked mrt_lock. */
  565. static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
  566. unsigned char *ttls)
  567. {
  568. int vifi;
  569. cache->mfc_un.res.minvif = MAXVIFS;
  570. cache->mfc_un.res.maxvif = 0;
  571. memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
  572. for (vifi = 0; vifi < mrt->maxvif; vifi++) {
  573. if (VIF_EXISTS(mrt, vifi) &&
  574. ttls[vifi] && ttls[vifi] < 255) {
  575. cache->mfc_un.res.ttls[vifi] = ttls[vifi];
  576. if (cache->mfc_un.res.minvif > vifi)
  577. cache->mfc_un.res.minvif = vifi;
  578. if (cache->mfc_un.res.maxvif <= vifi)
  579. cache->mfc_un.res.maxvif = vifi + 1;
  580. }
  581. }
  582. }
  583. static int vif_add(struct net *net, struct mr_table *mrt,
  584. struct vifctl *vifc, int mrtsock)
  585. {
  586. int vifi = vifc->vifc_vifi;
  587. struct vif_device *v = &mrt->vif_table[vifi];
  588. struct net_device *dev;
  589. struct in_device *in_dev;
  590. int err;
  591. /* Is vif busy ? */
  592. if (VIF_EXISTS(mrt, vifi))
  593. return -EADDRINUSE;
  594. switch (vifc->vifc_flags) {
  595. #ifdef CONFIG_IP_PIMSM
  596. case VIFF_REGISTER:
  597. /*
  598. * Special Purpose VIF in PIM
  599. * All the packets will be sent to the daemon
  600. */
  601. if (mrt->mroute_reg_vif_num >= 0)
  602. return -EADDRINUSE;
  603. dev = ipmr_reg_vif(net, mrt);
  604. if (!dev)
  605. return -ENOBUFS;
  606. err = dev_set_allmulti(dev, 1);
  607. if (err) {
  608. unregister_netdevice(dev);
  609. dev_put(dev);
  610. return err;
  611. }
  612. break;
  613. #endif
  614. case VIFF_TUNNEL:
  615. dev = ipmr_new_tunnel(net, vifc);
  616. if (!dev)
  617. return -ENOBUFS;
  618. err = dev_set_allmulti(dev, 1);
  619. if (err) {
  620. ipmr_del_tunnel(dev, vifc);
  621. dev_put(dev);
  622. return err;
  623. }
  624. break;
  625. case VIFF_USE_IFINDEX:
  626. case 0:
  627. if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
  628. dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
  629. if (dev && __in_dev_get_rtnl(dev) == NULL) {
  630. dev_put(dev);
  631. return -EADDRNOTAVAIL;
  632. }
  633. } else {
  634. dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
  635. }
  636. if (!dev)
  637. return -EADDRNOTAVAIL;
  638. err = dev_set_allmulti(dev, 1);
  639. if (err) {
  640. dev_put(dev);
  641. return err;
  642. }
  643. break;
  644. default:
  645. return -EINVAL;
  646. }
  647. in_dev = __in_dev_get_rtnl(dev);
  648. if (!in_dev) {
  649. dev_put(dev);
  650. return -EADDRNOTAVAIL;
  651. }
  652. IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
  653. inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING, dev->ifindex,
  654. &in_dev->cnf);
  655. ip_rt_multicast_event(in_dev);
  656. /* Fill in the VIF structures */
  657. v->rate_limit = vifc->vifc_rate_limit;
  658. v->local = vifc->vifc_lcl_addr.s_addr;
  659. v->remote = vifc->vifc_rmt_addr.s_addr;
  660. v->flags = vifc->vifc_flags;
  661. if (!mrtsock)
  662. v->flags |= VIFF_STATIC;
  663. v->threshold = vifc->vifc_threshold;
  664. v->bytes_in = 0;
  665. v->bytes_out = 0;
  666. v->pkt_in = 0;
  667. v->pkt_out = 0;
  668. v->link = dev->ifindex;
  669. if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
  670. v->link = dev->iflink;
  671. /* And finish update writing critical data */
  672. write_lock_bh(&mrt_lock);
  673. v->dev = dev;
  674. #ifdef CONFIG_IP_PIMSM
  675. if (v->flags & VIFF_REGISTER)
  676. mrt->mroute_reg_vif_num = vifi;
  677. #endif
  678. if (vifi+1 > mrt->maxvif)
  679. mrt->maxvif = vifi+1;
  680. write_unlock_bh(&mrt_lock);
  681. return 0;
  682. }
  683. /* called with rcu_read_lock() */
  684. static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
  685. __be32 origin,
  686. __be32 mcastgrp)
  687. {
  688. int line = MFC_HASH(mcastgrp, origin);
  689. struct mfc_cache *c;
  690. list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list) {
  691. if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
  692. return c;
  693. }
  694. return NULL;
  695. }
  696. /* Look for a (*,*,oif) entry */
  697. static struct mfc_cache *ipmr_cache_find_any_parent(struct mr_table *mrt,
  698. int vifi)
  699. {
  700. int line = MFC_HASH(htonl(INADDR_ANY), htonl(INADDR_ANY));
  701. struct mfc_cache *c;
  702. list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list)
  703. if (c->mfc_origin == htonl(INADDR_ANY) &&
  704. c->mfc_mcastgrp == htonl(INADDR_ANY) &&
  705. c->mfc_un.res.ttls[vifi] < 255)
  706. return c;
  707. return NULL;
  708. }
  709. /* Look for a (*,G) entry */
  710. static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
  711. __be32 mcastgrp, int vifi)
  712. {
  713. int line = MFC_HASH(mcastgrp, htonl(INADDR_ANY));
  714. struct mfc_cache *c, *proxy;
  715. if (mcastgrp == htonl(INADDR_ANY))
  716. goto skip;
  717. list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list)
  718. if (c->mfc_origin == htonl(INADDR_ANY) &&
  719. c->mfc_mcastgrp == mcastgrp) {
  720. if (c->mfc_un.res.ttls[vifi] < 255)
  721. return c;
  722. /* It's ok if the vifi is part of the static tree */
  723. proxy = ipmr_cache_find_any_parent(mrt,
  724. c->mfc_parent);
  725. if (proxy && proxy->mfc_un.res.ttls[vifi] < 255)
  726. return c;
  727. }
  728. skip:
  729. return ipmr_cache_find_any_parent(mrt, vifi);
  730. }
  731. /*
  732. * Allocate a multicast cache entry
  733. */
  734. static struct mfc_cache *ipmr_cache_alloc(void)
  735. {
  736. struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
  737. if (c)
  738. c->mfc_un.res.minvif = MAXVIFS;
  739. return c;
  740. }
  741. static struct mfc_cache *ipmr_cache_alloc_unres(void)
  742. {
  743. struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
  744. if (c) {
  745. skb_queue_head_init(&c->mfc_un.unres.unresolved);
  746. c->mfc_un.unres.expires = jiffies + 10*HZ;
  747. }
  748. return c;
  749. }
  750. /*
  751. * A cache entry has gone into a resolved state from queued
  752. */
  753. static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
  754. struct mfc_cache *uc, struct mfc_cache *c)
  755. {
  756. struct sk_buff *skb;
  757. struct nlmsgerr *e;
  758. /* Play the pending entries through our router */
  759. while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
  760. if (ip_hdr(skb)->version == 0) {
  761. struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
  762. if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) {
  763. nlh->nlmsg_len = skb_tail_pointer(skb) -
  764. (u8 *)nlh;
  765. } else {
  766. nlh->nlmsg_type = NLMSG_ERROR;
  767. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
  768. skb_trim(skb, nlh->nlmsg_len);
  769. e = nlmsg_data(nlh);
  770. e->error = -EMSGSIZE;
  771. memset(&e->msg, 0, sizeof(e->msg));
  772. }
  773. rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
  774. } else {
  775. ip_mr_forward(net, mrt, skb, c, 0);
  776. }
  777. }
  778. }
  779. /*
  780. * Bounce a cache query up to mrouted. We could use netlink for this but mrouted
  781. * expects the following bizarre scheme.
  782. *
  783. * Called under mrt_lock.
  784. */
  785. static int ipmr_cache_report(struct mr_table *mrt,
  786. struct sk_buff *pkt, vifi_t vifi, int assert)
  787. {
  788. struct sk_buff *skb;
  789. const int ihl = ip_hdrlen(pkt);
  790. struct igmphdr *igmp;
  791. struct igmpmsg *msg;
  792. struct sock *mroute_sk;
  793. int ret;
  794. #ifdef CONFIG_IP_PIMSM
  795. if (assert == IGMPMSG_WHOLEPKT)
  796. skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
  797. else
  798. #endif
  799. skb = alloc_skb(128, GFP_ATOMIC);
  800. if (!skb)
  801. return -ENOBUFS;
  802. #ifdef CONFIG_IP_PIMSM
  803. if (assert == IGMPMSG_WHOLEPKT) {
  804. /* Ugly, but we have no choice with this interface.
  805. * Duplicate old header, fix ihl, length etc.
  806. * And all this only to mangle msg->im_msgtype and
  807. * to set msg->im_mbz to "mbz" :-)
  808. */
  809. skb_push(skb, sizeof(struct iphdr));
  810. skb_reset_network_header(skb);
  811. skb_reset_transport_header(skb);
  812. msg = (struct igmpmsg *)skb_network_header(skb);
  813. memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
  814. msg->im_msgtype = IGMPMSG_WHOLEPKT;
  815. msg->im_mbz = 0;
  816. msg->im_vif = mrt->mroute_reg_vif_num;
  817. ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
  818. ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
  819. sizeof(struct iphdr));
  820. } else
  821. #endif
  822. {
  823. /* Copy the IP header */
  824. skb_set_network_header(skb, skb->len);
  825. skb_put(skb, ihl);
  826. skb_copy_to_linear_data(skb, pkt->data, ihl);
  827. ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
  828. msg = (struct igmpmsg *)skb_network_header(skb);
  829. msg->im_vif = vifi;
  830. skb_dst_set(skb, dst_clone(skb_dst(pkt)));
  831. /* Add our header */
  832. igmp = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
  833. igmp->type =
  834. msg->im_msgtype = assert;
  835. igmp->code = 0;
  836. ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
  837. skb->transport_header = skb->network_header;
  838. }
  839. rcu_read_lock();
  840. mroute_sk = rcu_dereference(mrt->mroute_sk);
  841. if (mroute_sk == NULL) {
  842. rcu_read_unlock();
  843. kfree_skb(skb);
  844. return -EINVAL;
  845. }
  846. /* Deliver to mrouted */
  847. ret = sock_queue_rcv_skb(mroute_sk, skb);
  848. rcu_read_unlock();
  849. if (ret < 0) {
  850. net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
  851. kfree_skb(skb);
  852. }
  853. return ret;
  854. }
  855. /*
  856. * Queue a packet for resolution. It gets locked cache entry!
  857. */
  858. static int
  859. ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
  860. {
  861. bool found = false;
  862. int err;
  863. struct mfc_cache *c;
  864. const struct iphdr *iph = ip_hdr(skb);
  865. spin_lock_bh(&mfc_unres_lock);
  866. list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
  867. if (c->mfc_mcastgrp == iph->daddr &&
  868. c->mfc_origin == iph->saddr) {
  869. found = true;
  870. break;
  871. }
  872. }
  873. if (!found) {
  874. /* Create a new entry if allowable */
  875. if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
  876. (c = ipmr_cache_alloc_unres()) == NULL) {
  877. spin_unlock_bh(&mfc_unres_lock);
  878. kfree_skb(skb);
  879. return -ENOBUFS;
  880. }
  881. /* Fill in the new cache entry */
  882. c->mfc_parent = -1;
  883. c->mfc_origin = iph->saddr;
  884. c->mfc_mcastgrp = iph->daddr;
  885. /* Reflect first query at mrouted. */
  886. err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
  887. if (err < 0) {
  888. /* If the report failed throw the cache entry
  889. out - Brad Parker
  890. */
  891. spin_unlock_bh(&mfc_unres_lock);
  892. ipmr_cache_free(c);
  893. kfree_skb(skb);
  894. return err;
  895. }
  896. atomic_inc(&mrt->cache_resolve_queue_len);
  897. list_add(&c->list, &mrt->mfc_unres_queue);
  898. mroute_netlink_event(mrt, c, RTM_NEWROUTE);
  899. if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
  900. mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
  901. }
  902. /* See if we can append the packet */
  903. if (c->mfc_un.unres.unresolved.qlen > 3) {
  904. kfree_skb(skb);
  905. err = -ENOBUFS;
  906. } else {
  907. skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
  908. err = 0;
  909. }
  910. spin_unlock_bh(&mfc_unres_lock);
  911. return err;
  912. }
  913. /*
  914. * MFC cache manipulation by user space mroute daemon
  915. */
  916. static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
  917. {
  918. int line;
  919. struct mfc_cache *c, *next;
  920. line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
  921. list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
  922. if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
  923. c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr &&
  924. (parent == -1 || parent == c->mfc_parent)) {
  925. list_del_rcu(&c->list);
  926. mroute_netlink_event(mrt, c, RTM_DELROUTE);
  927. ipmr_cache_free(c);
  928. return 0;
  929. }
  930. }
  931. return -ENOENT;
  932. }
  933. static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
  934. struct mfcctl *mfc, int mrtsock, int parent)
  935. {
  936. bool found = false;
  937. int line;
  938. struct mfc_cache *uc, *c;
  939. if (mfc->mfcc_parent >= MAXVIFS)
  940. return -ENFILE;
  941. line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
  942. list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
  943. if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
  944. c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr &&
  945. (parent == -1 || parent == c->mfc_parent)) {
  946. found = true;
  947. break;
  948. }
  949. }
  950. if (found) {
  951. write_lock_bh(&mrt_lock);
  952. c->mfc_parent = mfc->mfcc_parent;
  953. ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
  954. if (!mrtsock)
  955. c->mfc_flags |= MFC_STATIC;
  956. write_unlock_bh(&mrt_lock);
  957. mroute_netlink_event(mrt, c, RTM_NEWROUTE);
  958. return 0;
  959. }
  960. if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
  961. !ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
  962. return -EINVAL;
  963. c = ipmr_cache_alloc();
  964. if (c == NULL)
  965. return -ENOMEM;
  966. c->mfc_origin = mfc->mfcc_origin.s_addr;
  967. c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
  968. c->mfc_parent = mfc->mfcc_parent;
  969. ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
  970. if (!mrtsock)
  971. c->mfc_flags |= MFC_STATIC;
  972. list_add_rcu(&c->list, &mrt->mfc_cache_array[line]);
  973. /*
  974. * Check to see if we resolved a queued list. If so we
  975. * need to send on the frames and tidy up.
  976. */
  977. found = false;
  978. spin_lock_bh(&mfc_unres_lock);
  979. list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
  980. if (uc->mfc_origin == c->mfc_origin &&
  981. uc->mfc_mcastgrp == c->mfc_mcastgrp) {
  982. list_del(&uc->list);
  983. atomic_dec(&mrt->cache_resolve_queue_len);
  984. found = true;
  985. break;
  986. }
  987. }
  988. if (list_empty(&mrt->mfc_unres_queue))
  989. del_timer(&mrt->ipmr_expire_timer);
  990. spin_unlock_bh(&mfc_unres_lock);
  991. if (found) {
  992. ipmr_cache_resolve(net, mrt, uc, c);
  993. ipmr_cache_free(uc);
  994. }
  995. mroute_netlink_event(mrt, c, RTM_NEWROUTE);
  996. return 0;
  997. }
  998. /*
  999. * Close the multicast socket, and clear the vif tables etc
  1000. */
  1001. static void mroute_clean_tables(struct mr_table *mrt)
  1002. {
  1003. int i;
  1004. LIST_HEAD(list);
  1005. struct mfc_cache *c, *next;
  1006. /* Shut down all active vif entries */
  1007. for (i = 0; i < mrt->maxvif; i++) {
  1008. if (!(mrt->vif_table[i].flags & VIFF_STATIC))
  1009. vif_delete(mrt, i, 0, &list);
  1010. }
  1011. unregister_netdevice_many(&list);
  1012. /* Wipe the cache */
  1013. for (i = 0; i < MFC_LINES; i++) {
  1014. list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
  1015. if (c->mfc_flags & MFC_STATIC)
  1016. continue;
  1017. list_del_rcu(&c->list);
  1018. mroute_netlink_event(mrt, c, RTM_DELROUTE);
  1019. ipmr_cache_free(c);
  1020. }
  1021. }
  1022. if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
  1023. spin_lock_bh(&mfc_unres_lock);
  1024. list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
  1025. list_del(&c->list);
  1026. mroute_netlink_event(mrt, c, RTM_DELROUTE);
  1027. ipmr_destroy_unres(mrt, c);
  1028. }
  1029. spin_unlock_bh(&mfc_unres_lock);
  1030. }
  1031. }
  1032. /* called from ip_ra_control(), before an RCU grace period,
  1033. * we dont need to call synchronize_rcu() here
  1034. */
  1035. static void mrtsock_destruct(struct sock *sk)
  1036. {
  1037. struct net *net = sock_net(sk);
  1038. struct mr_table *mrt;
  1039. rtnl_lock();
  1040. ipmr_for_each_table(mrt, net) {
  1041. if (sk == rtnl_dereference(mrt->mroute_sk)) {
  1042. IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
  1043. inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
  1044. NETCONFA_IFINDEX_ALL,
  1045. net->ipv4.devconf_all);
  1046. RCU_INIT_POINTER(mrt->mroute_sk, NULL);
  1047. mroute_clean_tables(mrt);
  1048. }
  1049. }
  1050. rtnl_unlock();
  1051. }
  1052. /*
  1053. * Socket options and virtual interface manipulation. The whole
  1054. * virtual interface system is a complete heap, but unfortunately
  1055. * that's how BSD mrouted happens to think. Maybe one day with a proper
  1056. * MOSPF/PIM router set up we can clean this up.
  1057. */
  1058. int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
  1059. {
  1060. int ret, parent = 0;
  1061. struct vifctl vif;
  1062. struct mfcctl mfc;
  1063. struct net *net = sock_net(sk);
  1064. struct mr_table *mrt;
  1065. if (sk->sk_type != SOCK_RAW ||
  1066. inet_sk(sk)->inet_num != IPPROTO_IGMP)
  1067. return -EOPNOTSUPP;
  1068. mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
  1069. if (mrt == NULL)
  1070. return -ENOENT;
  1071. if (optname != MRT_INIT) {
  1072. if (sk != rcu_access_pointer(mrt->mroute_sk) &&
  1073. !ns_capable(net->user_ns, CAP_NET_ADMIN))
  1074. return -EACCES;
  1075. }
  1076. switch (optname) {
  1077. case MRT_INIT:
  1078. if (optlen != sizeof(int))
  1079. return -EINVAL;
  1080. rtnl_lock();
  1081. if (rtnl_dereference(mrt->mroute_sk)) {
  1082. rtnl_unlock();
  1083. return -EADDRINUSE;
  1084. }
  1085. ret = ip_ra_control(sk, 1, mrtsock_destruct);
  1086. if (ret == 0) {
  1087. rcu_assign_pointer(mrt->mroute_sk, sk);
  1088. IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
  1089. inet_netconf_notify_devconf(net, NETCONFA_MC_FORWARDING,
  1090. NETCONFA_IFINDEX_ALL,
  1091. net->ipv4.devconf_all);
  1092. }
  1093. rtnl_unlock();
  1094. return ret;
  1095. case MRT_DONE:
  1096. if (sk != rcu_access_pointer(mrt->mroute_sk))
  1097. return -EACCES;
  1098. return ip_ra_control(sk, 0, NULL);
  1099. case MRT_ADD_VIF:
  1100. case MRT_DEL_VIF:
  1101. if (optlen != sizeof(vif))
  1102. return -EINVAL;
  1103. if (copy_from_user(&vif, optval, sizeof(vif)))
  1104. return -EFAULT;
  1105. if (vif.vifc_vifi >= MAXVIFS)
  1106. return -ENFILE;
  1107. rtnl_lock();
  1108. if (optname == MRT_ADD_VIF) {
  1109. ret = vif_add(net, mrt, &vif,
  1110. sk == rtnl_dereference(mrt->mroute_sk));
  1111. } else {
  1112. ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
  1113. }
  1114. rtnl_unlock();
  1115. return ret;
  1116. /*
  1117. * Manipulate the forwarding caches. These live
  1118. * in a sort of kernel/user symbiosis.
  1119. */
  1120. case MRT_ADD_MFC:
  1121. case MRT_DEL_MFC:
  1122. parent = -1;
  1123. case MRT_ADD_MFC_PROXY:
  1124. case MRT_DEL_MFC_PROXY:
  1125. if (optlen != sizeof(mfc))
  1126. return -EINVAL;
  1127. if (copy_from_user(&mfc, optval, sizeof(mfc)))
  1128. return -EFAULT;
  1129. if (parent == 0)
  1130. parent = mfc.mfcc_parent;
  1131. rtnl_lock();
  1132. if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
  1133. ret = ipmr_mfc_delete(mrt, &mfc, parent);
  1134. else
  1135. ret = ipmr_mfc_add(net, mrt, &mfc,
  1136. sk == rtnl_dereference(mrt->mroute_sk),
  1137. parent);
  1138. rtnl_unlock();
  1139. return ret;
  1140. /*
  1141. * Control PIM assert.
  1142. */
  1143. case MRT_ASSERT:
  1144. {
  1145. int v;
  1146. if (optlen != sizeof(v))
  1147. return -EINVAL;
  1148. if (get_user(v, (int __user *)optval))
  1149. return -EFAULT;
  1150. mrt->mroute_do_assert = v;
  1151. return 0;
  1152. }
  1153. #ifdef CONFIG_IP_PIMSM
  1154. case MRT_PIM:
  1155. {
  1156. int v;
  1157. if (optlen != sizeof(v))
  1158. return -EINVAL;
  1159. if (get_user(v, (int __user *)optval))
  1160. return -EFAULT;
  1161. v = !!v;
  1162. rtnl_lock();
  1163. ret = 0;
  1164. if (v != mrt->mroute_do_pim) {
  1165. mrt->mroute_do_pim = v;
  1166. mrt->mroute_do_assert = v;
  1167. }
  1168. rtnl_unlock();
  1169. return ret;
  1170. }
  1171. #endif
  1172. #ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
  1173. case MRT_TABLE:
  1174. {
  1175. u32 v;
  1176. if (optlen != sizeof(u32))
  1177. return -EINVAL;
  1178. if (get_user(v, (u32 __user *)optval))
  1179. return -EFAULT;
  1180. /* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
  1181. if (v != RT_TABLE_DEFAULT && v >= 1000000000)
  1182. return -EINVAL;
  1183. rtnl_lock();
  1184. ret = 0;
  1185. if (sk == rtnl_dereference(mrt->mroute_sk)) {
  1186. ret = -EBUSY;
  1187. } else {
  1188. if (!ipmr_new_table(net, v))
  1189. ret = -ENOMEM;
  1190. else
  1191. raw_sk(sk)->ipmr_table = v;
  1192. }
  1193. rtnl_unlock();
  1194. return ret;
  1195. }
  1196. #endif
  1197. /*
  1198. * Spurious command, or MRT_VERSION which you cannot
  1199. * set.
  1200. */
  1201. default:
  1202. return -ENOPROTOOPT;
  1203. }
  1204. }
  1205. /*
  1206. * Getsock opt support for the multicast routing system.
  1207. */
  1208. int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
  1209. {
  1210. int olr;
  1211. int val;
  1212. struct net *net = sock_net(sk);
  1213. struct mr_table *mrt;
  1214. if (sk->sk_type != SOCK_RAW ||
  1215. inet_sk(sk)->inet_num != IPPROTO_IGMP)
  1216. return -EOPNOTSUPP;
  1217. mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
  1218. if (mrt == NULL)
  1219. return -ENOENT;
  1220. if (optname != MRT_VERSION &&
  1221. #ifdef CONFIG_IP_PIMSM
  1222. optname != MRT_PIM &&
  1223. #endif
  1224. optname != MRT_ASSERT)
  1225. return -ENOPROTOOPT;
  1226. if (get_user(olr, optlen))
  1227. return -EFAULT;
  1228. olr = min_t(unsigned int, olr, sizeof(int));
  1229. if (olr < 0)
  1230. return -EINVAL;
  1231. if (put_user(olr, optlen))
  1232. return -EFAULT;
  1233. if (optname == MRT_VERSION)
  1234. val = 0x0305;
  1235. #ifdef CONFIG_IP_PIMSM
  1236. else if (optname == MRT_PIM)
  1237. val = mrt->mroute_do_pim;
  1238. #endif
  1239. else
  1240. val = mrt->mroute_do_assert;
  1241. if (copy_to_user(optval, &val, olr))
  1242. return -EFAULT;
  1243. return 0;
  1244. }
  1245. /*
  1246. * The IP multicast ioctl support routines.
  1247. */
  1248. int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
  1249. {
  1250. struct sioc_sg_req sr;
  1251. struct sioc_vif_req vr;
  1252. struct vif_device *vif;
  1253. struct mfc_cache *c;
  1254. struct net *net = sock_net(sk);
  1255. struct mr_table *mrt;
  1256. mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
  1257. if (mrt == NULL)
  1258. return -ENOENT;
  1259. switch (cmd) {
  1260. case SIOCGETVIFCNT:
  1261. if (copy_from_user(&vr, arg, sizeof(vr)))
  1262. return -EFAULT;
  1263. if (vr.vifi >= mrt->maxvif)
  1264. return -EINVAL;
  1265. read_lock(&mrt_lock);
  1266. vif = &mrt->vif_table[vr.vifi];
  1267. if (VIF_EXISTS(mrt, vr.vifi)) {
  1268. vr.icount = vif->pkt_in;
  1269. vr.ocount = vif->pkt_out;
  1270. vr.ibytes = vif->bytes_in;
  1271. vr.obytes = vif->bytes_out;
  1272. read_unlock(&mrt_lock);
  1273. if (copy_to_user(arg, &vr, sizeof(vr)))
  1274. return -EFAULT;
  1275. return 0;
  1276. }
  1277. read_unlock(&mrt_lock);
  1278. return -EADDRNOTAVAIL;
  1279. case SIOCGETSGCNT:
  1280. if (copy_from_user(&sr, arg, sizeof(sr)))
  1281. return -EFAULT;
  1282. rcu_read_lock();
  1283. c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
  1284. if (c) {
  1285. sr.pktcnt = c->mfc_un.res.pkt;
  1286. sr.bytecnt = c->mfc_un.res.bytes;
  1287. sr.wrong_if = c->mfc_un.res.wrong_if;
  1288. rcu_read_unlock();
  1289. if (copy_to_user(arg, &sr, sizeof(sr)))
  1290. return -EFAULT;
  1291. return 0;
  1292. }
  1293. rcu_read_unlock();
  1294. return -EADDRNOTAVAIL;
  1295. default:
  1296. return -ENOIOCTLCMD;
  1297. }
  1298. }
  1299. #ifdef CONFIG_COMPAT
  1300. struct compat_sioc_sg_req {
  1301. struct in_addr src;
  1302. struct in_addr grp;
  1303. compat_ulong_t pktcnt;
  1304. compat_ulong_t bytecnt;
  1305. compat_ulong_t wrong_if;
  1306. };
  1307. struct compat_sioc_vif_req {
  1308. vifi_t vifi; /* Which iface */
  1309. compat_ulong_t icount;
  1310. compat_ulong_t ocount;
  1311. compat_ulong_t ibytes;
  1312. compat_ulong_t obytes;
  1313. };
  1314. int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
  1315. {
  1316. struct compat_sioc_sg_req sr;
  1317. struct compat_sioc_vif_req vr;
  1318. struct vif_device *vif;
  1319. struct mfc_cache *c;
  1320. struct net *net = sock_net(sk);
  1321. struct mr_table *mrt;
  1322. mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
  1323. if (mrt == NULL)
  1324. return -ENOENT;
  1325. switch (cmd) {
  1326. case SIOCGETVIFCNT:
  1327. if (copy_from_user(&vr, arg, sizeof(vr)))
  1328. return -EFAULT;
  1329. if (vr.vifi >= mrt->maxvif)
  1330. return -EINVAL;
  1331. read_lock(&mrt_lock);
  1332. vif = &mrt->vif_table[vr.vifi];
  1333. if (VIF_EXISTS(mrt, vr.vifi)) {
  1334. vr.icount = vif->pkt_in;
  1335. vr.ocount = vif->pkt_out;
  1336. vr.ibytes = vif->bytes_in;
  1337. vr.obytes = vif->bytes_out;
  1338. read_unlock(&mrt_lock);
  1339. if (copy_to_user(arg, &vr, sizeof(vr)))
  1340. return -EFAULT;
  1341. return 0;
  1342. }
  1343. read_unlock(&mrt_lock);
  1344. return -EADDRNOTAVAIL;
  1345. case SIOCGETSGCNT:
  1346. if (copy_from_user(&sr, arg, sizeof(sr)))
  1347. return -EFAULT;
  1348. rcu_read_lock();
  1349. c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
  1350. if (c) {
  1351. sr.pktcnt = c->mfc_un.res.pkt;
  1352. sr.bytecnt = c->mfc_un.res.bytes;
  1353. sr.wrong_if = c->mfc_un.res.wrong_if;
  1354. rcu_read_unlock();
  1355. if (copy_to_user(arg, &sr, sizeof(sr)))
  1356. return -EFAULT;
  1357. return 0;
  1358. }
  1359. rcu_read_unlock();
  1360. return -EADDRNOTAVAIL;
  1361. default:
  1362. return -ENOIOCTLCMD;
  1363. }
  1364. }
  1365. #endif
  1366. static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
  1367. {
  1368. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  1369. struct net *net = dev_net(dev);
  1370. struct mr_table *mrt;
  1371. struct vif_device *v;
  1372. int ct;
  1373. if (event != NETDEV_UNREGISTER)
  1374. return NOTIFY_DONE;
  1375. ipmr_for_each_table(mrt, net) {
  1376. v = &mrt->vif_table[0];
  1377. for (ct = 0; ct < mrt->maxvif; ct++, v++) {
  1378. if (v->dev == dev)
  1379. vif_delete(mrt, ct, 1, NULL);
  1380. }
  1381. }
  1382. return NOTIFY_DONE;
  1383. }
  1384. static struct notifier_block ip_mr_notifier = {
  1385. .notifier_call = ipmr_device_event,
  1386. };
  1387. /*
  1388. * Encapsulate a packet by attaching a valid IPIP header to it.
  1389. * This avoids tunnel drivers and other mess and gives us the speed so
  1390. * important for multicast video.
  1391. */
  1392. static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
  1393. {
  1394. struct iphdr *iph;
  1395. const struct iphdr *old_iph = ip_hdr(skb);
  1396. skb_push(skb, sizeof(struct iphdr));
  1397. skb->transport_header = skb->network_header;
  1398. skb_reset_network_header(skb);
  1399. iph = ip_hdr(skb);
  1400. iph->version = 4;
  1401. iph->tos = old_iph->tos;
  1402. iph->ttl = old_iph->ttl;
  1403. iph->frag_off = 0;
  1404. iph->daddr = daddr;
  1405. iph->saddr = saddr;
  1406. iph->protocol = IPPROTO_IPIP;
  1407. iph->ihl = 5;
  1408. iph->tot_len = htons(skb->len);
  1409. ip_select_ident(skb, skb_dst(skb), NULL);
  1410. ip_send_check(iph);
  1411. memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
  1412. nf_reset(skb);
  1413. }
  1414. static inline int ipmr_forward_finish(struct sk_buff *skb)
  1415. {
  1416. struct ip_options *opt = &(IPCB(skb)->opt);
  1417. IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
  1418. IP_ADD_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTOCTETS, skb->len);
  1419. if (unlikely(opt->optlen))
  1420. ip_forward_options(skb);
  1421. return dst_output(skb);
  1422. }
  1423. /*
  1424. * Processing handlers for ipmr_forward
  1425. */
  1426. static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
  1427. struct sk_buff *skb, struct mfc_cache *c, int vifi)
  1428. {
  1429. const struct iphdr *iph = ip_hdr(skb);
  1430. struct vif_device *vif = &mrt->vif_table[vifi];
  1431. struct net_device *dev;
  1432. struct rtable *rt;
  1433. struct flowi4 fl4;
  1434. int encap = 0;
  1435. if (vif->dev == NULL)
  1436. goto out_free;
  1437. #ifdef CONFIG_IP_PIMSM
  1438. if (vif->flags & VIFF_REGISTER) {
  1439. vif->pkt_out++;
  1440. vif->bytes_out += skb->len;
  1441. vif->dev->stats.tx_bytes += skb->len;
  1442. vif->dev->stats.tx_packets++;
  1443. ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
  1444. goto out_free;
  1445. }
  1446. #endif
  1447. if (vif->flags & VIFF_TUNNEL) {
  1448. rt = ip_route_output_ports(net, &fl4, NULL,
  1449. vif->remote, vif->local,
  1450. 0, 0,
  1451. IPPROTO_IPIP,
  1452. RT_TOS(iph->tos), vif->link);
  1453. if (IS_ERR(rt))
  1454. goto out_free;
  1455. encap = sizeof(struct iphdr);
  1456. } else {
  1457. rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
  1458. 0, 0,
  1459. IPPROTO_IPIP,
  1460. RT_TOS(iph->tos), vif->link);
  1461. if (IS_ERR(rt))
  1462. goto out_free;
  1463. }
  1464. dev = rt->dst.dev;
  1465. if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
  1466. /* Do not fragment multicasts. Alas, IPv4 does not
  1467. * allow to send ICMP, so that packets will disappear
  1468. * to blackhole.
  1469. */
  1470. IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
  1471. ip_rt_put(rt);
  1472. goto out_free;
  1473. }
  1474. encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
  1475. if (skb_cow(skb, encap)) {
  1476. ip_rt_put(rt);
  1477. goto out_free;
  1478. }
  1479. vif->pkt_out++;
  1480. vif->bytes_out += skb->len;
  1481. skb_dst_drop(skb);
  1482. skb_dst_set(skb, &rt->dst);
  1483. ip_decrease_ttl(ip_hdr(skb));
  1484. /* FIXME: forward and output firewalls used to be called here.
  1485. * What do we do with netfilter? -- RR
  1486. */
  1487. if (vif->flags & VIFF_TUNNEL) {
  1488. ip_encap(skb, vif->local, vif->remote);
  1489. /* FIXME: extra output firewall step used to be here. --RR */
  1490. vif->dev->stats.tx_packets++;
  1491. vif->dev->stats.tx_bytes += skb->len;
  1492. }
  1493. IPCB(skb)->flags |= IPSKB_FORWARDED;
  1494. /*
  1495. * RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
  1496. * not only before forwarding, but after forwarding on all output
  1497. * interfaces. It is clear, if mrouter runs a multicasting
  1498. * program, it should receive packets not depending to what interface
  1499. * program is joined.
  1500. * If we will not make it, the program will have to join on all
  1501. * interfaces. On the other hand, multihoming host (or router, but
  1502. * not mrouter) cannot join to more than one interface - it will
  1503. * result in receiving multiple packets.
  1504. */
  1505. NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
  1506. ipmr_forward_finish);
  1507. return;
  1508. out_free:
  1509. kfree_skb(skb);
  1510. }
  1511. static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
  1512. {
  1513. int ct;
  1514. for (ct = mrt->maxvif-1; ct >= 0; ct--) {
  1515. if (mrt->vif_table[ct].dev == dev)
  1516. break;
  1517. }
  1518. return ct;
  1519. }
  1520. /* "local" means that we should preserve one skb (for local delivery) */
  1521. static void ip_mr_forward(struct net *net, struct mr_table *mrt,
  1522. struct sk_buff *skb, struct mfc_cache *cache,
  1523. int local)
  1524. {
  1525. int psend = -1;
  1526. int vif, ct;
  1527. int true_vifi = ipmr_find_vif(mrt, skb->dev);
  1528. vif = cache->mfc_parent;
  1529. cache->mfc_un.res.pkt++;
  1530. cache->mfc_un.res.bytes += skb->len;
  1531. if (cache->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
  1532. struct mfc_cache *cache_proxy;
  1533. /* For an (*,G) entry, we only check that the incomming
  1534. * interface is part of the static tree.
  1535. */
  1536. cache_proxy = ipmr_cache_find_any_parent(mrt, vif);
  1537. if (cache_proxy &&
  1538. cache_proxy->mfc_un.res.ttls[true_vifi] < 255)
  1539. goto forward;
  1540. }
  1541. /*
  1542. * Wrong interface: drop packet and (maybe) send PIM assert.
  1543. */
  1544. if (mrt->vif_table[vif].dev != skb->dev) {
  1545. if (rt_is_output_route(skb_rtable(skb))) {
  1546. /* It is our own packet, looped back.
  1547. * Very complicated situation...
  1548. *
  1549. * The best workaround until routing daemons will be
  1550. * fixed is not to redistribute packet, if it was
  1551. * send through wrong interface. It means, that
  1552. * multicast applications WILL NOT work for
  1553. * (S,G), which have default multicast route pointing
  1554. * to wrong oif. In any case, it is not a good
  1555. * idea to use multicasting applications on router.
  1556. */
  1557. goto dont_forward;
  1558. }
  1559. cache->mfc_un.res.wrong_if++;
  1560. if (true_vifi >= 0 && mrt->mroute_do_assert &&
  1561. /* pimsm uses asserts, when switching from RPT to SPT,
  1562. * so that we cannot check that packet arrived on an oif.
  1563. * It is bad, but otherwise we would need to move pretty
  1564. * large chunk of pimd to kernel. Ough... --ANK
  1565. */
  1566. (mrt->mroute_do_pim ||
  1567. cache->mfc_un.res.ttls[true_vifi] < 255) &&
  1568. time_after(jiffies,
  1569. cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
  1570. cache->mfc_un.res.last_assert = jiffies;
  1571. ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
  1572. }
  1573. goto dont_forward;
  1574. }
  1575. forward:
  1576. mrt->vif_table[vif].pkt_in++;
  1577. mrt->vif_table[vif].bytes_in += skb->len;
  1578. /*
  1579. * Forward the frame
  1580. */
  1581. if (cache->mfc_origin == htonl(INADDR_ANY) &&
  1582. cache->mfc_mcastgrp == htonl(INADDR_ANY)) {
  1583. if (true_vifi >= 0 &&
  1584. true_vifi != cache->mfc_parent &&
  1585. ip_hdr(skb)->ttl >
  1586. cache->mfc_un.res.ttls[cache->mfc_parent]) {
  1587. /* It's an (*,*) entry and the packet is not coming from
  1588. * the upstream: forward the packet to the upstream
  1589. * only.
  1590. */
  1591. psend = cache->mfc_parent;
  1592. goto last_forward;
  1593. }
  1594. goto dont_forward;
  1595. }
  1596. for (ct = cache->mfc_un.res.maxvif - 1;
  1597. ct >= cache->mfc_un.res.minvif; ct--) {
  1598. /* For (*,G) entry, don't forward to the incoming interface */
  1599. if ((cache->mfc_origin != htonl(INADDR_ANY) ||
  1600. ct != true_vifi) &&
  1601. ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
  1602. if (psend != -1) {
  1603. struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  1604. if (skb2)
  1605. ipmr_queue_xmit(net, mrt, skb2, cache,
  1606. psend);
  1607. }
  1608. psend = ct;
  1609. }
  1610. }
  1611. last_forward:
  1612. if (psend != -1) {
  1613. if (local) {
  1614. struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  1615. if (skb2)
  1616. ipmr_queue_xmit(net, mrt, skb2, cache, psend);
  1617. } else {
  1618. ipmr_queue_xmit(net, mrt, skb, cache, psend);
  1619. return;
  1620. }
  1621. }
  1622. dont_forward:
  1623. if (!local)
  1624. kfree_skb(skb);
  1625. }
  1626. static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
  1627. {
  1628. struct rtable *rt = skb_rtable(skb);
  1629. struct iphdr *iph = ip_hdr(skb);
  1630. struct flowi4 fl4 = {
  1631. .daddr = iph->daddr,
  1632. .saddr = iph->saddr,
  1633. .flowi4_tos = RT_TOS(iph->tos),
  1634. .flowi4_oif = (rt_is_output_route(rt) ?
  1635. skb->dev->ifindex : 0),
  1636. .flowi4_iif = (rt_is_output_route(rt) ?
  1637. LOOPBACK_IFINDEX :
  1638. skb->dev->ifindex),
  1639. .flowi4_mark = skb->mark,
  1640. };
  1641. struct mr_table *mrt;
  1642. int err;
  1643. err = ipmr_fib_lookup(net, &fl4, &mrt);
  1644. if (err)
  1645. return ERR_PTR(err);
  1646. return mrt;
  1647. }
  1648. /*
  1649. * Multicast packets for forwarding arrive here
  1650. * Called with rcu_read_lock();
  1651. */
  1652. int ip_mr_input(struct sk_buff *skb)
  1653. {
  1654. struct mfc_cache *cache;
  1655. struct net *net = dev_net(skb->dev);
  1656. int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
  1657. struct mr_table *mrt;
  1658. /* Packet is looped back after forward, it should not be
  1659. * forwarded second time, but still can be delivered locally.
  1660. */
  1661. if (IPCB(skb)->flags & IPSKB_FORWARDED)
  1662. goto dont_forward;
  1663. mrt = ipmr_rt_fib_lookup(net, skb);
  1664. if (IS_ERR(mrt)) {
  1665. kfree_skb(skb);
  1666. return PTR_ERR(mrt);
  1667. }
  1668. if (!local) {
  1669. if (IPCB(skb)->opt.router_alert) {
  1670. if (ip_call_ra_chain(skb))
  1671. return 0;
  1672. } else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
  1673. /* IGMPv1 (and broken IGMPv2 implementations sort of
  1674. * Cisco IOS <= 11.2(8)) do not put router alert
  1675. * option to IGMP packets destined to routable
  1676. * groups. It is very bad, because it means
  1677. * that we can forward NO IGMP messages.
  1678. */
  1679. struct sock *mroute_sk;
  1680. mroute_sk = rcu_dereference(mrt->mroute_sk);
  1681. if (mroute_sk) {
  1682. nf_reset(skb);
  1683. raw_rcv(mroute_sk, skb);
  1684. return 0;
  1685. }
  1686. }
  1687. }
  1688. /* already under rcu_read_lock() */
  1689. cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
  1690. if (cache == NULL) {
  1691. int vif = ipmr_find_vif(mrt, skb->dev);
  1692. if (vif >= 0)
  1693. cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
  1694. vif);
  1695. }
  1696. /*
  1697. * No usable cache entry
  1698. */
  1699. if (cache == NULL) {
  1700. int vif;
  1701. if (local) {
  1702. struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
  1703. ip_local_deliver(skb);
  1704. if (skb2 == NULL)
  1705. return -ENOBUFS;
  1706. skb = skb2;
  1707. }
  1708. read_lock(&mrt_lock);
  1709. vif = ipmr_find_vif(mrt, skb->dev);
  1710. if (vif >= 0) {
  1711. int err2 = ipmr_cache_unresolved(mrt, vif, skb);
  1712. read_unlock(&mrt_lock);
  1713. return err2;
  1714. }
  1715. read_unlock(&mrt_lock);
  1716. kfree_skb(skb);
  1717. return -ENODEV;
  1718. }
  1719. read_lock(&mrt_lock);
  1720. ip_mr_forward(net, mrt, skb, cache, local);
  1721. read_unlock(&mrt_lock);
  1722. if (local)
  1723. return ip_local_deliver(skb);
  1724. return 0;
  1725. dont_forward:
  1726. if (local)
  1727. return ip_local_deliver(skb);
  1728. kfree_skb(skb);
  1729. return 0;
  1730. }
  1731. #ifdef CONFIG_IP_PIMSM
  1732. /* called with rcu_read_lock() */
  1733. static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
  1734. unsigned int pimlen)
  1735. {
  1736. struct net_device *reg_dev = NULL;
  1737. struct iphdr *encap;
  1738. encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
  1739. /*
  1740. * Check that:
  1741. * a. packet is really sent to a multicast group
  1742. * b. packet is not a NULL-REGISTER
  1743. * c. packet is not truncated
  1744. */
  1745. if (!ipv4_is_multicast(encap->daddr) ||
  1746. encap->tot_len == 0 ||
  1747. ntohs(encap->tot_len) + pimlen > skb->len)
  1748. return 1;
  1749. read_lock(&mrt_lock);
  1750. if (mrt->mroute_reg_vif_num >= 0)
  1751. reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
  1752. read_unlock(&mrt_lock);
  1753. if (reg_dev == NULL)
  1754. return 1;
  1755. skb->mac_header = skb->network_header;
  1756. skb_pull(skb, (u8 *)encap - skb->data);
  1757. skb_reset_network_header(skb);
  1758. skb->protocol = htons(ETH_P_IP);
  1759. skb->ip_summed = CHECKSUM_NONE;
  1760. skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
  1761. netif_rx(skb);
  1762. return NET_RX_SUCCESS;
  1763. }
  1764. #endif
  1765. #ifdef CONFIG_IP_PIMSM_V1
  1766. /*
  1767. * Handle IGMP messages of PIMv1
  1768. */
  1769. int pim_rcv_v1(struct sk_buff *skb)
  1770. {
  1771. struct igmphdr *pim;
  1772. struct net *net = dev_net(skb->dev);
  1773. struct mr_table *mrt;
  1774. if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
  1775. goto drop;
  1776. pim = igmp_hdr(skb);
  1777. mrt = ipmr_rt_fib_lookup(net, skb);
  1778. if (IS_ERR(mrt))
  1779. goto drop;
  1780. if (!mrt->mroute_do_pim ||
  1781. pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
  1782. goto drop;
  1783. if (__pim_rcv(mrt, skb, sizeof(*pim))) {
  1784. drop:
  1785. kfree_skb(skb);
  1786. }
  1787. return 0;
  1788. }
  1789. #endif
  1790. #ifdef CONFIG_IP_PIMSM_V2
  1791. static int pim_rcv(struct sk_buff *skb)
  1792. {
  1793. struct pimreghdr *pim;
  1794. struct net *net = dev_net(skb->dev);
  1795. struct mr_table *mrt;
  1796. if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
  1797. goto drop;
  1798. pim = (struct pimreghdr *)skb_transport_header(skb);
  1799. if (pim->type != ((PIM_VERSION << 4) | (PIM_REGISTER)) ||
  1800. (pim->flags & PIM_NULL_REGISTER) ||
  1801. (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
  1802. csum_fold(skb_checksum(skb, 0, skb->len, 0))))
  1803. goto drop;
  1804. mrt = ipmr_rt_fib_lookup(net, skb);
  1805. if (IS_ERR(mrt))
  1806. goto drop;
  1807. if (__pim_rcv(mrt, skb, sizeof(*pim))) {
  1808. drop:
  1809. kfree_skb(skb);
  1810. }
  1811. return 0;
  1812. }
  1813. #endif
  1814. static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
  1815. struct mfc_cache *c, struct rtmsg *rtm)
  1816. {
  1817. int ct;
  1818. struct rtnexthop *nhp;
  1819. struct nlattr *mp_attr;
  1820. struct rta_mfc_stats mfcs;
  1821. /* If cache is unresolved, don't try to parse IIF and OIF */
  1822. if (c->mfc_parent >= MAXVIFS)
  1823. return -ENOENT;
  1824. if (VIF_EXISTS(mrt, c->mfc_parent) &&
  1825. nla_put_u32(skb, RTA_IIF, mrt->vif_table[c->mfc_parent].dev->ifindex) < 0)
  1826. return -EMSGSIZE;
  1827. if (!(mp_attr = nla_nest_start(skb, RTA_MULTIPATH)))
  1828. return -EMSGSIZE;
  1829. for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
  1830. if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
  1831. if (!(nhp = nla_reserve_nohdr(skb, sizeof(*nhp)))) {
  1832. nla_nest_cancel(skb, mp_attr);
  1833. return -EMSGSIZE;
  1834. }
  1835. nhp->rtnh_flags = 0;
  1836. nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
  1837. nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
  1838. nhp->rtnh_len = sizeof(*nhp);
  1839. }
  1840. }
  1841. nla_nest_end(skb, mp_attr);
  1842. mfcs.mfcs_packets = c->mfc_un.res.pkt;
  1843. mfcs.mfcs_bytes = c->mfc_un.res.bytes;
  1844. mfcs.mfcs_wrong_if = c->mfc_un.res.wrong_if;
  1845. if (nla_put(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs) < 0)
  1846. return -EMSGSIZE;
  1847. rtm->rtm_type = RTN_MULTICAST;
  1848. return 1;
  1849. }
  1850. int ipmr_get_route(struct net *net, struct sk_buff *skb,
  1851. __be32 saddr, __be32 daddr,
  1852. struct rtmsg *rtm, int nowait)
  1853. {
  1854. struct mfc_cache *cache;
  1855. struct mr_table *mrt;
  1856. int err;
  1857. mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
  1858. if (mrt == NULL)
  1859. return -ENOENT;
  1860. rcu_read_lock();
  1861. cache = ipmr_cache_find(mrt, saddr, daddr);
  1862. if (cache == NULL && skb->dev) {
  1863. int vif = ipmr_find_vif(mrt, skb->dev);
  1864. if (vif >= 0)
  1865. cache = ipmr_cache_find_any(mrt, daddr, vif);
  1866. }
  1867. if (cache == NULL) {
  1868. struct sk_buff *skb2;
  1869. struct iphdr *iph;
  1870. struct net_device *dev;
  1871. int vif = -1;
  1872. if (nowait) {
  1873. rcu_read_unlock();
  1874. return -EAGAIN;
  1875. }
  1876. dev = skb->dev;
  1877. read_lock(&mrt_lock);
  1878. if (dev)
  1879. vif = ipmr_find_vif(mrt, dev);
  1880. if (vif < 0) {
  1881. read_unlock(&mrt_lock);
  1882. rcu_read_unlock();
  1883. return -ENODEV;
  1884. }
  1885. skb2 = skb_clone(skb, GFP_ATOMIC);
  1886. if (!skb2) {
  1887. read_unlock(&mrt_lock);
  1888. rcu_read_unlock();
  1889. return -ENOMEM;
  1890. }
  1891. skb_push(skb2, sizeof(struct iphdr));
  1892. skb_reset_network_header(skb2);
  1893. iph = ip_hdr(skb2);
  1894. iph->ihl = sizeof(struct iphdr) >> 2;
  1895. iph->saddr = saddr;
  1896. iph->daddr = daddr;
  1897. iph->version = 0;
  1898. err = ipmr_cache_unresolved(mrt, vif, skb2);
  1899. read_unlock(&mrt_lock);
  1900. rcu_read_unlock();
  1901. return err;
  1902. }
  1903. read_lock(&mrt_lock);
  1904. if (!nowait && (rtm->rtm_flags & RTM_F_NOTIFY))
  1905. cache->mfc_flags |= MFC_NOTIFY;
  1906. err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
  1907. read_unlock(&mrt_lock);
  1908. rcu_read_unlock();
  1909. return err;
  1910. }
  1911. static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
  1912. u32 portid, u32 seq, struct mfc_cache *c, int cmd)
  1913. {
  1914. struct nlmsghdr *nlh;
  1915. struct rtmsg *rtm;
  1916. int err;
  1917. nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), NLM_F_MULTI);
  1918. if (nlh == NULL)
  1919. return -EMSGSIZE;
  1920. rtm = nlmsg_data(nlh);
  1921. rtm->rtm_family = RTNL_FAMILY_IPMR;
  1922. rtm->rtm_dst_len = 32;
  1923. rtm->rtm_src_len = 32;
  1924. rtm->rtm_tos = 0;
  1925. rtm->rtm_table = mrt->id;
  1926. if (nla_put_u32(skb, RTA_TABLE, mrt->id))
  1927. goto nla_put_failure;
  1928. rtm->rtm_type = RTN_MULTICAST;
  1929. rtm->rtm_scope = RT_SCOPE_UNIVERSE;
  1930. if (c->mfc_flags & MFC_STATIC)
  1931. rtm->rtm_protocol = RTPROT_STATIC;
  1932. else
  1933. rtm->rtm_protocol = RTPROT_MROUTED;
  1934. rtm->rtm_flags = 0;
  1935. if (nla_put_be32(skb, RTA_SRC, c->mfc_origin) ||
  1936. nla_put_be32(skb, RTA_DST, c->mfc_mcastgrp))
  1937. goto nla_put_failure;
  1938. err = __ipmr_fill_mroute(mrt, skb, c, rtm);
  1939. /* do not break the dump if cache is unresolved */
  1940. if (err < 0 && err != -ENOENT)
  1941. goto nla_put_failure;
  1942. return nlmsg_end(skb, nlh);
  1943. nla_put_failure:
  1944. nlmsg_cancel(skb, nlh);
  1945. return -EMSGSIZE;
  1946. }
  1947. static size_t mroute_msgsize(bool unresolved, int maxvif)
  1948. {
  1949. size_t len =
  1950. NLMSG_ALIGN(sizeof(struct rtmsg))
  1951. + nla_total_size(4) /* RTA_TABLE */
  1952. + nla_total_size(4) /* RTA_SRC */
  1953. + nla_total_size(4) /* RTA_DST */
  1954. ;
  1955. if (!unresolved)
  1956. len = len
  1957. + nla_total_size(4) /* RTA_IIF */
  1958. + nla_total_size(0) /* RTA_MULTIPATH */
  1959. + maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
  1960. /* RTA_MFC_STATS */
  1961. + nla_total_size(sizeof(struct rta_mfc_stats))
  1962. ;
  1963. return len;
  1964. }
  1965. static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
  1966. int cmd)
  1967. {
  1968. struct net *net = read_pnet(&mrt->net);
  1969. struct sk_buff *skb;
  1970. int err = -ENOBUFS;
  1971. skb = nlmsg_new(mroute_msgsize(mfc->mfc_parent >= MAXVIFS, mrt->maxvif),
  1972. GFP_ATOMIC);
  1973. if (skb == NULL)
  1974. goto errout;
  1975. err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd);
  1976. if (err < 0)
  1977. goto errout;
  1978. rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
  1979. return;
  1980. errout:
  1981. kfree_skb(skb);
  1982. if (err < 0)
  1983. rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
  1984. }
  1985. static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
  1986. {
  1987. struct net *net = sock_net(skb->sk);
  1988. struct mr_table *mrt;
  1989. struct mfc_cache *mfc;
  1990. unsigned int t = 0, s_t;
  1991. unsigned int h = 0, s_h;
  1992. unsigned int e = 0, s_e;
  1993. s_t = cb->args[0];
  1994. s_h = cb->args[1];
  1995. s_e = cb->args[2];
  1996. rcu_read_lock();
  1997. ipmr_for_each_table(mrt, net) {
  1998. if (t < s_t)
  1999. goto next_table;
  2000. if (t > s_t)
  2001. s_h = 0;
  2002. for (h = s_h; h < MFC_LINES; h++) {
  2003. list_for_each_entry_rcu(mfc, &mrt->mfc_cache_array[h], list) {
  2004. if (e < s_e)
  2005. goto next_entry;
  2006. if (ipmr_fill_mroute(mrt, skb,
  2007. NETLINK_CB(cb->skb).portid,
  2008. cb->nlh->nlmsg_seq,
  2009. mfc, RTM_NEWROUTE) < 0)
  2010. goto done;
  2011. next_entry:
  2012. e++;
  2013. }
  2014. e = s_e = 0;
  2015. }
  2016. spin_lock_bh(&mfc_unres_lock);
  2017. list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) {
  2018. if (e < s_e)
  2019. goto next_entry2;
  2020. if (ipmr_fill_mroute(mrt, skb,
  2021. NETLINK_CB(cb->skb).portid,
  2022. cb->nlh->nlmsg_seq,
  2023. mfc, RTM_NEWROUTE) < 0) {
  2024. spin_unlock_bh(&mfc_unres_lock);
  2025. goto done;
  2026. }
  2027. next_entry2:
  2028. e++;
  2029. }
  2030. spin_unlock_bh(&mfc_unres_lock);
  2031. e = s_e = 0;
  2032. s_h = 0;
  2033. next_table:
  2034. t++;
  2035. }
  2036. done:
  2037. rcu_read_unlock();
  2038. cb->args[2] = e;
  2039. cb->args[1] = h;
  2040. cb->args[0] = t;
  2041. return skb->len;
  2042. }
  2043. #ifdef CONFIG_PROC_FS
  2044. /*
  2045. * The /proc interfaces to multicast routing :
  2046. * /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
  2047. */
  2048. struct ipmr_vif_iter {
  2049. struct seq_net_private p;
  2050. struct mr_table *mrt;
  2051. int ct;
  2052. };
  2053. static struct vif_device *ipmr_vif_seq_idx(struct net *net,
  2054. struct ipmr_vif_iter *iter,
  2055. loff_t pos)
  2056. {
  2057. struct mr_table *mrt = iter->mrt;
  2058. for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
  2059. if (!VIF_EXISTS(mrt, iter->ct))
  2060. continue;
  2061. if (pos-- == 0)
  2062. return &mrt->vif_table[iter->ct];
  2063. }
  2064. return NULL;
  2065. }
  2066. static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
  2067. __acquires(mrt_lock)
  2068. {
  2069. struct ipmr_vif_iter *iter = seq->private;
  2070. struct net *net = seq_file_net(seq);
  2071. struct mr_table *mrt;
  2072. mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
  2073. if (mrt == NULL)
  2074. return ERR_PTR(-ENOENT);
  2075. iter->mrt = mrt;
  2076. read_lock(&mrt_lock);
  2077. return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
  2078. : SEQ_START_TOKEN;
  2079. }
  2080. static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2081. {
  2082. struct ipmr_vif_iter *iter = seq->private;
  2083. struct net *net = seq_file_net(seq);
  2084. struct mr_table *mrt = iter->mrt;
  2085. ++*pos;
  2086. if (v == SEQ_START_TOKEN)
  2087. return ipmr_vif_seq_idx(net, iter, 0);
  2088. while (++iter->ct < mrt->maxvif) {
  2089. if (!VIF_EXISTS(mrt, iter->ct))
  2090. continue;
  2091. return &mrt->vif_table[iter->ct];
  2092. }
  2093. return NULL;
  2094. }
  2095. static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
  2096. __releases(mrt_lock)
  2097. {
  2098. read_unlock(&mrt_lock);
  2099. }
  2100. static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
  2101. {
  2102. struct ipmr_vif_iter *iter = seq->private;
  2103. struct mr_table *mrt = iter->mrt;
  2104. if (v == SEQ_START_TOKEN) {
  2105. seq_puts(seq,
  2106. "Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
  2107. } else {
  2108. const struct vif_device *vif = v;
  2109. const char *name = vif->dev ? vif->dev->name : "none";
  2110. seq_printf(seq,
  2111. "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
  2112. vif - mrt->vif_table,
  2113. name, vif->bytes_in, vif->pkt_in,
  2114. vif->bytes_out, vif->pkt_out,
  2115. vif->flags, vif->local, vif->remote);
  2116. }
  2117. return 0;
  2118. }
  2119. static const struct seq_operations ipmr_vif_seq_ops = {
  2120. .start = ipmr_vif_seq_start,
  2121. .next = ipmr_vif_seq_next,
  2122. .stop = ipmr_vif_seq_stop,
  2123. .show = ipmr_vif_seq_show,
  2124. };
  2125. static int ipmr_vif_open(struct inode *inode, struct file *file)
  2126. {
  2127. return seq_open_net(inode, file, &ipmr_vif_seq_ops,
  2128. sizeof(struct ipmr_vif_iter));
  2129. }
  2130. static const struct file_operations ipmr_vif_fops = {
  2131. .owner = THIS_MODULE,
  2132. .open = ipmr_vif_open,
  2133. .read = seq_read,
  2134. .llseek = seq_lseek,
  2135. .release = seq_release_net,
  2136. };
  2137. struct ipmr_mfc_iter {
  2138. struct seq_net_private p;
  2139. struct mr_table *mrt;
  2140. struct list_head *cache;
  2141. int ct;
  2142. };
  2143. static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
  2144. struct ipmr_mfc_iter *it, loff_t pos)
  2145. {
  2146. struct mr_table *mrt = it->mrt;
  2147. struct mfc_cache *mfc;
  2148. rcu_read_lock();
  2149. for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
  2150. it->cache = &mrt->mfc_cache_array[it->ct];
  2151. list_for_each_entry_rcu(mfc, it->cache, list)
  2152. if (pos-- == 0)
  2153. return mfc;
  2154. }
  2155. rcu_read_unlock();
  2156. spin_lock_bh(&mfc_unres_lock);
  2157. it->cache = &mrt->mfc_unres_queue;
  2158. list_for_each_entry(mfc, it->cache, list)
  2159. if (pos-- == 0)
  2160. return mfc;
  2161. spin_unlock_bh(&mfc_unres_lock);
  2162. it->cache = NULL;
  2163. return NULL;
  2164. }
  2165. static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
  2166. {
  2167. struct ipmr_mfc_iter *it = seq->private;
  2168. struct net *net = seq_file_net(seq);
  2169. struct mr_table *mrt;
  2170. mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
  2171. if (mrt == NULL)
  2172. return ERR_PTR(-ENOENT);
  2173. it->mrt = mrt;
  2174. it->cache = NULL;
  2175. it->ct = 0;
  2176. return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
  2177. : SEQ_START_TOKEN;
  2178. }
  2179. static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2180. {
  2181. struct mfc_cache *mfc = v;
  2182. struct ipmr_mfc_iter *it = seq->private;
  2183. struct net *net = seq_file_net(seq);
  2184. struct mr_table *mrt = it->mrt;
  2185. ++*pos;
  2186. if (v == SEQ_START_TOKEN)
  2187. return ipmr_mfc_seq_idx(net, seq->private, 0);
  2188. if (mfc->list.next != it->cache)
  2189. return list_entry(mfc->list.next, struct mfc_cache, list);
  2190. if (it->cache == &mrt->mfc_unres_queue)
  2191. goto end_of_list;
  2192. BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
  2193. while (++it->ct < MFC_LINES) {
  2194. it->cache = &mrt->mfc_cache_array[it->ct];
  2195. if (list_empty(it->cache))
  2196. continue;
  2197. return list_first_entry(it->cache, struct mfc_cache, list);
  2198. }
  2199. /* exhausted cache_array, show unresolved */
  2200. rcu_read_unlock();
  2201. it->cache = &mrt->mfc_unres_queue;
  2202. it->ct = 0;
  2203. spin_lock_bh(&mfc_unres_lock);
  2204. if (!list_empty(it->cache))
  2205. return list_first_entry(it->cache, struct mfc_cache, list);
  2206. end_of_list:
  2207. spin_unlock_bh(&mfc_unres_lock);
  2208. it->cache = NULL;
  2209. return NULL;
  2210. }
  2211. static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
  2212. {
  2213. struct ipmr_mfc_iter *it = seq->private;
  2214. struct mr_table *mrt = it->mrt;
  2215. if (it->cache == &mrt->mfc_unres_queue)
  2216. spin_unlock_bh(&mfc_unres_lock);
  2217. else if (it->cache == &mrt->mfc_cache_array[it->ct])
  2218. rcu_read_unlock();
  2219. }
  2220. static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
  2221. {
  2222. int n;
  2223. if (v == SEQ_START_TOKEN) {
  2224. seq_puts(seq,
  2225. "Group Origin Iif Pkts Bytes Wrong Oifs\n");
  2226. } else {
  2227. const struct mfc_cache *mfc = v;
  2228. const struct ipmr_mfc_iter *it = seq->private;
  2229. const struct mr_table *mrt = it->mrt;
  2230. seq_printf(seq, "%08X %08X %-3hd",
  2231. (__force u32) mfc->mfc_mcastgrp,
  2232. (__force u32) mfc->mfc_origin,
  2233. mfc->mfc_parent);
  2234. if (it->cache != &mrt->mfc_unres_queue) {
  2235. seq_printf(seq, " %8lu %8lu %8lu",
  2236. mfc->mfc_un.res.pkt,
  2237. mfc->mfc_un.res.bytes,
  2238. mfc->mfc_un.res.wrong_if);
  2239. for (n = mfc->mfc_un.res.minvif;
  2240. n < mfc->mfc_un.res.maxvif; n++) {
  2241. if (VIF_EXISTS(mrt, n) &&
  2242. mfc->mfc_un.res.ttls[n] < 255)
  2243. seq_printf(seq,
  2244. " %2d:%-3d",
  2245. n, mfc->mfc_un.res.ttls[n]);
  2246. }
  2247. } else {
  2248. /* unresolved mfc_caches don't contain
  2249. * pkt, bytes and wrong_if values
  2250. */
  2251. seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
  2252. }
  2253. seq_putc(seq, '\n');
  2254. }
  2255. return 0;
  2256. }
  2257. static const struct seq_operations ipmr_mfc_seq_ops = {
  2258. .start = ipmr_mfc_seq_start,
  2259. .next = ipmr_mfc_seq_next,
  2260. .stop = ipmr_mfc_seq_stop,
  2261. .show = ipmr_mfc_seq_show,
  2262. };
  2263. static int ipmr_mfc_open(struct inode *inode, struct file *file)
  2264. {
  2265. return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
  2266. sizeof(struct ipmr_mfc_iter));
  2267. }
  2268. static const struct file_operations ipmr_mfc_fops = {
  2269. .owner = THIS_MODULE,
  2270. .open = ipmr_mfc_open,
  2271. .read = seq_read,
  2272. .llseek = seq_lseek,
  2273. .release = seq_release_net,
  2274. };
  2275. #endif
  2276. #ifdef CONFIG_IP_PIMSM_V2
  2277. static const struct net_protocol pim_protocol = {
  2278. .handler = pim_rcv,
  2279. .netns_ok = 1,
  2280. };
  2281. #endif
  2282. /*
  2283. * Setup for IP multicast routing
  2284. */
  2285. static int __net_init ipmr_net_init(struct net *net)
  2286. {
  2287. int err;
  2288. err = ipmr_rules_init(net);
  2289. if (err < 0)
  2290. goto fail;
  2291. #ifdef CONFIG_PROC_FS
  2292. err = -ENOMEM;
  2293. if (!proc_create("ip_mr_vif", 0, net->proc_net, &ipmr_vif_fops))
  2294. goto proc_vif_fail;
  2295. if (!proc_create("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_fops))
  2296. goto proc_cache_fail;
  2297. #endif
  2298. return 0;
  2299. #ifdef CONFIG_PROC_FS
  2300. proc_cache_fail:
  2301. remove_proc_entry("ip_mr_vif", net->proc_net);
  2302. proc_vif_fail:
  2303. ipmr_rules_exit(net);
  2304. #endif
  2305. fail:
  2306. return err;
  2307. }
  2308. static void __net_exit ipmr_net_exit(struct net *net)
  2309. {
  2310. #ifdef CONFIG_PROC_FS
  2311. remove_proc_entry("ip_mr_cache", net->proc_net);
  2312. remove_proc_entry("ip_mr_vif", net->proc_net);
  2313. #endif
  2314. ipmr_rules_exit(net);
  2315. }
  2316. static struct pernet_operations ipmr_net_ops = {
  2317. .init = ipmr_net_init,
  2318. .exit = ipmr_net_exit,
  2319. };
  2320. int __init ip_mr_init(void)
  2321. {
  2322. int err;
  2323. mrt_cachep = kmem_cache_create("ip_mrt_cache",
  2324. sizeof(struct mfc_cache),
  2325. 0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
  2326. NULL);
  2327. if (!mrt_cachep)
  2328. return -ENOMEM;
  2329. err = register_pernet_subsys(&ipmr_net_ops);
  2330. if (err)
  2331. goto reg_pernet_fail;
  2332. err = register_netdevice_notifier(&ip_mr_notifier);
  2333. if (err)
  2334. goto reg_notif_fail;
  2335. #ifdef CONFIG_IP_PIMSM_V2
  2336. if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
  2337. pr_err("%s: can't add PIM protocol\n", __func__);
  2338. err = -EAGAIN;
  2339. goto add_proto_fail;
  2340. }
  2341. #endif
  2342. rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
  2343. NULL, ipmr_rtm_dumproute, NULL);
  2344. return 0;
  2345. #ifdef CONFIG_IP_PIMSM_V2
  2346. add_proto_fail:
  2347. unregister_netdevice_notifier(&ip_mr_notifier);
  2348. #endif
  2349. reg_notif_fail:
  2350. unregister_pernet_subsys(&ipmr_net_ops);
  2351. reg_pernet_fail:
  2352. kmem_cache_destroy(mrt_cachep);
  2353. return err;
  2354. }