mcast.c 71 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Multicast support for IPv6
  4. * Linux INET6 implementation
  5. *
  6. * Authors:
  7. * Pedro Roque <roque@di.fc.ul.pt>
  8. *
  9. * Based on linux/ipv4/igmp.c and linux/ipv4/ip_sockglue.c
  10. */
  11. /* Changes:
  12. *
  13. * yoshfuji : fix format of router-alert option
  14. * YOSHIFUJI Hideaki @USAGI:
  15. * Fixed source address for MLD message based on
  16. * <draft-ietf-magma-mld-source-05.txt>.
  17. * YOSHIFUJI Hideaki @USAGI:
  18. * - Ignore Queries for invalid addresses.
  19. * - MLD for link-local addresses.
  20. * David L Stevens <dlstevens@us.ibm.com>:
  21. * - MLDv2 support
  22. */
  23. #include <linux/module.h>
  24. #include <linux/errno.h>
  25. #include <linux/types.h>
  26. #include <linux/string.h>
  27. #include <linux/socket.h>
  28. #include <linux/sockios.h>
  29. #include <linux/jiffies.h>
  30. #include <linux/times.h>
  31. #include <linux/net.h>
  32. #include <linux/in.h>
  33. #include <linux/in6.h>
  34. #include <linux/netdevice.h>
  35. #include <linux/if_arp.h>
  36. #include <linux/route.h>
  37. #include <linux/init.h>
  38. #include <linux/proc_fs.h>
  39. #include <linux/seq_file.h>
  40. #include <linux/slab.h>
  41. #include <linux/pkt_sched.h>
  42. #include <net/mld.h>
  43. #include <linux/netfilter.h>
  44. #include <linux/netfilter_ipv6.h>
  45. #include <net/net_namespace.h>
  46. #include <net/sock.h>
  47. #include <net/snmp.h>
  48. #include <net/ipv6.h>
  49. #include <net/protocol.h>
  50. #include <net/if_inet6.h>
  51. #include <net/ndisc.h>
  52. #include <net/addrconf.h>
  53. #include <net/ip6_route.h>
  54. #include <net/inet_common.h>
  55. #include <net/ip6_checksum.h>
  56. /* Ensure that we have struct in6_addr aligned on 32bit word. */
  57. static int __mld2_query_bugs[] __attribute__((__unused__)) = {
  58. BUILD_BUG_ON_ZERO(offsetof(struct mld2_query, mld2q_srcs) % 4),
  59. BUILD_BUG_ON_ZERO(offsetof(struct mld2_report, mld2r_grec) % 4),
  60. BUILD_BUG_ON_ZERO(offsetof(struct mld2_grec, grec_mca) % 4)
  61. };
  62. static struct in6_addr mld2_all_mcr = MLD2_ALL_MCR_INIT;
  63. static void igmp6_join_group(struct ifmcaddr6 *ma);
  64. static void igmp6_leave_group(struct ifmcaddr6 *ma);
  65. static void igmp6_timer_handler(struct timer_list *t);
  66. static void mld_gq_timer_expire(struct timer_list *t);
  67. static void mld_ifc_timer_expire(struct timer_list *t);
  68. static void mld_ifc_event(struct inet6_dev *idev);
  69. static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *pmc);
  70. static void mld_del_delrec(struct inet6_dev *idev, struct ifmcaddr6 *pmc);
  71. static void mld_clear_delrec(struct inet6_dev *idev);
  72. static bool mld_in_v1_mode(const struct inet6_dev *idev);
  73. static int sf_setstate(struct ifmcaddr6 *pmc);
  74. static void sf_markstate(struct ifmcaddr6 *pmc);
  75. static void ip6_mc_clear_src(struct ifmcaddr6 *pmc);
  76. static int ip6_mc_del_src(struct inet6_dev *idev, const struct in6_addr *pmca,
  77. int sfmode, int sfcount, const struct in6_addr *psfsrc,
  78. int delta);
  79. static int ip6_mc_add_src(struct inet6_dev *idev, const struct in6_addr *pmca,
  80. int sfmode, int sfcount, const struct in6_addr *psfsrc,
  81. int delta);
  82. static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml,
  83. struct inet6_dev *idev);
  84. static int __ipv6_dev_mc_inc(struct net_device *dev,
  85. const struct in6_addr *addr, unsigned int mode);
  86. #define MLD_QRV_DEFAULT 2
  87. /* RFC3810, 9.2. Query Interval */
  88. #define MLD_QI_DEFAULT (125 * HZ)
  89. /* RFC3810, 9.3. Query Response Interval */
  90. #define MLD_QRI_DEFAULT (10 * HZ)
  91. /* RFC3810, 8.1 Query Version Distinctions */
  92. #define MLD_V1_QUERY_LEN 24
  93. #define MLD_V2_QUERY_LEN_MIN 28
  94. #define IPV6_MLD_MAX_MSF 64
  95. int sysctl_mld_max_msf __read_mostly = IPV6_MLD_MAX_MSF;
  96. int sysctl_mld_qrv __read_mostly = MLD_QRV_DEFAULT;
  97. /*
  98. * socket join on multicast group
  99. */
  100. #define for_each_pmc_rcu(np, pmc) \
  101. for (pmc = rcu_dereference(np->ipv6_mc_list); \
  102. pmc != NULL; \
  103. pmc = rcu_dereference(pmc->next))
  104. static int unsolicited_report_interval(struct inet6_dev *idev)
  105. {
  106. int iv;
  107. if (mld_in_v1_mode(idev))
  108. iv = idev->cnf.mldv1_unsolicited_report_interval;
  109. else
  110. iv = idev->cnf.mldv2_unsolicited_report_interval;
  111. return iv > 0 ? iv : 1;
  112. }
  113. static int __ipv6_sock_mc_join(struct sock *sk, int ifindex,
  114. const struct in6_addr *addr, unsigned int mode)
  115. {
  116. struct net_device *dev = NULL;
  117. struct ipv6_mc_socklist *mc_lst;
  118. struct ipv6_pinfo *np = inet6_sk(sk);
  119. struct net *net = sock_net(sk);
  120. int err;
  121. ASSERT_RTNL();
  122. if (!ipv6_addr_is_multicast(addr))
  123. return -EINVAL;
  124. rcu_read_lock();
  125. for_each_pmc_rcu(np, mc_lst) {
  126. if ((ifindex == 0 || mc_lst->ifindex == ifindex) &&
  127. ipv6_addr_equal(&mc_lst->addr, addr)) {
  128. rcu_read_unlock();
  129. return -EADDRINUSE;
  130. }
  131. }
  132. rcu_read_unlock();
  133. mc_lst = sock_kmalloc(sk, sizeof(struct ipv6_mc_socklist), GFP_KERNEL);
  134. if (!mc_lst)
  135. return -ENOMEM;
  136. mc_lst->next = NULL;
  137. mc_lst->addr = *addr;
  138. if (ifindex == 0) {
  139. struct rt6_info *rt;
  140. rt = rt6_lookup(net, addr, NULL, 0, NULL, 0);
  141. if (rt) {
  142. dev = rt->dst.dev;
  143. ip6_rt_put(rt);
  144. }
  145. } else
  146. dev = __dev_get_by_index(net, ifindex);
  147. if (!dev) {
  148. sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
  149. return -ENODEV;
  150. }
  151. mc_lst->ifindex = dev->ifindex;
  152. mc_lst->sfmode = mode;
  153. rwlock_init(&mc_lst->sflock);
  154. mc_lst->sflist = NULL;
  155. /*
  156. * now add/increase the group membership on the device
  157. */
  158. err = __ipv6_dev_mc_inc(dev, addr, mode);
  159. if (err) {
  160. sock_kfree_s(sk, mc_lst, sizeof(*mc_lst));
  161. return err;
  162. }
  163. mc_lst->next = np->ipv6_mc_list;
  164. rcu_assign_pointer(np->ipv6_mc_list, mc_lst);
  165. return 0;
  166. }
  167. int ipv6_sock_mc_join(struct sock *sk, int ifindex, const struct in6_addr *addr)
  168. {
  169. return __ipv6_sock_mc_join(sk, ifindex, addr, MCAST_EXCLUDE);
  170. }
  171. EXPORT_SYMBOL(ipv6_sock_mc_join);
  172. int ipv6_sock_mc_join_ssm(struct sock *sk, int ifindex,
  173. const struct in6_addr *addr, unsigned int mode)
  174. {
  175. return __ipv6_sock_mc_join(sk, ifindex, addr, mode);
  176. }
  177. /*
  178. * socket leave on multicast group
  179. */
  180. int ipv6_sock_mc_drop(struct sock *sk, int ifindex, const struct in6_addr *addr)
  181. {
  182. struct ipv6_pinfo *np = inet6_sk(sk);
  183. struct ipv6_mc_socklist *mc_lst;
  184. struct ipv6_mc_socklist __rcu **lnk;
  185. struct net *net = sock_net(sk);
  186. ASSERT_RTNL();
  187. if (!ipv6_addr_is_multicast(addr))
  188. return -EINVAL;
  189. for (lnk = &np->ipv6_mc_list;
  190. (mc_lst = rtnl_dereference(*lnk)) != NULL;
  191. lnk = &mc_lst->next) {
  192. if ((ifindex == 0 || mc_lst->ifindex == ifindex) &&
  193. ipv6_addr_equal(&mc_lst->addr, addr)) {
  194. struct net_device *dev;
  195. *lnk = mc_lst->next;
  196. dev = __dev_get_by_index(net, mc_lst->ifindex);
  197. if (dev) {
  198. struct inet6_dev *idev = __in6_dev_get(dev);
  199. (void) ip6_mc_leave_src(sk, mc_lst, idev);
  200. if (idev)
  201. __ipv6_dev_mc_dec(idev, &mc_lst->addr);
  202. } else
  203. (void) ip6_mc_leave_src(sk, mc_lst, NULL);
  204. atomic_sub(sizeof(*mc_lst), &sk->sk_omem_alloc);
  205. kfree_rcu(mc_lst, rcu);
  206. return 0;
  207. }
  208. }
  209. return -EADDRNOTAVAIL;
  210. }
  211. EXPORT_SYMBOL(ipv6_sock_mc_drop);
  212. /* called with rcu_read_lock() */
  213. static struct inet6_dev *ip6_mc_find_dev_rcu(struct net *net,
  214. const struct in6_addr *group,
  215. int ifindex)
  216. {
  217. struct net_device *dev = NULL;
  218. struct inet6_dev *idev = NULL;
  219. if (ifindex == 0) {
  220. struct rt6_info *rt = rt6_lookup(net, group, NULL, 0, NULL, 0);
  221. if (rt) {
  222. dev = rt->dst.dev;
  223. ip6_rt_put(rt);
  224. }
  225. } else
  226. dev = dev_get_by_index_rcu(net, ifindex);
  227. if (!dev)
  228. return NULL;
  229. idev = __in6_dev_get(dev);
  230. if (!idev)
  231. return NULL;
  232. read_lock_bh(&idev->lock);
  233. if (idev->dead) {
  234. read_unlock_bh(&idev->lock);
  235. return NULL;
  236. }
  237. return idev;
  238. }
  239. void __ipv6_sock_mc_close(struct sock *sk)
  240. {
  241. struct ipv6_pinfo *np = inet6_sk(sk);
  242. struct ipv6_mc_socklist *mc_lst;
  243. struct net *net = sock_net(sk);
  244. ASSERT_RTNL();
  245. while ((mc_lst = rtnl_dereference(np->ipv6_mc_list)) != NULL) {
  246. struct net_device *dev;
  247. np->ipv6_mc_list = mc_lst->next;
  248. dev = __dev_get_by_index(net, mc_lst->ifindex);
  249. if (dev) {
  250. struct inet6_dev *idev = __in6_dev_get(dev);
  251. (void) ip6_mc_leave_src(sk, mc_lst, idev);
  252. if (idev)
  253. __ipv6_dev_mc_dec(idev, &mc_lst->addr);
  254. } else
  255. (void) ip6_mc_leave_src(sk, mc_lst, NULL);
  256. atomic_sub(sizeof(*mc_lst), &sk->sk_omem_alloc);
  257. kfree_rcu(mc_lst, rcu);
  258. }
  259. }
  260. void ipv6_sock_mc_close(struct sock *sk)
  261. {
  262. struct ipv6_pinfo *np = inet6_sk(sk);
  263. if (!rcu_access_pointer(np->ipv6_mc_list))
  264. return;
  265. rtnl_lock();
  266. __ipv6_sock_mc_close(sk);
  267. rtnl_unlock();
  268. }
  269. int ip6_mc_source(int add, int omode, struct sock *sk,
  270. struct group_source_req *pgsr)
  271. {
  272. struct in6_addr *source, *group;
  273. struct ipv6_mc_socklist *pmc;
  274. struct inet6_dev *idev;
  275. struct ipv6_pinfo *inet6 = inet6_sk(sk);
  276. struct ip6_sf_socklist *psl;
  277. struct net *net = sock_net(sk);
  278. int i, j, rv;
  279. int leavegroup = 0;
  280. int pmclocked = 0;
  281. int err;
  282. source = &((struct sockaddr_in6 *)&pgsr->gsr_source)->sin6_addr;
  283. group = &((struct sockaddr_in6 *)&pgsr->gsr_group)->sin6_addr;
  284. if (!ipv6_addr_is_multicast(group))
  285. return -EINVAL;
  286. rcu_read_lock();
  287. idev = ip6_mc_find_dev_rcu(net, group, pgsr->gsr_interface);
  288. if (!idev) {
  289. rcu_read_unlock();
  290. return -ENODEV;
  291. }
  292. err = -EADDRNOTAVAIL;
  293. for_each_pmc_rcu(inet6, pmc) {
  294. if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface)
  295. continue;
  296. if (ipv6_addr_equal(&pmc->addr, group))
  297. break;
  298. }
  299. if (!pmc) { /* must have a prior join */
  300. err = -EINVAL;
  301. goto done;
  302. }
  303. /* if a source filter was set, must be the same mode as before */
  304. if (pmc->sflist) {
  305. if (pmc->sfmode != omode) {
  306. err = -EINVAL;
  307. goto done;
  308. }
  309. } else if (pmc->sfmode != omode) {
  310. /* allow mode switches for empty-set filters */
  311. ip6_mc_add_src(idev, group, omode, 0, NULL, 0);
  312. ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);
  313. pmc->sfmode = omode;
  314. }
  315. write_lock(&pmc->sflock);
  316. pmclocked = 1;
  317. psl = pmc->sflist;
  318. if (!add) {
  319. if (!psl)
  320. goto done; /* err = -EADDRNOTAVAIL */
  321. rv = !0;
  322. for (i = 0; i < psl->sl_count; i++) {
  323. rv = !ipv6_addr_equal(&psl->sl_addr[i], source);
  324. if (rv == 0)
  325. break;
  326. }
  327. if (rv) /* source not found */
  328. goto done; /* err = -EADDRNOTAVAIL */
  329. /* special case - (INCLUDE, empty) == LEAVE_GROUP */
  330. if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
  331. leavegroup = 1;
  332. goto done;
  333. }
  334. /* update the interface filter */
  335. ip6_mc_del_src(idev, group, omode, 1, source, 1);
  336. for (j = i+1; j < psl->sl_count; j++)
  337. psl->sl_addr[j-1] = psl->sl_addr[j];
  338. psl->sl_count--;
  339. err = 0;
  340. goto done;
  341. }
  342. /* else, add a new source to the filter */
  343. if (psl && psl->sl_count >= sysctl_mld_max_msf) {
  344. err = -ENOBUFS;
  345. goto done;
  346. }
  347. if (!psl || psl->sl_count == psl->sl_max) {
  348. struct ip6_sf_socklist *newpsl;
  349. int count = IP6_SFBLOCK;
  350. if (psl)
  351. count += psl->sl_max;
  352. newpsl = sock_kmalloc(sk, IP6_SFLSIZE(count), GFP_ATOMIC);
  353. if (!newpsl) {
  354. err = -ENOBUFS;
  355. goto done;
  356. }
  357. newpsl->sl_max = count;
  358. newpsl->sl_count = count - IP6_SFBLOCK;
  359. if (psl) {
  360. for (i = 0; i < psl->sl_count; i++)
  361. newpsl->sl_addr[i] = psl->sl_addr[i];
  362. sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max));
  363. }
  364. pmc->sflist = psl = newpsl;
  365. }
  366. rv = 1; /* > 0 for insert logic below if sl_count is 0 */
  367. for (i = 0; i < psl->sl_count; i++) {
  368. rv = !ipv6_addr_equal(&psl->sl_addr[i], source);
  369. if (rv == 0) /* There is an error in the address. */
  370. goto done;
  371. }
  372. for (j = psl->sl_count-1; j >= i; j--)
  373. psl->sl_addr[j+1] = psl->sl_addr[j];
  374. psl->sl_addr[i] = *source;
  375. psl->sl_count++;
  376. err = 0;
  377. /* update the interface list */
  378. ip6_mc_add_src(idev, group, omode, 1, source, 1);
  379. done:
  380. if (pmclocked)
  381. write_unlock(&pmc->sflock);
  382. read_unlock_bh(&idev->lock);
  383. rcu_read_unlock();
  384. if (leavegroup)
  385. err = ipv6_sock_mc_drop(sk, pgsr->gsr_interface, group);
  386. return err;
  387. }
  388. int ip6_mc_msfilter(struct sock *sk, struct group_filter *gsf,
  389. struct sockaddr_storage *list)
  390. {
  391. const struct in6_addr *group;
  392. struct ipv6_mc_socklist *pmc;
  393. struct inet6_dev *idev;
  394. struct ipv6_pinfo *inet6 = inet6_sk(sk);
  395. struct ip6_sf_socklist *newpsl, *psl;
  396. struct net *net = sock_net(sk);
  397. int leavegroup = 0;
  398. int i, err;
  399. group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr;
  400. if (!ipv6_addr_is_multicast(group))
  401. return -EINVAL;
  402. if (gsf->gf_fmode != MCAST_INCLUDE &&
  403. gsf->gf_fmode != MCAST_EXCLUDE)
  404. return -EINVAL;
  405. rcu_read_lock();
  406. idev = ip6_mc_find_dev_rcu(net, group, gsf->gf_interface);
  407. if (!idev) {
  408. rcu_read_unlock();
  409. return -ENODEV;
  410. }
  411. err = 0;
  412. if (gsf->gf_fmode == MCAST_INCLUDE && gsf->gf_numsrc == 0) {
  413. leavegroup = 1;
  414. goto done;
  415. }
  416. for_each_pmc_rcu(inet6, pmc) {
  417. if (pmc->ifindex != gsf->gf_interface)
  418. continue;
  419. if (ipv6_addr_equal(&pmc->addr, group))
  420. break;
  421. }
  422. if (!pmc) { /* must have a prior join */
  423. err = -EINVAL;
  424. goto done;
  425. }
  426. if (gsf->gf_numsrc) {
  427. newpsl = sock_kmalloc(sk, IP6_SFLSIZE(gsf->gf_numsrc),
  428. GFP_ATOMIC);
  429. if (!newpsl) {
  430. err = -ENOBUFS;
  431. goto done;
  432. }
  433. newpsl->sl_max = newpsl->sl_count = gsf->gf_numsrc;
  434. for (i = 0; i < newpsl->sl_count; ++i, ++list) {
  435. struct sockaddr_in6 *psin6;
  436. psin6 = (struct sockaddr_in6 *)list;
  437. newpsl->sl_addr[i] = psin6->sin6_addr;
  438. }
  439. err = ip6_mc_add_src(idev, group, gsf->gf_fmode,
  440. newpsl->sl_count, newpsl->sl_addr, 0);
  441. if (err) {
  442. sock_kfree_s(sk, newpsl, IP6_SFLSIZE(newpsl->sl_max));
  443. goto done;
  444. }
  445. } else {
  446. newpsl = NULL;
  447. (void) ip6_mc_add_src(idev, group, gsf->gf_fmode, 0, NULL, 0);
  448. }
  449. write_lock(&pmc->sflock);
  450. psl = pmc->sflist;
  451. if (psl) {
  452. (void) ip6_mc_del_src(idev, group, pmc->sfmode,
  453. psl->sl_count, psl->sl_addr, 0);
  454. sock_kfree_s(sk, psl, IP6_SFLSIZE(psl->sl_max));
  455. } else
  456. (void) ip6_mc_del_src(idev, group, pmc->sfmode, 0, NULL, 0);
  457. pmc->sflist = newpsl;
  458. pmc->sfmode = gsf->gf_fmode;
  459. write_unlock(&pmc->sflock);
  460. err = 0;
  461. done:
  462. read_unlock_bh(&idev->lock);
  463. rcu_read_unlock();
  464. if (leavegroup)
  465. err = ipv6_sock_mc_drop(sk, gsf->gf_interface, group);
  466. return err;
  467. }
  468. int ip6_mc_msfget(struct sock *sk, struct group_filter *gsf,
  469. struct sockaddr_storage *p)
  470. {
  471. int err, i, count, copycount;
  472. const struct in6_addr *group;
  473. struct ipv6_mc_socklist *pmc;
  474. struct inet6_dev *idev;
  475. struct ipv6_pinfo *inet6 = inet6_sk(sk);
  476. struct ip6_sf_socklist *psl;
  477. struct net *net = sock_net(sk);
  478. group = &((struct sockaddr_in6 *)&gsf->gf_group)->sin6_addr;
  479. if (!ipv6_addr_is_multicast(group))
  480. return -EINVAL;
  481. rcu_read_lock();
  482. idev = ip6_mc_find_dev_rcu(net, group, gsf->gf_interface);
  483. if (!idev) {
  484. rcu_read_unlock();
  485. return -ENODEV;
  486. }
  487. err = -EADDRNOTAVAIL;
  488. /* changes to the ipv6_mc_list require the socket lock and
  489. * rtnl lock. We have the socket lock and rcu read lock,
  490. * so reading the list is safe.
  491. */
  492. for_each_pmc_rcu(inet6, pmc) {
  493. if (pmc->ifindex != gsf->gf_interface)
  494. continue;
  495. if (ipv6_addr_equal(group, &pmc->addr))
  496. break;
  497. }
  498. if (!pmc) /* must have a prior join */
  499. goto done;
  500. gsf->gf_fmode = pmc->sfmode;
  501. psl = pmc->sflist;
  502. count = psl ? psl->sl_count : 0;
  503. read_unlock_bh(&idev->lock);
  504. rcu_read_unlock();
  505. copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
  506. gsf->gf_numsrc = count;
  507. /* changes to psl require the socket lock, and a write lock
  508. * on pmc->sflock. We have the socket lock so reading here is safe.
  509. */
  510. for (i = 0; i < copycount; i++, p++) {
  511. struct sockaddr_in6 *psin6;
  512. struct sockaddr_storage ss;
  513. psin6 = (struct sockaddr_in6 *)&ss;
  514. memset(&ss, 0, sizeof(ss));
  515. psin6->sin6_family = AF_INET6;
  516. psin6->sin6_addr = psl->sl_addr[i];
  517. if (copy_to_user(p, &ss, sizeof(ss)))
  518. return -EFAULT;
  519. }
  520. return 0;
  521. done:
  522. read_unlock_bh(&idev->lock);
  523. rcu_read_unlock();
  524. return err;
  525. }
  526. bool inet6_mc_check(struct sock *sk, const struct in6_addr *mc_addr,
  527. const struct in6_addr *src_addr)
  528. {
  529. struct ipv6_pinfo *np = inet6_sk(sk);
  530. struct ipv6_mc_socklist *mc;
  531. struct ip6_sf_socklist *psl;
  532. bool rv = true;
  533. rcu_read_lock();
  534. for_each_pmc_rcu(np, mc) {
  535. if (ipv6_addr_equal(&mc->addr, mc_addr))
  536. break;
  537. }
  538. if (!mc) {
  539. rcu_read_unlock();
  540. return np->mc_all;
  541. }
  542. read_lock(&mc->sflock);
  543. psl = mc->sflist;
  544. if (!psl) {
  545. rv = mc->sfmode == MCAST_EXCLUDE;
  546. } else {
  547. int i;
  548. for (i = 0; i < psl->sl_count; i++) {
  549. if (ipv6_addr_equal(&psl->sl_addr[i], src_addr))
  550. break;
  551. }
  552. if (mc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
  553. rv = false;
  554. if (mc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
  555. rv = false;
  556. }
  557. read_unlock(&mc->sflock);
  558. rcu_read_unlock();
  559. return rv;
  560. }
  561. static void igmp6_group_added(struct ifmcaddr6 *mc)
  562. {
  563. struct net_device *dev = mc->idev->dev;
  564. char buf[MAX_ADDR_LEN];
  565. if (IPV6_ADDR_MC_SCOPE(&mc->mca_addr) <
  566. IPV6_ADDR_SCOPE_LINKLOCAL)
  567. return;
  568. spin_lock_bh(&mc->mca_lock);
  569. if (!(mc->mca_flags&MAF_LOADED)) {
  570. mc->mca_flags |= MAF_LOADED;
  571. if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
  572. dev_mc_add(dev, buf);
  573. }
  574. spin_unlock_bh(&mc->mca_lock);
  575. if (!(dev->flags & IFF_UP) || (mc->mca_flags & MAF_NOREPORT))
  576. return;
  577. if (mld_in_v1_mode(mc->idev)) {
  578. igmp6_join_group(mc);
  579. return;
  580. }
  581. /* else v2 */
  582. /* Based on RFC3810 6.1, for newly added INCLUDE SSM, we
  583. * should not send filter-mode change record as the mode
  584. * should be from IN() to IN(A).
  585. */
  586. if (mc->mca_sfmode == MCAST_EXCLUDE)
  587. mc->mca_crcount = mc->idev->mc_qrv;
  588. mld_ifc_event(mc->idev);
  589. }
  590. static void igmp6_group_dropped(struct ifmcaddr6 *mc)
  591. {
  592. struct net_device *dev = mc->idev->dev;
  593. char buf[MAX_ADDR_LEN];
  594. if (IPV6_ADDR_MC_SCOPE(&mc->mca_addr) <
  595. IPV6_ADDR_SCOPE_LINKLOCAL)
  596. return;
  597. spin_lock_bh(&mc->mca_lock);
  598. if (mc->mca_flags&MAF_LOADED) {
  599. mc->mca_flags &= ~MAF_LOADED;
  600. if (ndisc_mc_map(&mc->mca_addr, buf, dev, 0) == 0)
  601. dev_mc_del(dev, buf);
  602. }
  603. spin_unlock_bh(&mc->mca_lock);
  604. if (mc->mca_flags & MAF_NOREPORT)
  605. return;
  606. if (!mc->idev->dead)
  607. igmp6_leave_group(mc);
  608. spin_lock_bh(&mc->mca_lock);
  609. if (del_timer(&mc->mca_timer))
  610. refcount_dec(&mc->mca_refcnt);
  611. spin_unlock_bh(&mc->mca_lock);
  612. }
  613. /*
  614. * deleted ifmcaddr6 manipulation
  615. */
  616. static void mld_add_delrec(struct inet6_dev *idev, struct ifmcaddr6 *im)
  617. {
  618. struct ifmcaddr6 *pmc;
  619. /* this is an "ifmcaddr6" for convenience; only the fields below
  620. * are actually used. In particular, the refcnt and users are not
  621. * used for management of the delete list. Using the same structure
  622. * for deleted items allows change reports to use common code with
  623. * non-deleted or query-response MCA's.
  624. */
  625. pmc = kzalloc(sizeof(*pmc), GFP_ATOMIC);
  626. if (!pmc)
  627. return;
  628. spin_lock_bh(&im->mca_lock);
  629. spin_lock_init(&pmc->mca_lock);
  630. pmc->idev = im->idev;
  631. in6_dev_hold(idev);
  632. pmc->mca_addr = im->mca_addr;
  633. pmc->mca_crcount = idev->mc_qrv;
  634. pmc->mca_sfmode = im->mca_sfmode;
  635. if (pmc->mca_sfmode == MCAST_INCLUDE) {
  636. struct ip6_sf_list *psf;
  637. pmc->mca_tomb = im->mca_tomb;
  638. pmc->mca_sources = im->mca_sources;
  639. im->mca_tomb = im->mca_sources = NULL;
  640. for (psf = pmc->mca_sources; psf; psf = psf->sf_next)
  641. psf->sf_crcount = pmc->mca_crcount;
  642. }
  643. spin_unlock_bh(&im->mca_lock);
  644. spin_lock_bh(&idev->mc_lock);
  645. pmc->next = idev->mc_tomb;
  646. idev->mc_tomb = pmc;
  647. spin_unlock_bh(&idev->mc_lock);
  648. }
  649. static void mld_del_delrec(struct inet6_dev *idev, struct ifmcaddr6 *im)
  650. {
  651. struct ifmcaddr6 *pmc, *pmc_prev;
  652. struct ip6_sf_list *psf;
  653. struct in6_addr *pmca = &im->mca_addr;
  654. spin_lock_bh(&idev->mc_lock);
  655. pmc_prev = NULL;
  656. for (pmc = idev->mc_tomb; pmc; pmc = pmc->next) {
  657. if (ipv6_addr_equal(&pmc->mca_addr, pmca))
  658. break;
  659. pmc_prev = pmc;
  660. }
  661. if (pmc) {
  662. if (pmc_prev)
  663. pmc_prev->next = pmc->next;
  664. else
  665. idev->mc_tomb = pmc->next;
  666. }
  667. spin_unlock_bh(&idev->mc_lock);
  668. spin_lock_bh(&im->mca_lock);
  669. if (pmc) {
  670. im->idev = pmc->idev;
  671. if (im->mca_sfmode == MCAST_INCLUDE) {
  672. swap(im->mca_tomb, pmc->mca_tomb);
  673. swap(im->mca_sources, pmc->mca_sources);
  674. for (psf = im->mca_sources; psf; psf = psf->sf_next)
  675. psf->sf_crcount = idev->mc_qrv;
  676. } else {
  677. im->mca_crcount = idev->mc_qrv;
  678. }
  679. in6_dev_put(pmc->idev);
  680. ip6_mc_clear_src(pmc);
  681. kfree(pmc);
  682. }
  683. spin_unlock_bh(&im->mca_lock);
  684. }
  685. static void mld_clear_delrec(struct inet6_dev *idev)
  686. {
  687. struct ifmcaddr6 *pmc, *nextpmc;
  688. spin_lock_bh(&idev->mc_lock);
  689. pmc = idev->mc_tomb;
  690. idev->mc_tomb = NULL;
  691. spin_unlock_bh(&idev->mc_lock);
  692. for (; pmc; pmc = nextpmc) {
  693. nextpmc = pmc->next;
  694. ip6_mc_clear_src(pmc);
  695. in6_dev_put(pmc->idev);
  696. kfree(pmc);
  697. }
  698. /* clear dead sources, too */
  699. read_lock_bh(&idev->lock);
  700. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  701. struct ip6_sf_list *psf, *psf_next;
  702. spin_lock_bh(&pmc->mca_lock);
  703. psf = pmc->mca_tomb;
  704. pmc->mca_tomb = NULL;
  705. spin_unlock_bh(&pmc->mca_lock);
  706. for (; psf; psf = psf_next) {
  707. psf_next = psf->sf_next;
  708. kfree(psf);
  709. }
  710. }
  711. read_unlock_bh(&idev->lock);
  712. }
  713. static void mca_get(struct ifmcaddr6 *mc)
  714. {
  715. refcount_inc(&mc->mca_refcnt);
  716. }
  717. static void ma_put(struct ifmcaddr6 *mc)
  718. {
  719. if (refcount_dec_and_test(&mc->mca_refcnt)) {
  720. in6_dev_put(mc->idev);
  721. kfree(mc);
  722. }
  723. }
  724. static struct ifmcaddr6 *mca_alloc(struct inet6_dev *idev,
  725. const struct in6_addr *addr,
  726. unsigned int mode)
  727. {
  728. struct ifmcaddr6 *mc;
  729. mc = kzalloc(sizeof(*mc), GFP_ATOMIC);
  730. if (!mc)
  731. return NULL;
  732. timer_setup(&mc->mca_timer, igmp6_timer_handler, 0);
  733. mc->mca_addr = *addr;
  734. mc->idev = idev; /* reference taken by caller */
  735. mc->mca_users = 1;
  736. /* mca_stamp should be updated upon changes */
  737. mc->mca_cstamp = mc->mca_tstamp = jiffies;
  738. refcount_set(&mc->mca_refcnt, 1);
  739. spin_lock_init(&mc->mca_lock);
  740. mc->mca_sfmode = mode;
  741. mc->mca_sfcount[mode] = 1;
  742. if (ipv6_addr_is_ll_all_nodes(&mc->mca_addr) ||
  743. IPV6_ADDR_MC_SCOPE(&mc->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL)
  744. mc->mca_flags |= MAF_NOREPORT;
  745. return mc;
  746. }
  747. /*
  748. * device multicast group inc (add if not found)
  749. */
  750. static int __ipv6_dev_mc_inc(struct net_device *dev,
  751. const struct in6_addr *addr, unsigned int mode)
  752. {
  753. struct ifmcaddr6 *mc;
  754. struct inet6_dev *idev;
  755. ASSERT_RTNL();
  756. /* we need to take a reference on idev */
  757. idev = in6_dev_get(dev);
  758. if (!idev)
  759. return -EINVAL;
  760. write_lock_bh(&idev->lock);
  761. if (idev->dead) {
  762. write_unlock_bh(&idev->lock);
  763. in6_dev_put(idev);
  764. return -ENODEV;
  765. }
  766. for (mc = idev->mc_list; mc; mc = mc->next) {
  767. if (ipv6_addr_equal(&mc->mca_addr, addr)) {
  768. mc->mca_users++;
  769. write_unlock_bh(&idev->lock);
  770. ip6_mc_add_src(idev, &mc->mca_addr, mode, 0, NULL, 0);
  771. in6_dev_put(idev);
  772. return 0;
  773. }
  774. }
  775. mc = mca_alloc(idev, addr, mode);
  776. if (!mc) {
  777. write_unlock_bh(&idev->lock);
  778. in6_dev_put(idev);
  779. return -ENOMEM;
  780. }
  781. mc->next = idev->mc_list;
  782. idev->mc_list = mc;
  783. /* Hold this for the code below before we unlock,
  784. * it is already exposed via idev->mc_list.
  785. */
  786. mca_get(mc);
  787. write_unlock_bh(&idev->lock);
  788. mld_del_delrec(idev, mc);
  789. igmp6_group_added(mc);
  790. ma_put(mc);
  791. return 0;
  792. }
  793. int ipv6_dev_mc_inc(struct net_device *dev, const struct in6_addr *addr)
  794. {
  795. return __ipv6_dev_mc_inc(dev, addr, MCAST_EXCLUDE);
  796. }
  797. EXPORT_SYMBOL(ipv6_dev_mc_inc);
  798. /*
  799. * device multicast group del
  800. */
  801. int __ipv6_dev_mc_dec(struct inet6_dev *idev, const struct in6_addr *addr)
  802. {
  803. struct ifmcaddr6 *ma, **map;
  804. ASSERT_RTNL();
  805. write_lock_bh(&idev->lock);
  806. for (map = &idev->mc_list; (ma = *map) != NULL; map = &ma->next) {
  807. if (ipv6_addr_equal(&ma->mca_addr, addr)) {
  808. if (--ma->mca_users == 0) {
  809. *map = ma->next;
  810. write_unlock_bh(&idev->lock);
  811. igmp6_group_dropped(ma);
  812. ip6_mc_clear_src(ma);
  813. ma_put(ma);
  814. return 0;
  815. }
  816. write_unlock_bh(&idev->lock);
  817. return 0;
  818. }
  819. }
  820. write_unlock_bh(&idev->lock);
  821. return -ENOENT;
  822. }
  823. int ipv6_dev_mc_dec(struct net_device *dev, const struct in6_addr *addr)
  824. {
  825. struct inet6_dev *idev;
  826. int err;
  827. ASSERT_RTNL();
  828. idev = __in6_dev_get(dev);
  829. if (!idev)
  830. err = -ENODEV;
  831. else
  832. err = __ipv6_dev_mc_dec(idev, addr);
  833. return err;
  834. }
  835. EXPORT_SYMBOL(ipv6_dev_mc_dec);
  836. /*
  837. * check if the interface/address pair is valid
  838. */
  839. bool ipv6_chk_mcast_addr(struct net_device *dev, const struct in6_addr *group,
  840. const struct in6_addr *src_addr)
  841. {
  842. struct inet6_dev *idev;
  843. struct ifmcaddr6 *mc;
  844. bool rv = false;
  845. rcu_read_lock();
  846. idev = __in6_dev_get(dev);
  847. if (idev) {
  848. read_lock_bh(&idev->lock);
  849. for (mc = idev->mc_list; mc; mc = mc->next) {
  850. if (ipv6_addr_equal(&mc->mca_addr, group))
  851. break;
  852. }
  853. if (mc) {
  854. if (src_addr && !ipv6_addr_any(src_addr)) {
  855. struct ip6_sf_list *psf;
  856. spin_lock_bh(&mc->mca_lock);
  857. for (psf = mc->mca_sources; psf; psf = psf->sf_next) {
  858. if (ipv6_addr_equal(&psf->sf_addr, src_addr))
  859. break;
  860. }
  861. if (psf)
  862. rv = psf->sf_count[MCAST_INCLUDE] ||
  863. psf->sf_count[MCAST_EXCLUDE] !=
  864. mc->mca_sfcount[MCAST_EXCLUDE];
  865. else
  866. rv = mc->mca_sfcount[MCAST_EXCLUDE] != 0;
  867. spin_unlock_bh(&mc->mca_lock);
  868. } else
  869. rv = true; /* don't filter unspecified source */
  870. }
  871. read_unlock_bh(&idev->lock);
  872. }
  873. rcu_read_unlock();
  874. return rv;
  875. }
  876. static void mld_gq_start_timer(struct inet6_dev *idev)
  877. {
  878. unsigned long tv = prandom_u32() % idev->mc_maxdelay;
  879. idev->mc_gq_running = 1;
  880. if (!mod_timer(&idev->mc_gq_timer, jiffies+tv+2))
  881. in6_dev_hold(idev);
  882. }
  883. static void mld_gq_stop_timer(struct inet6_dev *idev)
  884. {
  885. idev->mc_gq_running = 0;
  886. if (del_timer(&idev->mc_gq_timer))
  887. __in6_dev_put(idev);
  888. }
  889. static void mld_ifc_start_timer(struct inet6_dev *idev, unsigned long delay)
  890. {
  891. unsigned long tv = prandom_u32() % delay;
  892. if (!mod_timer(&idev->mc_ifc_timer, jiffies+tv+2))
  893. in6_dev_hold(idev);
  894. }
  895. static void mld_ifc_stop_timer(struct inet6_dev *idev)
  896. {
  897. idev->mc_ifc_count = 0;
  898. if (del_timer(&idev->mc_ifc_timer))
  899. __in6_dev_put(idev);
  900. }
  901. static void mld_dad_start_timer(struct inet6_dev *idev, unsigned long delay)
  902. {
  903. unsigned long tv = prandom_u32() % delay;
  904. if (!mod_timer(&idev->mc_dad_timer, jiffies+tv+2))
  905. in6_dev_hold(idev);
  906. }
  907. static void mld_dad_stop_timer(struct inet6_dev *idev)
  908. {
  909. if (del_timer(&idev->mc_dad_timer))
  910. __in6_dev_put(idev);
  911. }
  912. /*
  913. * IGMP handling (alias multicast ICMPv6 messages)
  914. */
  915. static void igmp6_group_queried(struct ifmcaddr6 *ma, unsigned long resptime)
  916. {
  917. unsigned long delay = resptime;
  918. /* Do not start timer for these addresses */
  919. if (ipv6_addr_is_ll_all_nodes(&ma->mca_addr) ||
  920. IPV6_ADDR_MC_SCOPE(&ma->mca_addr) < IPV6_ADDR_SCOPE_LINKLOCAL)
  921. return;
  922. if (del_timer(&ma->mca_timer)) {
  923. refcount_dec(&ma->mca_refcnt);
  924. delay = ma->mca_timer.expires - jiffies;
  925. }
  926. if (delay >= resptime)
  927. delay = prandom_u32() % resptime;
  928. ma->mca_timer.expires = jiffies + delay;
  929. if (!mod_timer(&ma->mca_timer, jiffies + delay))
  930. refcount_inc(&ma->mca_refcnt);
  931. ma->mca_flags |= MAF_TIMER_RUNNING;
  932. }
  933. /* mark EXCLUDE-mode sources */
  934. static bool mld_xmarksources(struct ifmcaddr6 *pmc, int nsrcs,
  935. const struct in6_addr *srcs)
  936. {
  937. struct ip6_sf_list *psf;
  938. int i, scount;
  939. scount = 0;
  940. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  941. if (scount == nsrcs)
  942. break;
  943. for (i = 0; i < nsrcs; i++) {
  944. /* skip inactive filters */
  945. if (psf->sf_count[MCAST_INCLUDE] ||
  946. pmc->mca_sfcount[MCAST_EXCLUDE] !=
  947. psf->sf_count[MCAST_EXCLUDE])
  948. break;
  949. if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) {
  950. scount++;
  951. break;
  952. }
  953. }
  954. }
  955. pmc->mca_flags &= ~MAF_GSQUERY;
  956. if (scount == nsrcs) /* all sources excluded */
  957. return false;
  958. return true;
  959. }
  960. static bool mld_marksources(struct ifmcaddr6 *pmc, int nsrcs,
  961. const struct in6_addr *srcs)
  962. {
  963. struct ip6_sf_list *psf;
  964. int i, scount;
  965. if (pmc->mca_sfmode == MCAST_EXCLUDE)
  966. return mld_xmarksources(pmc, nsrcs, srcs);
  967. /* mark INCLUDE-mode sources */
  968. scount = 0;
  969. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  970. if (scount == nsrcs)
  971. break;
  972. for (i = 0; i < nsrcs; i++) {
  973. if (ipv6_addr_equal(&srcs[i], &psf->sf_addr)) {
  974. psf->sf_gsresp = 1;
  975. scount++;
  976. break;
  977. }
  978. }
  979. }
  980. if (!scount) {
  981. pmc->mca_flags &= ~MAF_GSQUERY;
  982. return false;
  983. }
  984. pmc->mca_flags |= MAF_GSQUERY;
  985. return true;
  986. }
  987. static int mld_force_mld_version(const struct inet6_dev *idev)
  988. {
  989. /* Normally, both are 0 here. If enforcement to a particular is
  990. * being used, individual device enforcement will have a lower
  991. * precedence over 'all' device (.../conf/all/force_mld_version).
  992. */
  993. if (dev_net(idev->dev)->ipv6.devconf_all->force_mld_version != 0)
  994. return dev_net(idev->dev)->ipv6.devconf_all->force_mld_version;
  995. else
  996. return idev->cnf.force_mld_version;
  997. }
  998. static bool mld_in_v2_mode_only(const struct inet6_dev *idev)
  999. {
  1000. return mld_force_mld_version(idev) == 2;
  1001. }
  1002. static bool mld_in_v1_mode_only(const struct inet6_dev *idev)
  1003. {
  1004. return mld_force_mld_version(idev) == 1;
  1005. }
  1006. static bool mld_in_v1_mode(const struct inet6_dev *idev)
  1007. {
  1008. if (mld_in_v2_mode_only(idev))
  1009. return false;
  1010. if (mld_in_v1_mode_only(idev))
  1011. return true;
  1012. if (idev->mc_v1_seen && time_before(jiffies, idev->mc_v1_seen))
  1013. return true;
  1014. return false;
  1015. }
  1016. static void mld_set_v1_mode(struct inet6_dev *idev)
  1017. {
  1018. /* RFC3810, relevant sections:
  1019. * - 9.1. Robustness Variable
  1020. * - 9.2. Query Interval
  1021. * - 9.3. Query Response Interval
  1022. * - 9.12. Older Version Querier Present Timeout
  1023. */
  1024. unsigned long switchback;
  1025. switchback = (idev->mc_qrv * idev->mc_qi) + idev->mc_qri;
  1026. idev->mc_v1_seen = jiffies + switchback;
  1027. }
  1028. static void mld_update_qrv(struct inet6_dev *idev,
  1029. const struct mld2_query *mlh2)
  1030. {
  1031. /* RFC3810, relevant sections:
  1032. * - 5.1.8. QRV (Querier's Robustness Variable)
  1033. * - 9.1. Robustness Variable
  1034. */
  1035. /* The value of the Robustness Variable MUST NOT be zero,
  1036. * and SHOULD NOT be one. Catch this here if we ever run
  1037. * into such a case in future.
  1038. */
  1039. const int min_qrv = min(MLD_QRV_DEFAULT, sysctl_mld_qrv);
  1040. WARN_ON(idev->mc_qrv == 0);
  1041. if (mlh2->mld2q_qrv > 0)
  1042. idev->mc_qrv = mlh2->mld2q_qrv;
  1043. if (unlikely(idev->mc_qrv < min_qrv)) {
  1044. net_warn_ratelimited("IPv6: MLD: clamping QRV from %u to %u!\n",
  1045. idev->mc_qrv, min_qrv);
  1046. idev->mc_qrv = min_qrv;
  1047. }
  1048. }
  1049. static void mld_update_qi(struct inet6_dev *idev,
  1050. const struct mld2_query *mlh2)
  1051. {
  1052. /* RFC3810, relevant sections:
  1053. * - 5.1.9. QQIC (Querier's Query Interval Code)
  1054. * - 9.2. Query Interval
  1055. * - 9.12. Older Version Querier Present Timeout
  1056. * (the [Query Interval] in the last Query received)
  1057. */
  1058. unsigned long mc_qqi;
  1059. if (mlh2->mld2q_qqic < 128) {
  1060. mc_qqi = mlh2->mld2q_qqic;
  1061. } else {
  1062. unsigned long mc_man, mc_exp;
  1063. mc_exp = MLDV2_QQIC_EXP(mlh2->mld2q_qqic);
  1064. mc_man = MLDV2_QQIC_MAN(mlh2->mld2q_qqic);
  1065. mc_qqi = (mc_man | 0x10) << (mc_exp + 3);
  1066. }
  1067. idev->mc_qi = mc_qqi * HZ;
  1068. }
  1069. static void mld_update_qri(struct inet6_dev *idev,
  1070. const struct mld2_query *mlh2)
  1071. {
  1072. /* RFC3810, relevant sections:
  1073. * - 5.1.3. Maximum Response Code
  1074. * - 9.3. Query Response Interval
  1075. */
  1076. idev->mc_qri = msecs_to_jiffies(mldv2_mrc(mlh2));
  1077. }
  1078. static int mld_process_v1(struct inet6_dev *idev, struct mld_msg *mld,
  1079. unsigned long *max_delay, bool v1_query)
  1080. {
  1081. unsigned long mldv1_md;
  1082. /* Ignore v1 queries */
  1083. if (mld_in_v2_mode_only(idev))
  1084. return -EINVAL;
  1085. mldv1_md = ntohs(mld->mld_maxdelay);
  1086. /* When in MLDv1 fallback and a MLDv2 router start-up being
  1087. * unaware of current MLDv1 operation, the MRC == MRD mapping
  1088. * only works when the exponential algorithm is not being
  1089. * used (as MLDv1 is unaware of such things).
  1090. *
  1091. * According to the RFC author, the MLDv2 implementations
  1092. * he's aware of all use a MRC < 32768 on start up queries.
  1093. *
  1094. * Thus, should we *ever* encounter something else larger
  1095. * than that, just assume the maximum possible within our
  1096. * reach.
  1097. */
  1098. if (!v1_query)
  1099. mldv1_md = min(mldv1_md, MLDV1_MRD_MAX_COMPAT);
  1100. *max_delay = max(msecs_to_jiffies(mldv1_md), 1UL);
  1101. /* MLDv1 router present: we need to go into v1 mode *only*
  1102. * when an MLDv1 query is received as per section 9.12. of
  1103. * RFC3810! And we know from RFC2710 section 3.7 that MLDv1
  1104. * queries MUST be of exactly 24 octets.
  1105. */
  1106. if (v1_query)
  1107. mld_set_v1_mode(idev);
  1108. /* cancel MLDv2 report timer */
  1109. mld_gq_stop_timer(idev);
  1110. /* cancel the interface change timer */
  1111. mld_ifc_stop_timer(idev);
  1112. /* clear deleted report items */
  1113. mld_clear_delrec(idev);
  1114. return 0;
  1115. }
  1116. static int mld_process_v2(struct inet6_dev *idev, struct mld2_query *mld,
  1117. unsigned long *max_delay)
  1118. {
  1119. *max_delay = max(msecs_to_jiffies(mldv2_mrc(mld)), 1UL);
  1120. mld_update_qrv(idev, mld);
  1121. mld_update_qi(idev, mld);
  1122. mld_update_qri(idev, mld);
  1123. idev->mc_maxdelay = *max_delay;
  1124. return 0;
  1125. }
  1126. /* called with rcu_read_lock() */
  1127. int igmp6_event_query(struct sk_buff *skb)
  1128. {
  1129. struct mld2_query *mlh2 = NULL;
  1130. struct ifmcaddr6 *ma;
  1131. const struct in6_addr *group;
  1132. unsigned long max_delay;
  1133. struct inet6_dev *idev;
  1134. struct mld_msg *mld;
  1135. int group_type;
  1136. int mark = 0;
  1137. int len, err;
  1138. if (!pskb_may_pull(skb, sizeof(struct in6_addr)))
  1139. return -EINVAL;
  1140. /* compute payload length excluding extension headers */
  1141. len = ntohs(ipv6_hdr(skb)->payload_len) + sizeof(struct ipv6hdr);
  1142. len -= skb_network_header_len(skb);
  1143. /* RFC3810 6.2
  1144. * Upon reception of an MLD message that contains a Query, the node
  1145. * checks if the source address of the message is a valid link-local
  1146. * address, if the Hop Limit is set to 1, and if the Router Alert
  1147. * option is present in the Hop-By-Hop Options header of the IPv6
  1148. * packet. If any of these checks fails, the packet is dropped.
  1149. */
  1150. if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL) ||
  1151. ipv6_hdr(skb)->hop_limit != 1 ||
  1152. !(IP6CB(skb)->flags & IP6SKB_ROUTERALERT) ||
  1153. IP6CB(skb)->ra != htons(IPV6_OPT_ROUTERALERT_MLD))
  1154. return -EINVAL;
  1155. idev = __in6_dev_get(skb->dev);
  1156. if (!idev)
  1157. return 0;
  1158. mld = (struct mld_msg *)icmp6_hdr(skb);
  1159. group = &mld->mld_mca;
  1160. group_type = ipv6_addr_type(group);
  1161. if (group_type != IPV6_ADDR_ANY &&
  1162. !(group_type&IPV6_ADDR_MULTICAST))
  1163. return -EINVAL;
  1164. if (len < MLD_V1_QUERY_LEN) {
  1165. return -EINVAL;
  1166. } else if (len == MLD_V1_QUERY_LEN || mld_in_v1_mode(idev)) {
  1167. err = mld_process_v1(idev, mld, &max_delay,
  1168. len == MLD_V1_QUERY_LEN);
  1169. if (err < 0)
  1170. return err;
  1171. } else if (len >= MLD_V2_QUERY_LEN_MIN) {
  1172. int srcs_offset = sizeof(struct mld2_query) -
  1173. sizeof(struct icmp6hdr);
  1174. if (!pskb_may_pull(skb, srcs_offset))
  1175. return -EINVAL;
  1176. mlh2 = (struct mld2_query *)skb_transport_header(skb);
  1177. err = mld_process_v2(idev, mlh2, &max_delay);
  1178. if (err < 0)
  1179. return err;
  1180. if (group_type == IPV6_ADDR_ANY) { /* general query */
  1181. if (mlh2->mld2q_nsrcs)
  1182. return -EINVAL; /* no sources allowed */
  1183. mld_gq_start_timer(idev);
  1184. return 0;
  1185. }
  1186. /* mark sources to include, if group & source-specific */
  1187. if (mlh2->mld2q_nsrcs != 0) {
  1188. if (!pskb_may_pull(skb, srcs_offset +
  1189. ntohs(mlh2->mld2q_nsrcs) * sizeof(struct in6_addr)))
  1190. return -EINVAL;
  1191. mlh2 = (struct mld2_query *)skb_transport_header(skb);
  1192. mark = 1;
  1193. }
  1194. } else {
  1195. return -EINVAL;
  1196. }
  1197. read_lock_bh(&idev->lock);
  1198. if (group_type == IPV6_ADDR_ANY) {
  1199. for (ma = idev->mc_list; ma; ma = ma->next) {
  1200. spin_lock_bh(&ma->mca_lock);
  1201. igmp6_group_queried(ma, max_delay);
  1202. spin_unlock_bh(&ma->mca_lock);
  1203. }
  1204. } else {
  1205. for (ma = idev->mc_list; ma; ma = ma->next) {
  1206. if (!ipv6_addr_equal(group, &ma->mca_addr))
  1207. continue;
  1208. spin_lock_bh(&ma->mca_lock);
  1209. if (ma->mca_flags & MAF_TIMER_RUNNING) {
  1210. /* gsquery <- gsquery && mark */
  1211. if (!mark)
  1212. ma->mca_flags &= ~MAF_GSQUERY;
  1213. } else {
  1214. /* gsquery <- mark */
  1215. if (mark)
  1216. ma->mca_flags |= MAF_GSQUERY;
  1217. else
  1218. ma->mca_flags &= ~MAF_GSQUERY;
  1219. }
  1220. if (!(ma->mca_flags & MAF_GSQUERY) ||
  1221. mld_marksources(ma, ntohs(mlh2->mld2q_nsrcs), mlh2->mld2q_srcs))
  1222. igmp6_group_queried(ma, max_delay);
  1223. spin_unlock_bh(&ma->mca_lock);
  1224. break;
  1225. }
  1226. }
  1227. read_unlock_bh(&idev->lock);
  1228. return 0;
  1229. }
  1230. /* called with rcu_read_lock() */
  1231. int igmp6_event_report(struct sk_buff *skb)
  1232. {
  1233. struct ifmcaddr6 *ma;
  1234. struct inet6_dev *idev;
  1235. struct mld_msg *mld;
  1236. int addr_type;
  1237. /* Our own report looped back. Ignore it. */
  1238. if (skb->pkt_type == PACKET_LOOPBACK)
  1239. return 0;
  1240. /* send our report if the MC router may not have heard this report */
  1241. if (skb->pkt_type != PACKET_MULTICAST &&
  1242. skb->pkt_type != PACKET_BROADCAST)
  1243. return 0;
  1244. if (!pskb_may_pull(skb, sizeof(*mld) - sizeof(struct icmp6hdr)))
  1245. return -EINVAL;
  1246. mld = (struct mld_msg *)icmp6_hdr(skb);
  1247. /* Drop reports with not link local source */
  1248. addr_type = ipv6_addr_type(&ipv6_hdr(skb)->saddr);
  1249. if (addr_type != IPV6_ADDR_ANY &&
  1250. !(addr_type&IPV6_ADDR_LINKLOCAL))
  1251. return -EINVAL;
  1252. idev = __in6_dev_get(skb->dev);
  1253. if (!idev)
  1254. return -ENODEV;
  1255. /*
  1256. * Cancel the timer for this group
  1257. */
  1258. read_lock_bh(&idev->lock);
  1259. for (ma = idev->mc_list; ma; ma = ma->next) {
  1260. if (ipv6_addr_equal(&ma->mca_addr, &mld->mld_mca)) {
  1261. spin_lock(&ma->mca_lock);
  1262. if (del_timer(&ma->mca_timer))
  1263. refcount_dec(&ma->mca_refcnt);
  1264. ma->mca_flags &= ~(MAF_LAST_REPORTER|MAF_TIMER_RUNNING);
  1265. spin_unlock(&ma->mca_lock);
  1266. break;
  1267. }
  1268. }
  1269. read_unlock_bh(&idev->lock);
  1270. return 0;
  1271. }
  1272. static bool is_in(struct ifmcaddr6 *pmc, struct ip6_sf_list *psf, int type,
  1273. int gdeleted, int sdeleted)
  1274. {
  1275. switch (type) {
  1276. case MLD2_MODE_IS_INCLUDE:
  1277. case MLD2_MODE_IS_EXCLUDE:
  1278. if (gdeleted || sdeleted)
  1279. return false;
  1280. if (!((pmc->mca_flags & MAF_GSQUERY) && !psf->sf_gsresp)) {
  1281. if (pmc->mca_sfmode == MCAST_INCLUDE)
  1282. return true;
  1283. /* don't include if this source is excluded
  1284. * in all filters
  1285. */
  1286. if (psf->sf_count[MCAST_INCLUDE])
  1287. return type == MLD2_MODE_IS_INCLUDE;
  1288. return pmc->mca_sfcount[MCAST_EXCLUDE] ==
  1289. psf->sf_count[MCAST_EXCLUDE];
  1290. }
  1291. return false;
  1292. case MLD2_CHANGE_TO_INCLUDE:
  1293. if (gdeleted || sdeleted)
  1294. return false;
  1295. return psf->sf_count[MCAST_INCLUDE] != 0;
  1296. case MLD2_CHANGE_TO_EXCLUDE:
  1297. if (gdeleted || sdeleted)
  1298. return false;
  1299. if (pmc->mca_sfcount[MCAST_EXCLUDE] == 0 ||
  1300. psf->sf_count[MCAST_INCLUDE])
  1301. return false;
  1302. return pmc->mca_sfcount[MCAST_EXCLUDE] ==
  1303. psf->sf_count[MCAST_EXCLUDE];
  1304. case MLD2_ALLOW_NEW_SOURCES:
  1305. if (gdeleted || !psf->sf_crcount)
  1306. return false;
  1307. return (pmc->mca_sfmode == MCAST_INCLUDE) ^ sdeleted;
  1308. case MLD2_BLOCK_OLD_SOURCES:
  1309. if (pmc->mca_sfmode == MCAST_INCLUDE)
  1310. return gdeleted || (psf->sf_crcount && sdeleted);
  1311. return psf->sf_crcount && !gdeleted && !sdeleted;
  1312. }
  1313. return false;
  1314. }
  1315. static int
  1316. mld_scount(struct ifmcaddr6 *pmc, int type, int gdeleted, int sdeleted)
  1317. {
  1318. struct ip6_sf_list *psf;
  1319. int scount = 0;
  1320. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  1321. if (!is_in(pmc, psf, type, gdeleted, sdeleted))
  1322. continue;
  1323. scount++;
  1324. }
  1325. return scount;
  1326. }
  1327. static void ip6_mc_hdr(struct sock *sk, struct sk_buff *skb,
  1328. struct net_device *dev,
  1329. const struct in6_addr *saddr,
  1330. const struct in6_addr *daddr,
  1331. int proto, int len)
  1332. {
  1333. struct ipv6hdr *hdr;
  1334. skb->protocol = htons(ETH_P_IPV6);
  1335. skb->dev = dev;
  1336. skb_reset_network_header(skb);
  1337. skb_put(skb, sizeof(struct ipv6hdr));
  1338. hdr = ipv6_hdr(skb);
  1339. ip6_flow_hdr(hdr, 0, 0);
  1340. hdr->payload_len = htons(len);
  1341. hdr->nexthdr = proto;
  1342. hdr->hop_limit = inet6_sk(sk)->hop_limit;
  1343. hdr->saddr = *saddr;
  1344. hdr->daddr = *daddr;
  1345. }
  1346. static struct sk_buff *mld_newpack(struct inet6_dev *idev, unsigned int mtu)
  1347. {
  1348. struct net_device *dev = idev->dev;
  1349. struct net *net = dev_net(dev);
  1350. struct sock *sk = net->ipv6.igmp_sk;
  1351. struct sk_buff *skb;
  1352. struct mld2_report *pmr;
  1353. struct in6_addr addr_buf;
  1354. const struct in6_addr *saddr;
  1355. int hlen = LL_RESERVED_SPACE(dev);
  1356. int tlen = dev->needed_tailroom;
  1357. unsigned int size = mtu + hlen + tlen;
  1358. int err;
  1359. u8 ra[8] = { IPPROTO_ICMPV6, 0,
  1360. IPV6_TLV_ROUTERALERT, 2, 0, 0,
  1361. IPV6_TLV_PADN, 0 };
  1362. /* we assume size > sizeof(ra) here */
  1363. skb = sock_alloc_send_skb(sk, size, 1, &err);
  1364. if (!skb)
  1365. return NULL;
  1366. skb->priority = TC_PRIO_CONTROL;
  1367. skb_reserve(skb, hlen);
  1368. skb_tailroom_reserve(skb, mtu, tlen);
  1369. if (__ipv6_get_lladdr(idev, &addr_buf, IFA_F_TENTATIVE)) {
  1370. /* <draft-ietf-magma-mld-source-05.txt>:
  1371. * use unspecified address as the source address
  1372. * when a valid link-local address is not available.
  1373. */
  1374. saddr = &in6addr_any;
  1375. } else
  1376. saddr = &addr_buf;
  1377. ip6_mc_hdr(sk, skb, dev, saddr, &mld2_all_mcr, NEXTHDR_HOP, 0);
  1378. skb_put_data(skb, ra, sizeof(ra));
  1379. skb_set_transport_header(skb, skb_tail_pointer(skb) - skb->data);
  1380. skb_put(skb, sizeof(*pmr));
  1381. pmr = (struct mld2_report *)skb_transport_header(skb);
  1382. pmr->mld2r_type = ICMPV6_MLD2_REPORT;
  1383. pmr->mld2r_resv1 = 0;
  1384. pmr->mld2r_cksum = 0;
  1385. pmr->mld2r_resv2 = 0;
  1386. pmr->mld2r_ngrec = 0;
  1387. return skb;
  1388. }
  1389. static void mld_sendpack(struct sk_buff *skb)
  1390. {
  1391. struct ipv6hdr *pip6 = ipv6_hdr(skb);
  1392. struct mld2_report *pmr =
  1393. (struct mld2_report *)skb_transport_header(skb);
  1394. int payload_len, mldlen;
  1395. struct inet6_dev *idev;
  1396. struct net *net = dev_net(skb->dev);
  1397. int err;
  1398. struct flowi6 fl6;
  1399. struct dst_entry *dst;
  1400. rcu_read_lock();
  1401. idev = __in6_dev_get(skb->dev);
  1402. IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
  1403. payload_len = (skb_tail_pointer(skb) - skb_network_header(skb)) -
  1404. sizeof(*pip6);
  1405. mldlen = skb_tail_pointer(skb) - skb_transport_header(skb);
  1406. pip6->payload_len = htons(payload_len);
  1407. pmr->mld2r_cksum = csum_ipv6_magic(&pip6->saddr, &pip6->daddr, mldlen,
  1408. IPPROTO_ICMPV6,
  1409. csum_partial(skb_transport_header(skb),
  1410. mldlen, 0));
  1411. icmpv6_flow_init(net->ipv6.igmp_sk, &fl6, ICMPV6_MLD2_REPORT,
  1412. &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
  1413. skb->dev->ifindex);
  1414. dst = icmp6_dst_alloc(skb->dev, &fl6);
  1415. err = 0;
  1416. if (IS_ERR(dst)) {
  1417. err = PTR_ERR(dst);
  1418. dst = NULL;
  1419. }
  1420. skb_dst_set(skb, dst);
  1421. if (err)
  1422. goto err_out;
  1423. err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
  1424. net, net->ipv6.igmp_sk, skb, NULL, skb->dev,
  1425. dst_output);
  1426. out:
  1427. if (!err) {
  1428. ICMP6MSGOUT_INC_STATS(net, idev, ICMPV6_MLD2_REPORT);
  1429. ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
  1430. } else {
  1431. IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
  1432. }
  1433. rcu_read_unlock();
  1434. return;
  1435. err_out:
  1436. kfree_skb(skb);
  1437. goto out;
  1438. }
  1439. static int grec_size(struct ifmcaddr6 *pmc, int type, int gdel, int sdel)
  1440. {
  1441. return sizeof(struct mld2_grec) + 16 * mld_scount(pmc,type,gdel,sdel);
  1442. }
  1443. static struct sk_buff *add_grhead(struct sk_buff *skb, struct ifmcaddr6 *pmc,
  1444. int type, struct mld2_grec **ppgr, unsigned int mtu)
  1445. {
  1446. struct mld2_report *pmr;
  1447. struct mld2_grec *pgr;
  1448. if (!skb) {
  1449. skb = mld_newpack(pmc->idev, mtu);
  1450. if (!skb)
  1451. return NULL;
  1452. }
  1453. pgr = skb_put(skb, sizeof(struct mld2_grec));
  1454. pgr->grec_type = type;
  1455. pgr->grec_auxwords = 0;
  1456. pgr->grec_nsrcs = 0;
  1457. pgr->grec_mca = pmc->mca_addr; /* structure copy */
  1458. pmr = (struct mld2_report *)skb_transport_header(skb);
  1459. pmr->mld2r_ngrec = htons(ntohs(pmr->mld2r_ngrec)+1);
  1460. *ppgr = pgr;
  1461. return skb;
  1462. }
  1463. #define AVAILABLE(skb) ((skb) ? skb_availroom(skb) : 0)
  1464. static struct sk_buff *add_grec(struct sk_buff *skb, struct ifmcaddr6 *pmc,
  1465. int type, int gdeleted, int sdeleted, int crsend)
  1466. {
  1467. struct inet6_dev *idev = pmc->idev;
  1468. struct net_device *dev = idev->dev;
  1469. struct mld2_report *pmr;
  1470. struct mld2_grec *pgr = NULL;
  1471. struct ip6_sf_list *psf, *psf_next, *psf_prev, **psf_list;
  1472. int scount, stotal, first, isquery, truncate;
  1473. unsigned int mtu;
  1474. if (pmc->mca_flags & MAF_NOREPORT)
  1475. return skb;
  1476. mtu = READ_ONCE(dev->mtu);
  1477. if (mtu < IPV6_MIN_MTU)
  1478. return skb;
  1479. isquery = type == MLD2_MODE_IS_INCLUDE ||
  1480. type == MLD2_MODE_IS_EXCLUDE;
  1481. truncate = type == MLD2_MODE_IS_EXCLUDE ||
  1482. type == MLD2_CHANGE_TO_EXCLUDE;
  1483. stotal = scount = 0;
  1484. psf_list = sdeleted ? &pmc->mca_tomb : &pmc->mca_sources;
  1485. if (!*psf_list)
  1486. goto empty_source;
  1487. pmr = skb ? (struct mld2_report *)skb_transport_header(skb) : NULL;
  1488. /* EX and TO_EX get a fresh packet, if needed */
  1489. if (truncate) {
  1490. if (pmr && pmr->mld2r_ngrec &&
  1491. AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
  1492. if (skb)
  1493. mld_sendpack(skb);
  1494. skb = mld_newpack(idev, mtu);
  1495. }
  1496. }
  1497. first = 1;
  1498. psf_prev = NULL;
  1499. for (psf = *psf_list; psf; psf = psf_next) {
  1500. struct in6_addr *psrc;
  1501. psf_next = psf->sf_next;
  1502. if (!is_in(pmc, psf, type, gdeleted, sdeleted) && !crsend) {
  1503. psf_prev = psf;
  1504. continue;
  1505. }
  1506. /* Based on RFC3810 6.1. Should not send source-list change
  1507. * records when there is a filter mode change.
  1508. */
  1509. if (((gdeleted && pmc->mca_sfmode == MCAST_EXCLUDE) ||
  1510. (!gdeleted && pmc->mca_crcount)) &&
  1511. (type == MLD2_ALLOW_NEW_SOURCES ||
  1512. type == MLD2_BLOCK_OLD_SOURCES) && psf->sf_crcount)
  1513. goto decrease_sf_crcount;
  1514. /* clear marks on query responses */
  1515. if (isquery)
  1516. psf->sf_gsresp = 0;
  1517. if (AVAILABLE(skb) < sizeof(*psrc) +
  1518. first*sizeof(struct mld2_grec)) {
  1519. if (truncate && !first)
  1520. break; /* truncate these */
  1521. if (pgr)
  1522. pgr->grec_nsrcs = htons(scount);
  1523. if (skb)
  1524. mld_sendpack(skb);
  1525. skb = mld_newpack(idev, mtu);
  1526. first = 1;
  1527. scount = 0;
  1528. }
  1529. if (first) {
  1530. skb = add_grhead(skb, pmc, type, &pgr, mtu);
  1531. first = 0;
  1532. }
  1533. if (!skb)
  1534. return NULL;
  1535. psrc = skb_put(skb, sizeof(*psrc));
  1536. *psrc = psf->sf_addr;
  1537. scount++; stotal++;
  1538. if ((type == MLD2_ALLOW_NEW_SOURCES ||
  1539. type == MLD2_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
  1540. decrease_sf_crcount:
  1541. psf->sf_crcount--;
  1542. if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
  1543. if (psf_prev)
  1544. psf_prev->sf_next = psf->sf_next;
  1545. else
  1546. *psf_list = psf->sf_next;
  1547. kfree(psf);
  1548. continue;
  1549. }
  1550. }
  1551. psf_prev = psf;
  1552. }
  1553. empty_source:
  1554. if (!stotal) {
  1555. if (type == MLD2_ALLOW_NEW_SOURCES ||
  1556. type == MLD2_BLOCK_OLD_SOURCES)
  1557. return skb;
  1558. if (pmc->mca_crcount || isquery || crsend) {
  1559. /* make sure we have room for group header */
  1560. if (skb && AVAILABLE(skb) < sizeof(struct mld2_grec)) {
  1561. mld_sendpack(skb);
  1562. skb = NULL; /* add_grhead will get a new one */
  1563. }
  1564. skb = add_grhead(skb, pmc, type, &pgr, mtu);
  1565. }
  1566. }
  1567. if (pgr)
  1568. pgr->grec_nsrcs = htons(scount);
  1569. if (isquery)
  1570. pmc->mca_flags &= ~MAF_GSQUERY; /* clear query state */
  1571. return skb;
  1572. }
  1573. static void mld_send_report(struct inet6_dev *idev, struct ifmcaddr6 *pmc)
  1574. {
  1575. struct sk_buff *skb = NULL;
  1576. int type;
  1577. read_lock_bh(&idev->lock);
  1578. if (!pmc) {
  1579. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  1580. if (pmc->mca_flags & MAF_NOREPORT)
  1581. continue;
  1582. spin_lock_bh(&pmc->mca_lock);
  1583. if (pmc->mca_sfcount[MCAST_EXCLUDE])
  1584. type = MLD2_MODE_IS_EXCLUDE;
  1585. else
  1586. type = MLD2_MODE_IS_INCLUDE;
  1587. skb = add_grec(skb, pmc, type, 0, 0, 0);
  1588. spin_unlock_bh(&pmc->mca_lock);
  1589. }
  1590. } else {
  1591. spin_lock_bh(&pmc->mca_lock);
  1592. if (pmc->mca_sfcount[MCAST_EXCLUDE])
  1593. type = MLD2_MODE_IS_EXCLUDE;
  1594. else
  1595. type = MLD2_MODE_IS_INCLUDE;
  1596. skb = add_grec(skb, pmc, type, 0, 0, 0);
  1597. spin_unlock_bh(&pmc->mca_lock);
  1598. }
  1599. read_unlock_bh(&idev->lock);
  1600. if (skb)
  1601. mld_sendpack(skb);
  1602. }
  1603. /*
  1604. * remove zero-count source records from a source filter list
  1605. */
  1606. static void mld_clear_zeros(struct ip6_sf_list **ppsf)
  1607. {
  1608. struct ip6_sf_list *psf_prev, *psf_next, *psf;
  1609. psf_prev = NULL;
  1610. for (psf = *ppsf; psf; psf = psf_next) {
  1611. psf_next = psf->sf_next;
  1612. if (psf->sf_crcount == 0) {
  1613. if (psf_prev)
  1614. psf_prev->sf_next = psf->sf_next;
  1615. else
  1616. *ppsf = psf->sf_next;
  1617. kfree(psf);
  1618. } else
  1619. psf_prev = psf;
  1620. }
  1621. }
  1622. static void mld_send_cr(struct inet6_dev *idev)
  1623. {
  1624. struct ifmcaddr6 *pmc, *pmc_prev, *pmc_next;
  1625. struct sk_buff *skb = NULL;
  1626. int type, dtype;
  1627. read_lock_bh(&idev->lock);
  1628. spin_lock(&idev->mc_lock);
  1629. /* deleted MCA's */
  1630. pmc_prev = NULL;
  1631. for (pmc = idev->mc_tomb; pmc; pmc = pmc_next) {
  1632. pmc_next = pmc->next;
  1633. if (pmc->mca_sfmode == MCAST_INCLUDE) {
  1634. type = MLD2_BLOCK_OLD_SOURCES;
  1635. dtype = MLD2_BLOCK_OLD_SOURCES;
  1636. skb = add_grec(skb, pmc, type, 1, 0, 0);
  1637. skb = add_grec(skb, pmc, dtype, 1, 1, 0);
  1638. }
  1639. if (pmc->mca_crcount) {
  1640. if (pmc->mca_sfmode == MCAST_EXCLUDE) {
  1641. type = MLD2_CHANGE_TO_INCLUDE;
  1642. skb = add_grec(skb, pmc, type, 1, 0, 0);
  1643. }
  1644. pmc->mca_crcount--;
  1645. if (pmc->mca_crcount == 0) {
  1646. mld_clear_zeros(&pmc->mca_tomb);
  1647. mld_clear_zeros(&pmc->mca_sources);
  1648. }
  1649. }
  1650. if (pmc->mca_crcount == 0 && !pmc->mca_tomb &&
  1651. !pmc->mca_sources) {
  1652. if (pmc_prev)
  1653. pmc_prev->next = pmc_next;
  1654. else
  1655. idev->mc_tomb = pmc_next;
  1656. in6_dev_put(pmc->idev);
  1657. kfree(pmc);
  1658. } else
  1659. pmc_prev = pmc;
  1660. }
  1661. spin_unlock(&idev->mc_lock);
  1662. /* change recs */
  1663. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  1664. spin_lock_bh(&pmc->mca_lock);
  1665. if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
  1666. type = MLD2_BLOCK_OLD_SOURCES;
  1667. dtype = MLD2_ALLOW_NEW_SOURCES;
  1668. } else {
  1669. type = MLD2_ALLOW_NEW_SOURCES;
  1670. dtype = MLD2_BLOCK_OLD_SOURCES;
  1671. }
  1672. skb = add_grec(skb, pmc, type, 0, 0, 0);
  1673. skb = add_grec(skb, pmc, dtype, 0, 1, 0); /* deleted sources */
  1674. /* filter mode changes */
  1675. if (pmc->mca_crcount) {
  1676. if (pmc->mca_sfmode == MCAST_EXCLUDE)
  1677. type = MLD2_CHANGE_TO_EXCLUDE;
  1678. else
  1679. type = MLD2_CHANGE_TO_INCLUDE;
  1680. skb = add_grec(skb, pmc, type, 0, 0, 0);
  1681. pmc->mca_crcount--;
  1682. }
  1683. spin_unlock_bh(&pmc->mca_lock);
  1684. }
  1685. read_unlock_bh(&idev->lock);
  1686. if (!skb)
  1687. return;
  1688. (void) mld_sendpack(skb);
  1689. }
  1690. static void igmp6_send(struct in6_addr *addr, struct net_device *dev, int type)
  1691. {
  1692. struct net *net = dev_net(dev);
  1693. struct sock *sk = net->ipv6.igmp_sk;
  1694. struct inet6_dev *idev;
  1695. struct sk_buff *skb;
  1696. struct mld_msg *hdr;
  1697. const struct in6_addr *snd_addr, *saddr;
  1698. struct in6_addr addr_buf;
  1699. int hlen = LL_RESERVED_SPACE(dev);
  1700. int tlen = dev->needed_tailroom;
  1701. int err, len, payload_len, full_len;
  1702. u8 ra[8] = { IPPROTO_ICMPV6, 0,
  1703. IPV6_TLV_ROUTERALERT, 2, 0, 0,
  1704. IPV6_TLV_PADN, 0 };
  1705. struct flowi6 fl6;
  1706. struct dst_entry *dst;
  1707. if (type == ICMPV6_MGM_REDUCTION)
  1708. snd_addr = &in6addr_linklocal_allrouters;
  1709. else
  1710. snd_addr = addr;
  1711. len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
  1712. payload_len = len + sizeof(ra);
  1713. full_len = sizeof(struct ipv6hdr) + payload_len;
  1714. rcu_read_lock();
  1715. IP6_UPD_PO_STATS(net, __in6_dev_get(dev),
  1716. IPSTATS_MIB_OUT, full_len);
  1717. rcu_read_unlock();
  1718. skb = sock_alloc_send_skb(sk, hlen + tlen + full_len, 1, &err);
  1719. if (!skb) {
  1720. rcu_read_lock();
  1721. IP6_INC_STATS(net, __in6_dev_get(dev),
  1722. IPSTATS_MIB_OUTDISCARDS);
  1723. rcu_read_unlock();
  1724. return;
  1725. }
  1726. skb->priority = TC_PRIO_CONTROL;
  1727. skb_reserve(skb, hlen);
  1728. if (ipv6_get_lladdr(dev, &addr_buf, IFA_F_TENTATIVE)) {
  1729. /* <draft-ietf-magma-mld-source-05.txt>:
  1730. * use unspecified address as the source address
  1731. * when a valid link-local address is not available.
  1732. */
  1733. saddr = &in6addr_any;
  1734. } else
  1735. saddr = &addr_buf;
  1736. ip6_mc_hdr(sk, skb, dev, saddr, snd_addr, NEXTHDR_HOP, payload_len);
  1737. skb_put_data(skb, ra, sizeof(ra));
  1738. hdr = skb_put_zero(skb, sizeof(struct mld_msg));
  1739. hdr->mld_type = type;
  1740. hdr->mld_mca = *addr;
  1741. hdr->mld_cksum = csum_ipv6_magic(saddr, snd_addr, len,
  1742. IPPROTO_ICMPV6,
  1743. csum_partial(hdr, len, 0));
  1744. rcu_read_lock();
  1745. idev = __in6_dev_get(skb->dev);
  1746. icmpv6_flow_init(sk, &fl6, type,
  1747. &ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
  1748. skb->dev->ifindex);
  1749. dst = icmp6_dst_alloc(skb->dev, &fl6);
  1750. if (IS_ERR(dst)) {
  1751. err = PTR_ERR(dst);
  1752. goto err_out;
  1753. }
  1754. skb_dst_set(skb, dst);
  1755. err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
  1756. net, sk, skb, NULL, skb->dev,
  1757. dst_output);
  1758. out:
  1759. if (!err) {
  1760. ICMP6MSGOUT_INC_STATS(net, idev, type);
  1761. ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
  1762. } else
  1763. IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
  1764. rcu_read_unlock();
  1765. return;
  1766. err_out:
  1767. kfree_skb(skb);
  1768. goto out;
  1769. }
  1770. static void mld_send_initial_cr(struct inet6_dev *idev)
  1771. {
  1772. struct sk_buff *skb;
  1773. struct ifmcaddr6 *pmc;
  1774. int type;
  1775. if (mld_in_v1_mode(idev))
  1776. return;
  1777. skb = NULL;
  1778. read_lock_bh(&idev->lock);
  1779. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  1780. spin_lock_bh(&pmc->mca_lock);
  1781. if (pmc->mca_sfcount[MCAST_EXCLUDE])
  1782. type = MLD2_CHANGE_TO_EXCLUDE;
  1783. else
  1784. type = MLD2_ALLOW_NEW_SOURCES;
  1785. skb = add_grec(skb, pmc, type, 0, 0, 1);
  1786. spin_unlock_bh(&pmc->mca_lock);
  1787. }
  1788. read_unlock_bh(&idev->lock);
  1789. if (skb)
  1790. mld_sendpack(skb);
  1791. }
  1792. void ipv6_mc_dad_complete(struct inet6_dev *idev)
  1793. {
  1794. idev->mc_dad_count = idev->mc_qrv;
  1795. if (idev->mc_dad_count) {
  1796. mld_send_initial_cr(idev);
  1797. idev->mc_dad_count--;
  1798. if (idev->mc_dad_count)
  1799. mld_dad_start_timer(idev,
  1800. unsolicited_report_interval(idev));
  1801. }
  1802. }
  1803. static void mld_dad_timer_expire(struct timer_list *t)
  1804. {
  1805. struct inet6_dev *idev = from_timer(idev, t, mc_dad_timer);
  1806. mld_send_initial_cr(idev);
  1807. if (idev->mc_dad_count) {
  1808. idev->mc_dad_count--;
  1809. if (idev->mc_dad_count)
  1810. mld_dad_start_timer(idev,
  1811. unsolicited_report_interval(idev));
  1812. }
  1813. in6_dev_put(idev);
  1814. }
  1815. static int ip6_mc_del1_src(struct ifmcaddr6 *pmc, int sfmode,
  1816. const struct in6_addr *psfsrc)
  1817. {
  1818. struct ip6_sf_list *psf, *psf_prev;
  1819. int rv = 0;
  1820. psf_prev = NULL;
  1821. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  1822. if (ipv6_addr_equal(&psf->sf_addr, psfsrc))
  1823. break;
  1824. psf_prev = psf;
  1825. }
  1826. if (!psf || psf->sf_count[sfmode] == 0) {
  1827. /* source filter not found, or count wrong => bug */
  1828. return -ESRCH;
  1829. }
  1830. psf->sf_count[sfmode]--;
  1831. if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) {
  1832. struct inet6_dev *idev = pmc->idev;
  1833. /* no more filters for this source */
  1834. if (psf_prev)
  1835. psf_prev->sf_next = psf->sf_next;
  1836. else
  1837. pmc->mca_sources = psf->sf_next;
  1838. if (psf->sf_oldin && !(pmc->mca_flags & MAF_NOREPORT) &&
  1839. !mld_in_v1_mode(idev)) {
  1840. psf->sf_crcount = idev->mc_qrv;
  1841. psf->sf_next = pmc->mca_tomb;
  1842. pmc->mca_tomb = psf;
  1843. rv = 1;
  1844. } else
  1845. kfree(psf);
  1846. }
  1847. return rv;
  1848. }
  1849. static int ip6_mc_del_src(struct inet6_dev *idev, const struct in6_addr *pmca,
  1850. int sfmode, int sfcount, const struct in6_addr *psfsrc,
  1851. int delta)
  1852. {
  1853. struct ifmcaddr6 *pmc;
  1854. int changerec = 0;
  1855. int i, err;
  1856. if (!idev)
  1857. return -ENODEV;
  1858. read_lock_bh(&idev->lock);
  1859. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  1860. if (ipv6_addr_equal(pmca, &pmc->mca_addr))
  1861. break;
  1862. }
  1863. if (!pmc) {
  1864. /* MCA not found?? bug */
  1865. read_unlock_bh(&idev->lock);
  1866. return -ESRCH;
  1867. }
  1868. spin_lock_bh(&pmc->mca_lock);
  1869. sf_markstate(pmc);
  1870. if (!delta) {
  1871. if (!pmc->mca_sfcount[sfmode]) {
  1872. spin_unlock_bh(&pmc->mca_lock);
  1873. read_unlock_bh(&idev->lock);
  1874. return -EINVAL;
  1875. }
  1876. pmc->mca_sfcount[sfmode]--;
  1877. }
  1878. err = 0;
  1879. for (i = 0; i < sfcount; i++) {
  1880. int rv = ip6_mc_del1_src(pmc, sfmode, &psfsrc[i]);
  1881. changerec |= rv > 0;
  1882. if (!err && rv < 0)
  1883. err = rv;
  1884. }
  1885. if (pmc->mca_sfmode == MCAST_EXCLUDE &&
  1886. pmc->mca_sfcount[MCAST_EXCLUDE] == 0 &&
  1887. pmc->mca_sfcount[MCAST_INCLUDE]) {
  1888. struct ip6_sf_list *psf;
  1889. /* filter mode change */
  1890. pmc->mca_sfmode = MCAST_INCLUDE;
  1891. pmc->mca_crcount = idev->mc_qrv;
  1892. idev->mc_ifc_count = pmc->mca_crcount;
  1893. for (psf = pmc->mca_sources; psf; psf = psf->sf_next)
  1894. psf->sf_crcount = 0;
  1895. mld_ifc_event(pmc->idev);
  1896. } else if (sf_setstate(pmc) || changerec)
  1897. mld_ifc_event(pmc->idev);
  1898. spin_unlock_bh(&pmc->mca_lock);
  1899. read_unlock_bh(&idev->lock);
  1900. return err;
  1901. }
  1902. /*
  1903. * Add multicast single-source filter to the interface list
  1904. */
  1905. static int ip6_mc_add1_src(struct ifmcaddr6 *pmc, int sfmode,
  1906. const struct in6_addr *psfsrc)
  1907. {
  1908. struct ip6_sf_list *psf, *psf_prev;
  1909. psf_prev = NULL;
  1910. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  1911. if (ipv6_addr_equal(&psf->sf_addr, psfsrc))
  1912. break;
  1913. psf_prev = psf;
  1914. }
  1915. if (!psf) {
  1916. psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
  1917. if (!psf)
  1918. return -ENOBUFS;
  1919. psf->sf_addr = *psfsrc;
  1920. if (psf_prev) {
  1921. psf_prev->sf_next = psf;
  1922. } else
  1923. pmc->mca_sources = psf;
  1924. }
  1925. psf->sf_count[sfmode]++;
  1926. return 0;
  1927. }
  1928. static void sf_markstate(struct ifmcaddr6 *pmc)
  1929. {
  1930. struct ip6_sf_list *psf;
  1931. int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];
  1932. for (psf = pmc->mca_sources; psf; psf = psf->sf_next)
  1933. if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
  1934. psf->sf_oldin = mca_xcount ==
  1935. psf->sf_count[MCAST_EXCLUDE] &&
  1936. !psf->sf_count[MCAST_INCLUDE];
  1937. } else
  1938. psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0;
  1939. }
  1940. static int sf_setstate(struct ifmcaddr6 *pmc)
  1941. {
  1942. struct ip6_sf_list *psf, *dpsf;
  1943. int mca_xcount = pmc->mca_sfcount[MCAST_EXCLUDE];
  1944. int qrv = pmc->idev->mc_qrv;
  1945. int new_in, rv;
  1946. rv = 0;
  1947. for (psf = pmc->mca_sources; psf; psf = psf->sf_next) {
  1948. if (pmc->mca_sfcount[MCAST_EXCLUDE]) {
  1949. new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
  1950. !psf->sf_count[MCAST_INCLUDE];
  1951. } else
  1952. new_in = psf->sf_count[MCAST_INCLUDE] != 0;
  1953. if (new_in) {
  1954. if (!psf->sf_oldin) {
  1955. struct ip6_sf_list *prev = NULL;
  1956. for (dpsf = pmc->mca_tomb; dpsf;
  1957. dpsf = dpsf->sf_next) {
  1958. if (ipv6_addr_equal(&dpsf->sf_addr,
  1959. &psf->sf_addr))
  1960. break;
  1961. prev = dpsf;
  1962. }
  1963. if (dpsf) {
  1964. if (prev)
  1965. prev->sf_next = dpsf->sf_next;
  1966. else
  1967. pmc->mca_tomb = dpsf->sf_next;
  1968. kfree(dpsf);
  1969. }
  1970. psf->sf_crcount = qrv;
  1971. rv++;
  1972. }
  1973. } else if (psf->sf_oldin) {
  1974. psf->sf_crcount = 0;
  1975. /*
  1976. * add or update "delete" records if an active filter
  1977. * is now inactive
  1978. */
  1979. for (dpsf = pmc->mca_tomb; dpsf; dpsf = dpsf->sf_next)
  1980. if (ipv6_addr_equal(&dpsf->sf_addr,
  1981. &psf->sf_addr))
  1982. break;
  1983. if (!dpsf) {
  1984. dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC);
  1985. if (!dpsf)
  1986. continue;
  1987. *dpsf = *psf;
  1988. /* pmc->mca_lock held by callers */
  1989. dpsf->sf_next = pmc->mca_tomb;
  1990. pmc->mca_tomb = dpsf;
  1991. }
  1992. dpsf->sf_crcount = qrv;
  1993. rv++;
  1994. }
  1995. }
  1996. return rv;
  1997. }
  1998. /*
  1999. * Add multicast source filter list to the interface list
  2000. */
  2001. static int ip6_mc_add_src(struct inet6_dev *idev, const struct in6_addr *pmca,
  2002. int sfmode, int sfcount, const struct in6_addr *psfsrc,
  2003. int delta)
  2004. {
  2005. struct ifmcaddr6 *pmc;
  2006. int isexclude;
  2007. int i, err;
  2008. if (!idev)
  2009. return -ENODEV;
  2010. read_lock_bh(&idev->lock);
  2011. for (pmc = idev->mc_list; pmc; pmc = pmc->next) {
  2012. if (ipv6_addr_equal(pmca, &pmc->mca_addr))
  2013. break;
  2014. }
  2015. if (!pmc) {
  2016. /* MCA not found?? bug */
  2017. read_unlock_bh(&idev->lock);
  2018. return -ESRCH;
  2019. }
  2020. spin_lock_bh(&pmc->mca_lock);
  2021. sf_markstate(pmc);
  2022. isexclude = pmc->mca_sfmode == MCAST_EXCLUDE;
  2023. if (!delta)
  2024. pmc->mca_sfcount[sfmode]++;
  2025. err = 0;
  2026. for (i = 0; i < sfcount; i++) {
  2027. err = ip6_mc_add1_src(pmc, sfmode, &psfsrc[i]);
  2028. if (err)
  2029. break;
  2030. }
  2031. if (err) {
  2032. int j;
  2033. if (!delta)
  2034. pmc->mca_sfcount[sfmode]--;
  2035. for (j = 0; j < i; j++)
  2036. ip6_mc_del1_src(pmc, sfmode, &psfsrc[j]);
  2037. } else if (isexclude != (pmc->mca_sfcount[MCAST_EXCLUDE] != 0)) {
  2038. struct ip6_sf_list *psf;
  2039. /* filter mode change */
  2040. if (pmc->mca_sfcount[MCAST_EXCLUDE])
  2041. pmc->mca_sfmode = MCAST_EXCLUDE;
  2042. else if (pmc->mca_sfcount[MCAST_INCLUDE])
  2043. pmc->mca_sfmode = MCAST_INCLUDE;
  2044. /* else no filters; keep old mode for reports */
  2045. pmc->mca_crcount = idev->mc_qrv;
  2046. idev->mc_ifc_count = pmc->mca_crcount;
  2047. for (psf = pmc->mca_sources; psf; psf = psf->sf_next)
  2048. psf->sf_crcount = 0;
  2049. mld_ifc_event(idev);
  2050. } else if (sf_setstate(pmc))
  2051. mld_ifc_event(idev);
  2052. spin_unlock_bh(&pmc->mca_lock);
  2053. read_unlock_bh(&idev->lock);
  2054. return err;
  2055. }
  2056. static void ip6_mc_clear_src(struct ifmcaddr6 *pmc)
  2057. {
  2058. struct ip6_sf_list *psf, *nextpsf;
  2059. for (psf = pmc->mca_tomb; psf; psf = nextpsf) {
  2060. nextpsf = psf->sf_next;
  2061. kfree(psf);
  2062. }
  2063. pmc->mca_tomb = NULL;
  2064. for (psf = pmc->mca_sources; psf; psf = nextpsf) {
  2065. nextpsf = psf->sf_next;
  2066. kfree(psf);
  2067. }
  2068. pmc->mca_sources = NULL;
  2069. pmc->mca_sfmode = MCAST_EXCLUDE;
  2070. pmc->mca_sfcount[MCAST_INCLUDE] = 0;
  2071. pmc->mca_sfcount[MCAST_EXCLUDE] = 1;
  2072. }
  2073. static void igmp6_join_group(struct ifmcaddr6 *ma)
  2074. {
  2075. unsigned long delay;
  2076. if (ma->mca_flags & MAF_NOREPORT)
  2077. return;
  2078. igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT);
  2079. delay = prandom_u32() % unsolicited_report_interval(ma->idev);
  2080. spin_lock_bh(&ma->mca_lock);
  2081. if (del_timer(&ma->mca_timer)) {
  2082. refcount_dec(&ma->mca_refcnt);
  2083. delay = ma->mca_timer.expires - jiffies;
  2084. }
  2085. if (!mod_timer(&ma->mca_timer, jiffies + delay))
  2086. refcount_inc(&ma->mca_refcnt);
  2087. ma->mca_flags |= MAF_TIMER_RUNNING | MAF_LAST_REPORTER;
  2088. spin_unlock_bh(&ma->mca_lock);
  2089. }
  2090. static int ip6_mc_leave_src(struct sock *sk, struct ipv6_mc_socklist *iml,
  2091. struct inet6_dev *idev)
  2092. {
  2093. int err;
  2094. write_lock_bh(&iml->sflock);
  2095. if (!iml->sflist) {
  2096. /* any-source empty exclude case */
  2097. err = ip6_mc_del_src(idev, &iml->addr, iml->sfmode, 0, NULL, 0);
  2098. } else {
  2099. err = ip6_mc_del_src(idev, &iml->addr, iml->sfmode,
  2100. iml->sflist->sl_count, iml->sflist->sl_addr, 0);
  2101. sock_kfree_s(sk, iml->sflist, IP6_SFLSIZE(iml->sflist->sl_max));
  2102. iml->sflist = NULL;
  2103. }
  2104. write_unlock_bh(&iml->sflock);
  2105. return err;
  2106. }
  2107. static void igmp6_leave_group(struct ifmcaddr6 *ma)
  2108. {
  2109. if (mld_in_v1_mode(ma->idev)) {
  2110. if (ma->mca_flags & MAF_LAST_REPORTER)
  2111. igmp6_send(&ma->mca_addr, ma->idev->dev,
  2112. ICMPV6_MGM_REDUCTION);
  2113. } else {
  2114. mld_add_delrec(ma->idev, ma);
  2115. mld_ifc_event(ma->idev);
  2116. }
  2117. }
  2118. static void mld_gq_timer_expire(struct timer_list *t)
  2119. {
  2120. struct inet6_dev *idev = from_timer(idev, t, mc_gq_timer);
  2121. idev->mc_gq_running = 0;
  2122. mld_send_report(idev, NULL);
  2123. in6_dev_put(idev);
  2124. }
  2125. static void mld_ifc_timer_expire(struct timer_list *t)
  2126. {
  2127. struct inet6_dev *idev = from_timer(idev, t, mc_ifc_timer);
  2128. mld_send_cr(idev);
  2129. if (idev->mc_ifc_count) {
  2130. idev->mc_ifc_count--;
  2131. if (idev->mc_ifc_count)
  2132. mld_ifc_start_timer(idev,
  2133. unsolicited_report_interval(idev));
  2134. }
  2135. in6_dev_put(idev);
  2136. }
  2137. static void mld_ifc_event(struct inet6_dev *idev)
  2138. {
  2139. if (mld_in_v1_mode(idev))
  2140. return;
  2141. idev->mc_ifc_count = idev->mc_qrv;
  2142. mld_ifc_start_timer(idev, 1);
  2143. }
  2144. static void igmp6_timer_handler(struct timer_list *t)
  2145. {
  2146. struct ifmcaddr6 *ma = from_timer(ma, t, mca_timer);
  2147. if (mld_in_v1_mode(ma->idev))
  2148. igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT);
  2149. else
  2150. mld_send_report(ma->idev, ma);
  2151. spin_lock(&ma->mca_lock);
  2152. ma->mca_flags |= MAF_LAST_REPORTER;
  2153. ma->mca_flags &= ~MAF_TIMER_RUNNING;
  2154. spin_unlock(&ma->mca_lock);
  2155. ma_put(ma);
  2156. }
  2157. /* Device changing type */
  2158. void ipv6_mc_unmap(struct inet6_dev *idev)
  2159. {
  2160. struct ifmcaddr6 *i;
  2161. /* Install multicast list, except for all-nodes (already installed) */
  2162. read_lock_bh(&idev->lock);
  2163. for (i = idev->mc_list; i; i = i->next)
  2164. igmp6_group_dropped(i);
  2165. read_unlock_bh(&idev->lock);
  2166. }
  2167. void ipv6_mc_remap(struct inet6_dev *idev)
  2168. {
  2169. ipv6_mc_up(idev);
  2170. }
  2171. /* Device going down */
  2172. void ipv6_mc_down(struct inet6_dev *idev)
  2173. {
  2174. struct ifmcaddr6 *i;
  2175. /* Withdraw multicast list */
  2176. read_lock_bh(&idev->lock);
  2177. for (i = idev->mc_list; i; i = i->next)
  2178. igmp6_group_dropped(i);
  2179. /* Should stop timer after group drop. or we will
  2180. * start timer again in mld_ifc_event()
  2181. */
  2182. mld_ifc_stop_timer(idev);
  2183. mld_gq_stop_timer(idev);
  2184. mld_dad_stop_timer(idev);
  2185. read_unlock_bh(&idev->lock);
  2186. }
  2187. static void ipv6_mc_reset(struct inet6_dev *idev)
  2188. {
  2189. idev->mc_qrv = sysctl_mld_qrv;
  2190. idev->mc_qi = MLD_QI_DEFAULT;
  2191. idev->mc_qri = MLD_QRI_DEFAULT;
  2192. idev->mc_v1_seen = 0;
  2193. idev->mc_maxdelay = unsolicited_report_interval(idev);
  2194. }
  2195. /* Device going up */
  2196. void ipv6_mc_up(struct inet6_dev *idev)
  2197. {
  2198. struct ifmcaddr6 *i;
  2199. /* Install multicast list, except for all-nodes (already installed) */
  2200. read_lock_bh(&idev->lock);
  2201. ipv6_mc_reset(idev);
  2202. for (i = idev->mc_list; i; i = i->next) {
  2203. mld_del_delrec(idev, i);
  2204. igmp6_group_added(i);
  2205. }
  2206. read_unlock_bh(&idev->lock);
  2207. }
  2208. /* IPv6 device initialization. */
  2209. void ipv6_mc_init_dev(struct inet6_dev *idev)
  2210. {
  2211. write_lock_bh(&idev->lock);
  2212. spin_lock_init(&idev->mc_lock);
  2213. idev->mc_gq_running = 0;
  2214. timer_setup(&idev->mc_gq_timer, mld_gq_timer_expire, 0);
  2215. idev->mc_tomb = NULL;
  2216. idev->mc_ifc_count = 0;
  2217. timer_setup(&idev->mc_ifc_timer, mld_ifc_timer_expire, 0);
  2218. timer_setup(&idev->mc_dad_timer, mld_dad_timer_expire, 0);
  2219. ipv6_mc_reset(idev);
  2220. write_unlock_bh(&idev->lock);
  2221. }
  2222. /*
  2223. * Device is about to be destroyed: clean up.
  2224. */
  2225. void ipv6_mc_destroy_dev(struct inet6_dev *idev)
  2226. {
  2227. struct ifmcaddr6 *i;
  2228. /* Deactivate timers */
  2229. ipv6_mc_down(idev);
  2230. mld_clear_delrec(idev);
  2231. /* Delete all-nodes address. */
  2232. /* We cannot call ipv6_dev_mc_dec() directly, our caller in
  2233. * addrconf.c has NULL'd out dev->ip6_ptr so in6_dev_get() will
  2234. * fail.
  2235. */
  2236. __ipv6_dev_mc_dec(idev, &in6addr_linklocal_allnodes);
  2237. if (idev->cnf.forwarding)
  2238. __ipv6_dev_mc_dec(idev, &in6addr_linklocal_allrouters);
  2239. write_lock_bh(&idev->lock);
  2240. while ((i = idev->mc_list) != NULL) {
  2241. idev->mc_list = i->next;
  2242. write_unlock_bh(&idev->lock);
  2243. ip6_mc_clear_src(i);
  2244. ma_put(i);
  2245. write_lock_bh(&idev->lock);
  2246. }
  2247. write_unlock_bh(&idev->lock);
  2248. }
  2249. static void ipv6_mc_rejoin_groups(struct inet6_dev *idev)
  2250. {
  2251. struct ifmcaddr6 *pmc;
  2252. ASSERT_RTNL();
  2253. if (mld_in_v1_mode(idev)) {
  2254. read_lock_bh(&idev->lock);
  2255. for (pmc = idev->mc_list; pmc; pmc = pmc->next)
  2256. igmp6_join_group(pmc);
  2257. read_unlock_bh(&idev->lock);
  2258. } else
  2259. mld_send_report(idev, NULL);
  2260. }
  2261. static int ipv6_mc_netdev_event(struct notifier_block *this,
  2262. unsigned long event,
  2263. void *ptr)
  2264. {
  2265. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  2266. struct inet6_dev *idev = __in6_dev_get(dev);
  2267. switch (event) {
  2268. case NETDEV_RESEND_IGMP:
  2269. if (idev)
  2270. ipv6_mc_rejoin_groups(idev);
  2271. break;
  2272. default:
  2273. break;
  2274. }
  2275. return NOTIFY_DONE;
  2276. }
  2277. static struct notifier_block igmp6_netdev_notifier = {
  2278. .notifier_call = ipv6_mc_netdev_event,
  2279. };
  2280. #ifdef CONFIG_PROC_FS
  2281. struct igmp6_mc_iter_state {
  2282. struct seq_net_private p;
  2283. struct net_device *dev;
  2284. struct inet6_dev *idev;
  2285. };
  2286. #define igmp6_mc_seq_private(seq) ((struct igmp6_mc_iter_state *)(seq)->private)
  2287. static inline struct ifmcaddr6 *igmp6_mc_get_first(struct seq_file *seq)
  2288. {
  2289. struct ifmcaddr6 *im = NULL;
  2290. struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
  2291. struct net *net = seq_file_net(seq);
  2292. state->idev = NULL;
  2293. for_each_netdev_rcu(net, state->dev) {
  2294. struct inet6_dev *idev;
  2295. idev = __in6_dev_get(state->dev);
  2296. if (!idev)
  2297. continue;
  2298. read_lock_bh(&idev->lock);
  2299. im = idev->mc_list;
  2300. if (im) {
  2301. state->idev = idev;
  2302. break;
  2303. }
  2304. read_unlock_bh(&idev->lock);
  2305. }
  2306. return im;
  2307. }
  2308. static struct ifmcaddr6 *igmp6_mc_get_next(struct seq_file *seq, struct ifmcaddr6 *im)
  2309. {
  2310. struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
  2311. im = im->next;
  2312. while (!im) {
  2313. if (likely(state->idev))
  2314. read_unlock_bh(&state->idev->lock);
  2315. state->dev = next_net_device_rcu(state->dev);
  2316. if (!state->dev) {
  2317. state->idev = NULL;
  2318. break;
  2319. }
  2320. state->idev = __in6_dev_get(state->dev);
  2321. if (!state->idev)
  2322. continue;
  2323. read_lock_bh(&state->idev->lock);
  2324. im = state->idev->mc_list;
  2325. }
  2326. return im;
  2327. }
  2328. static struct ifmcaddr6 *igmp6_mc_get_idx(struct seq_file *seq, loff_t pos)
  2329. {
  2330. struct ifmcaddr6 *im = igmp6_mc_get_first(seq);
  2331. if (im)
  2332. while (pos && (im = igmp6_mc_get_next(seq, im)) != NULL)
  2333. --pos;
  2334. return pos ? NULL : im;
  2335. }
  2336. static void *igmp6_mc_seq_start(struct seq_file *seq, loff_t *pos)
  2337. __acquires(RCU)
  2338. {
  2339. rcu_read_lock();
  2340. return igmp6_mc_get_idx(seq, *pos);
  2341. }
  2342. static void *igmp6_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2343. {
  2344. struct ifmcaddr6 *im = igmp6_mc_get_next(seq, v);
  2345. ++*pos;
  2346. return im;
  2347. }
  2348. static void igmp6_mc_seq_stop(struct seq_file *seq, void *v)
  2349. __releases(RCU)
  2350. {
  2351. struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
  2352. if (likely(state->idev)) {
  2353. read_unlock_bh(&state->idev->lock);
  2354. state->idev = NULL;
  2355. }
  2356. state->dev = NULL;
  2357. rcu_read_unlock();
  2358. }
  2359. static int igmp6_mc_seq_show(struct seq_file *seq, void *v)
  2360. {
  2361. struct ifmcaddr6 *im = (struct ifmcaddr6 *)v;
  2362. struct igmp6_mc_iter_state *state = igmp6_mc_seq_private(seq);
  2363. seq_printf(seq,
  2364. "%-4d %-15s %pi6 %5d %08X %ld\n",
  2365. state->dev->ifindex, state->dev->name,
  2366. &im->mca_addr,
  2367. im->mca_users, im->mca_flags,
  2368. (im->mca_flags&MAF_TIMER_RUNNING) ?
  2369. jiffies_to_clock_t(im->mca_timer.expires-jiffies) : 0);
  2370. return 0;
  2371. }
  2372. static const struct seq_operations igmp6_mc_seq_ops = {
  2373. .start = igmp6_mc_seq_start,
  2374. .next = igmp6_mc_seq_next,
  2375. .stop = igmp6_mc_seq_stop,
  2376. .show = igmp6_mc_seq_show,
  2377. };
  2378. struct igmp6_mcf_iter_state {
  2379. struct seq_net_private p;
  2380. struct net_device *dev;
  2381. struct inet6_dev *idev;
  2382. struct ifmcaddr6 *im;
  2383. };
  2384. #define igmp6_mcf_seq_private(seq) ((struct igmp6_mcf_iter_state *)(seq)->private)
  2385. static inline struct ip6_sf_list *igmp6_mcf_get_first(struct seq_file *seq)
  2386. {
  2387. struct ip6_sf_list *psf = NULL;
  2388. struct ifmcaddr6 *im = NULL;
  2389. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
  2390. struct net *net = seq_file_net(seq);
  2391. state->idev = NULL;
  2392. state->im = NULL;
  2393. for_each_netdev_rcu(net, state->dev) {
  2394. struct inet6_dev *idev;
  2395. idev = __in6_dev_get(state->dev);
  2396. if (unlikely(idev == NULL))
  2397. continue;
  2398. read_lock_bh(&idev->lock);
  2399. im = idev->mc_list;
  2400. if (likely(im)) {
  2401. spin_lock_bh(&im->mca_lock);
  2402. psf = im->mca_sources;
  2403. if (likely(psf)) {
  2404. state->im = im;
  2405. state->idev = idev;
  2406. break;
  2407. }
  2408. spin_unlock_bh(&im->mca_lock);
  2409. }
  2410. read_unlock_bh(&idev->lock);
  2411. }
  2412. return psf;
  2413. }
  2414. static struct ip6_sf_list *igmp6_mcf_get_next(struct seq_file *seq, struct ip6_sf_list *psf)
  2415. {
  2416. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
  2417. psf = psf->sf_next;
  2418. while (!psf) {
  2419. spin_unlock_bh(&state->im->mca_lock);
  2420. state->im = state->im->next;
  2421. while (!state->im) {
  2422. if (likely(state->idev))
  2423. read_unlock_bh(&state->idev->lock);
  2424. state->dev = next_net_device_rcu(state->dev);
  2425. if (!state->dev) {
  2426. state->idev = NULL;
  2427. goto out;
  2428. }
  2429. state->idev = __in6_dev_get(state->dev);
  2430. if (!state->idev)
  2431. continue;
  2432. read_lock_bh(&state->idev->lock);
  2433. state->im = state->idev->mc_list;
  2434. }
  2435. if (!state->im)
  2436. break;
  2437. spin_lock_bh(&state->im->mca_lock);
  2438. psf = state->im->mca_sources;
  2439. }
  2440. out:
  2441. return psf;
  2442. }
  2443. static struct ip6_sf_list *igmp6_mcf_get_idx(struct seq_file *seq, loff_t pos)
  2444. {
  2445. struct ip6_sf_list *psf = igmp6_mcf_get_first(seq);
  2446. if (psf)
  2447. while (pos && (psf = igmp6_mcf_get_next(seq, psf)) != NULL)
  2448. --pos;
  2449. return pos ? NULL : psf;
  2450. }
  2451. static void *igmp6_mcf_seq_start(struct seq_file *seq, loff_t *pos)
  2452. __acquires(RCU)
  2453. {
  2454. rcu_read_lock();
  2455. return *pos ? igmp6_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  2456. }
  2457. static void *igmp6_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2458. {
  2459. struct ip6_sf_list *psf;
  2460. if (v == SEQ_START_TOKEN)
  2461. psf = igmp6_mcf_get_first(seq);
  2462. else
  2463. psf = igmp6_mcf_get_next(seq, v);
  2464. ++*pos;
  2465. return psf;
  2466. }
  2467. static void igmp6_mcf_seq_stop(struct seq_file *seq, void *v)
  2468. __releases(RCU)
  2469. {
  2470. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
  2471. if (likely(state->im)) {
  2472. spin_unlock_bh(&state->im->mca_lock);
  2473. state->im = NULL;
  2474. }
  2475. if (likely(state->idev)) {
  2476. read_unlock_bh(&state->idev->lock);
  2477. state->idev = NULL;
  2478. }
  2479. state->dev = NULL;
  2480. rcu_read_unlock();
  2481. }
  2482. static int igmp6_mcf_seq_show(struct seq_file *seq, void *v)
  2483. {
  2484. struct ip6_sf_list *psf = (struct ip6_sf_list *)v;
  2485. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq);
  2486. if (v == SEQ_START_TOKEN) {
  2487. seq_puts(seq, "Idx Device Multicast Address Source Address INC EXC\n");
  2488. } else {
  2489. seq_printf(seq,
  2490. "%3d %6.6s %pi6 %pi6 %6lu %6lu\n",
  2491. state->dev->ifindex, state->dev->name,
  2492. &state->im->mca_addr,
  2493. &psf->sf_addr,
  2494. psf->sf_count[MCAST_INCLUDE],
  2495. psf->sf_count[MCAST_EXCLUDE]);
  2496. }
  2497. return 0;
  2498. }
  2499. static const struct seq_operations igmp6_mcf_seq_ops = {
  2500. .start = igmp6_mcf_seq_start,
  2501. .next = igmp6_mcf_seq_next,
  2502. .stop = igmp6_mcf_seq_stop,
  2503. .show = igmp6_mcf_seq_show,
  2504. };
  2505. static int __net_init igmp6_proc_init(struct net *net)
  2506. {
  2507. int err;
  2508. err = -ENOMEM;
  2509. if (!proc_create_net("igmp6", 0444, net->proc_net, &igmp6_mc_seq_ops,
  2510. sizeof(struct igmp6_mc_iter_state)))
  2511. goto out;
  2512. if (!proc_create_net("mcfilter6", 0444, net->proc_net,
  2513. &igmp6_mcf_seq_ops,
  2514. sizeof(struct igmp6_mcf_iter_state)))
  2515. goto out_proc_net_igmp6;
  2516. err = 0;
  2517. out:
  2518. return err;
  2519. out_proc_net_igmp6:
  2520. remove_proc_entry("igmp6", net->proc_net);
  2521. goto out;
  2522. }
  2523. static void __net_exit igmp6_proc_exit(struct net *net)
  2524. {
  2525. remove_proc_entry("mcfilter6", net->proc_net);
  2526. remove_proc_entry("igmp6", net->proc_net);
  2527. }
  2528. #else
  2529. static inline int igmp6_proc_init(struct net *net)
  2530. {
  2531. return 0;
  2532. }
  2533. static inline void igmp6_proc_exit(struct net *net)
  2534. {
  2535. }
  2536. #endif
  2537. static int __net_init igmp6_net_init(struct net *net)
  2538. {
  2539. int err;
  2540. err = inet_ctl_sock_create(&net->ipv6.igmp_sk, PF_INET6,
  2541. SOCK_RAW, IPPROTO_ICMPV6, net);
  2542. if (err < 0) {
  2543. pr_err("Failed to initialize the IGMP6 control socket (err %d)\n",
  2544. err);
  2545. goto out;
  2546. }
  2547. inet6_sk(net->ipv6.igmp_sk)->hop_limit = 1;
  2548. err = inet_ctl_sock_create(&net->ipv6.mc_autojoin_sk, PF_INET6,
  2549. SOCK_RAW, IPPROTO_ICMPV6, net);
  2550. if (err < 0) {
  2551. pr_err("Failed to initialize the IGMP6 autojoin socket (err %d)\n",
  2552. err);
  2553. goto out_sock_create;
  2554. }
  2555. err = igmp6_proc_init(net);
  2556. if (err)
  2557. goto out_sock_create_autojoin;
  2558. return 0;
  2559. out_sock_create_autojoin:
  2560. inet_ctl_sock_destroy(net->ipv6.mc_autojoin_sk);
  2561. out_sock_create:
  2562. inet_ctl_sock_destroy(net->ipv6.igmp_sk);
  2563. out:
  2564. return err;
  2565. }
  2566. static void __net_exit igmp6_net_exit(struct net *net)
  2567. {
  2568. inet_ctl_sock_destroy(net->ipv6.igmp_sk);
  2569. inet_ctl_sock_destroy(net->ipv6.mc_autojoin_sk);
  2570. igmp6_proc_exit(net);
  2571. }
  2572. static struct pernet_operations igmp6_net_ops = {
  2573. .init = igmp6_net_init,
  2574. .exit = igmp6_net_exit,
  2575. };
  2576. int __init igmp6_init(void)
  2577. {
  2578. return register_pernet_subsys(&igmp6_net_ops);
  2579. }
  2580. int __init igmp6_late_init(void)
  2581. {
  2582. return register_netdevice_notifier(&igmp6_netdev_notifier);
  2583. }
  2584. void igmp6_cleanup(void)
  2585. {
  2586. unregister_pernet_subsys(&igmp6_net_ops);
  2587. }
  2588. void igmp6_late_cleanup(void)
  2589. {
  2590. unregister_netdevice_notifier(&igmp6_netdev_notifier);
  2591. }