igmp.c 74 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Linux NET3: Internet Group Management Protocol [IGMP]
  4. *
  5. * This code implements the IGMP protocol as defined in RFC1112. There has
  6. * been a further revision of this protocol since which is now supported.
  7. *
  8. * If you have trouble with this module be careful what gcc you have used,
  9. * the older version didn't come out right using gcc 2.5.8, the newer one
  10. * seems to fall out with gcc 2.6.2.
  11. *
  12. * Authors:
  13. * Alan Cox <[email protected]>
  14. *
  15. * Fixes:
  16. *
  17. * Alan Cox : Added lots of __inline__ to optimise
  18. * the memory usage of all the tiny little
  19. * functions.
  20. * Alan Cox : Dumped the header building experiment.
  21. * Alan Cox : Minor tweaks ready for multicast routing
  22. * and extended IGMP protocol.
  23. * Alan Cox : Removed a load of inline directives. Gcc 2.5.8
  24. * writes utterly bogus code otherwise (sigh)
  25. * fixed IGMP loopback to behave in the manner
  26. * desired by mrouted, fixed the fact it has been
  27. * broken since 1.3.6 and cleaned up a few minor
  28. * points.
  29. *
  30. * Chih-Jen Chang : Tried to revise IGMP to Version 2
  31. * Tsu-Sheng Tsao E-mail: [email protected] and [email protected]
  32. * The enhancements are mainly based on Steve Deering's
  33. * ipmulti-3.5 source code.
  34. * Chih-Jen Chang : Added the igmp_get_mrouter_info and
  35. * Tsu-Sheng Tsao igmp_set_mrouter_info to keep track of
  36. * the mrouted version on that device.
  37. * Chih-Jen Chang : Added the max_resp_time parameter to
  38. * Tsu-Sheng Tsao igmp_heard_query(). Using this parameter
  39. * to identify the multicast router version
  40. * and do what the IGMP version 2 specified.
  41. * Chih-Jen Chang : Added a timer to revert to IGMP V2 router
  42. * Tsu-Sheng Tsao if the specified time expired.
  43. * Alan Cox : Stop IGMP from 0.0.0.0 being accepted.
  44. * Alan Cox : Use GFP_ATOMIC in the right places.
  45. * Christian Daudt : igmp timer wasn't set for local group
  46. * memberships but was being deleted,
  47. * which caused a "del_timer() called
  48. * from %p with timer not initialized\n"
  49. * message (960131).
  50. * Christian Daudt : removed del_timer from
  51. * igmp_timer_expire function (960205).
  52. * Christian Daudt : igmp_heard_report now only calls
  53. * igmp_timer_expire if tm->running is
  54. * true (960216).
  55. * Malcolm Beattie : ttl comparison wrong in igmp_rcv made
  56. * igmp_heard_query never trigger. Expiry
  57. * miscalculation fixed in igmp_heard_query
  58. * and random() made to return unsigned to
  59. * prevent negative expiry times.
  60. * Alexey Kuznetsov: Wrong group leaving behaviour, backport
  61. * fix from pending 2.1.x patches.
  62. * Alan Cox: Forget to enable FDDI support earlier.
  63. * Alexey Kuznetsov: Fixed leaving groups on device down.
  64. * Alexey Kuznetsov: Accordance to igmp-v2-06 draft.
  65. * David L Stevens: IGMPv3 support, with help from
  66. * Vinay Kulkarni
  67. */
  68. #include <linux/module.h>
  69. #include <linux/slab.h>
  70. #include <linux/uaccess.h>
  71. #include <linux/types.h>
  72. #include <linux/kernel.h>
  73. #include <linux/jiffies.h>
  74. #include <linux/string.h>
  75. #include <linux/socket.h>
  76. #include <linux/sockios.h>
  77. #include <linux/in.h>
  78. #include <linux/inet.h>
  79. #include <linux/netdevice.h>
  80. #include <linux/skbuff.h>
  81. #include <linux/inetdevice.h>
  82. #include <linux/igmp.h>
  83. #include <linux/if_arp.h>
  84. #include <linux/rtnetlink.h>
  85. #include <linux/times.h>
  86. #include <linux/pkt_sched.h>
  87. #include <linux/byteorder/generic.h>
  88. #include <net/net_namespace.h>
  89. #include <net/arp.h>
  90. #include <net/ip.h>
  91. #include <net/protocol.h>
  92. #include <net/route.h>
  93. #include <net/sock.h>
  94. #include <net/checksum.h>
  95. #include <net/inet_common.h>
  96. #include <linux/netfilter_ipv4.h>
  97. #ifdef CONFIG_IP_MROUTE
  98. #include <linux/mroute.h>
  99. #endif
  100. #ifdef CONFIG_PROC_FS
  101. #include <linux/proc_fs.h>
  102. #include <linux/seq_file.h>
  103. #endif
  104. #ifdef CONFIG_IP_MULTICAST
  105. /* Parameter names and values are taken from igmp-v2-06 draft */
  106. #define IGMP_QUERY_INTERVAL (125*HZ)
  107. #define IGMP_QUERY_RESPONSE_INTERVAL (10*HZ)
  108. #define IGMP_INITIAL_REPORT_DELAY (1)
  109. /* IGMP_INITIAL_REPORT_DELAY is not from IGMP specs!
  110. * IGMP specs require to report membership immediately after
  111. * joining a group, but we delay the first report by a
  112. * small interval. It seems more natural and still does not
  113. * contradict to specs provided this delay is small enough.
  114. */
  115. #define IGMP_V1_SEEN(in_dev) \
  116. (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 1 || \
  117. IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 1 || \
  118. ((in_dev)->mr_v1_seen && \
  119. time_before(jiffies, (in_dev)->mr_v1_seen)))
  120. #define IGMP_V2_SEEN(in_dev) \
  121. (IPV4_DEVCONF_ALL(dev_net(in_dev->dev), FORCE_IGMP_VERSION) == 2 || \
  122. IN_DEV_CONF_GET((in_dev), FORCE_IGMP_VERSION) == 2 || \
  123. ((in_dev)->mr_v2_seen && \
  124. time_before(jiffies, (in_dev)->mr_v2_seen)))
  125. static int unsolicited_report_interval(struct in_device *in_dev)
  126. {
  127. int interval_ms, interval_jiffies;
  128. if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev))
  129. interval_ms = IN_DEV_CONF_GET(
  130. in_dev,
  131. IGMPV2_UNSOLICITED_REPORT_INTERVAL);
  132. else /* v3 */
  133. interval_ms = IN_DEV_CONF_GET(
  134. in_dev,
  135. IGMPV3_UNSOLICITED_REPORT_INTERVAL);
  136. interval_jiffies = msecs_to_jiffies(interval_ms);
  137. /* _timer functions can't handle a delay of 0 jiffies so ensure
  138. * we always return a positive value.
  139. */
  140. if (interval_jiffies <= 0)
  141. interval_jiffies = 1;
  142. return interval_jiffies;
  143. }
  144. static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im,
  145. gfp_t gfp);
  146. static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im);
  147. static void igmpv3_clear_delrec(struct in_device *in_dev);
  148. static int sf_setstate(struct ip_mc_list *pmc);
  149. static void sf_markstate(struct ip_mc_list *pmc);
  150. #endif
  151. static void ip_mc_clear_src(struct ip_mc_list *pmc);
  152. static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
  153. int sfcount, __be32 *psfsrc, int delta);
  154. static void ip_ma_put(struct ip_mc_list *im)
  155. {
  156. if (refcount_dec_and_test(&im->refcnt)) {
  157. in_dev_put(im->interface);
  158. kfree_rcu(im, rcu);
  159. }
  160. }
  161. #define for_each_pmc_rcu(in_dev, pmc) \
  162. for (pmc = rcu_dereference(in_dev->mc_list); \
  163. pmc != NULL; \
  164. pmc = rcu_dereference(pmc->next_rcu))
  165. #define for_each_pmc_rtnl(in_dev, pmc) \
  166. for (pmc = rtnl_dereference(in_dev->mc_list); \
  167. pmc != NULL; \
  168. pmc = rtnl_dereference(pmc->next_rcu))
  169. static void ip_sf_list_clear_all(struct ip_sf_list *psf)
  170. {
  171. struct ip_sf_list *next;
  172. while (psf) {
  173. next = psf->sf_next;
  174. kfree(psf);
  175. psf = next;
  176. }
  177. }
  178. #ifdef CONFIG_IP_MULTICAST
  179. /*
  180. * Timer management
  181. */
  182. static void igmp_stop_timer(struct ip_mc_list *im)
  183. {
  184. spin_lock_bh(&im->lock);
  185. if (del_timer(&im->timer))
  186. refcount_dec(&im->refcnt);
  187. im->tm_running = 0;
  188. im->reporter = 0;
  189. im->unsolicit_count = 0;
  190. spin_unlock_bh(&im->lock);
  191. }
  192. /* It must be called with locked im->lock */
  193. static void igmp_start_timer(struct ip_mc_list *im, int max_delay)
  194. {
  195. int tv = prandom_u32_max(max_delay);
  196. im->tm_running = 1;
  197. if (refcount_inc_not_zero(&im->refcnt)) {
  198. if (mod_timer(&im->timer, jiffies + tv + 2))
  199. ip_ma_put(im);
  200. }
  201. }
  202. static void igmp_gq_start_timer(struct in_device *in_dev)
  203. {
  204. int tv = prandom_u32_max(in_dev->mr_maxdelay);
  205. unsigned long exp = jiffies + tv + 2;
  206. if (in_dev->mr_gq_running &&
  207. time_after_eq(exp, (in_dev->mr_gq_timer).expires))
  208. return;
  209. in_dev->mr_gq_running = 1;
  210. if (!mod_timer(&in_dev->mr_gq_timer, exp))
  211. in_dev_hold(in_dev);
  212. }
  213. static void igmp_ifc_start_timer(struct in_device *in_dev, int delay)
  214. {
  215. int tv = prandom_u32_max(delay);
  216. if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2))
  217. in_dev_hold(in_dev);
  218. }
  219. static void igmp_mod_timer(struct ip_mc_list *im, int max_delay)
  220. {
  221. spin_lock_bh(&im->lock);
  222. im->unsolicit_count = 0;
  223. if (del_timer(&im->timer)) {
  224. if ((long)(im->timer.expires-jiffies) < max_delay) {
  225. add_timer(&im->timer);
  226. im->tm_running = 1;
  227. spin_unlock_bh(&im->lock);
  228. return;
  229. }
  230. refcount_dec(&im->refcnt);
  231. }
  232. igmp_start_timer(im, max_delay);
  233. spin_unlock_bh(&im->lock);
  234. }
  235. /*
  236. * Send an IGMP report.
  237. */
  238. #define IGMP_SIZE (sizeof(struct igmphdr)+sizeof(struct iphdr)+4)
  239. static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,
  240. int gdeleted, int sdeleted)
  241. {
  242. switch (type) {
  243. case IGMPV3_MODE_IS_INCLUDE:
  244. case IGMPV3_MODE_IS_EXCLUDE:
  245. if (gdeleted || sdeleted)
  246. return 0;
  247. if (!(pmc->gsquery && !psf->sf_gsresp)) {
  248. if (pmc->sfmode == MCAST_INCLUDE)
  249. return 1;
  250. /* don't include if this source is excluded
  251. * in all filters
  252. */
  253. if (psf->sf_count[MCAST_INCLUDE])
  254. return type == IGMPV3_MODE_IS_INCLUDE;
  255. return pmc->sfcount[MCAST_EXCLUDE] ==
  256. psf->sf_count[MCAST_EXCLUDE];
  257. }
  258. return 0;
  259. case IGMPV3_CHANGE_TO_INCLUDE:
  260. if (gdeleted || sdeleted)
  261. return 0;
  262. return psf->sf_count[MCAST_INCLUDE] != 0;
  263. case IGMPV3_CHANGE_TO_EXCLUDE:
  264. if (gdeleted || sdeleted)
  265. return 0;
  266. if (pmc->sfcount[MCAST_EXCLUDE] == 0 ||
  267. psf->sf_count[MCAST_INCLUDE])
  268. return 0;
  269. return pmc->sfcount[MCAST_EXCLUDE] ==
  270. psf->sf_count[MCAST_EXCLUDE];
  271. case IGMPV3_ALLOW_NEW_SOURCES:
  272. if (gdeleted || !psf->sf_crcount)
  273. return 0;
  274. return (pmc->sfmode == MCAST_INCLUDE) ^ sdeleted;
  275. case IGMPV3_BLOCK_OLD_SOURCES:
  276. if (pmc->sfmode == MCAST_INCLUDE)
  277. return gdeleted || (psf->sf_crcount && sdeleted);
  278. return psf->sf_crcount && !gdeleted && !sdeleted;
  279. }
  280. return 0;
  281. }
  282. static int
  283. igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted)
  284. {
  285. struct ip_sf_list *psf;
  286. int scount = 0;
  287. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  288. if (!is_in(pmc, psf, type, gdeleted, sdeleted))
  289. continue;
  290. scount++;
  291. }
  292. return scount;
  293. }
  294. /* source address selection per RFC 3376 section 4.2.13 */
  295. static __be32 igmpv3_get_srcaddr(struct net_device *dev,
  296. const struct flowi4 *fl4)
  297. {
  298. struct in_device *in_dev = __in_dev_get_rcu(dev);
  299. const struct in_ifaddr *ifa;
  300. if (!in_dev)
  301. return htonl(INADDR_ANY);
  302. in_dev_for_each_ifa_rcu(ifa, in_dev) {
  303. if (fl4->saddr == ifa->ifa_local)
  304. return fl4->saddr;
  305. }
  306. return htonl(INADDR_ANY);
  307. }
  308. static struct sk_buff *igmpv3_newpack(struct net_device *dev, unsigned int mtu)
  309. {
  310. struct sk_buff *skb;
  311. struct rtable *rt;
  312. struct iphdr *pip;
  313. struct igmpv3_report *pig;
  314. struct net *net = dev_net(dev);
  315. struct flowi4 fl4;
  316. int hlen = LL_RESERVED_SPACE(dev);
  317. int tlen = dev->needed_tailroom;
  318. unsigned int size;
  319. size = min(mtu, IP_MAX_MTU);
  320. while (1) {
  321. skb = alloc_skb(size + hlen + tlen,
  322. GFP_ATOMIC | __GFP_NOWARN);
  323. if (skb)
  324. break;
  325. size >>= 1;
  326. if (size < 256)
  327. return NULL;
  328. }
  329. skb->priority = TC_PRIO_CONTROL;
  330. rt = ip_route_output_ports(net, &fl4, NULL, IGMPV3_ALL_MCR, 0,
  331. 0, 0,
  332. IPPROTO_IGMP, 0, dev->ifindex);
  333. if (IS_ERR(rt)) {
  334. kfree_skb(skb);
  335. return NULL;
  336. }
  337. skb_dst_set(skb, &rt->dst);
  338. skb->dev = dev;
  339. skb_reserve(skb, hlen);
  340. skb_tailroom_reserve(skb, mtu, tlen);
  341. skb_reset_network_header(skb);
  342. pip = ip_hdr(skb);
  343. skb_put(skb, sizeof(struct iphdr) + 4);
  344. pip->version = 4;
  345. pip->ihl = (sizeof(struct iphdr)+4)>>2;
  346. pip->tos = 0xc0;
  347. pip->frag_off = htons(IP_DF);
  348. pip->ttl = 1;
  349. pip->daddr = fl4.daddr;
  350. rcu_read_lock();
  351. pip->saddr = igmpv3_get_srcaddr(dev, &fl4);
  352. rcu_read_unlock();
  353. pip->protocol = IPPROTO_IGMP;
  354. pip->tot_len = 0; /* filled in later */
  355. ip_select_ident(net, skb, NULL);
  356. ((u8 *)&pip[1])[0] = IPOPT_RA;
  357. ((u8 *)&pip[1])[1] = 4;
  358. ((u8 *)&pip[1])[2] = 0;
  359. ((u8 *)&pip[1])[3] = 0;
  360. skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4;
  361. skb_put(skb, sizeof(*pig));
  362. pig = igmpv3_report_hdr(skb);
  363. pig->type = IGMPV3_HOST_MEMBERSHIP_REPORT;
  364. pig->resv1 = 0;
  365. pig->csum = 0;
  366. pig->resv2 = 0;
  367. pig->ngrec = 0;
  368. return skb;
  369. }
  370. static int igmpv3_sendpack(struct sk_buff *skb)
  371. {
  372. struct igmphdr *pig = igmp_hdr(skb);
  373. const int igmplen = skb_tail_pointer(skb) - skb_transport_header(skb);
  374. pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen);
  375. return ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
  376. }
  377. static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)
  378. {
  379. return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);
  380. }
  381. static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc,
  382. int type, struct igmpv3_grec **ppgr, unsigned int mtu)
  383. {
  384. struct net_device *dev = pmc->interface->dev;
  385. struct igmpv3_report *pih;
  386. struct igmpv3_grec *pgr;
  387. if (!skb) {
  388. skb = igmpv3_newpack(dev, mtu);
  389. if (!skb)
  390. return NULL;
  391. }
  392. pgr = skb_put(skb, sizeof(struct igmpv3_grec));
  393. pgr->grec_type = type;
  394. pgr->grec_auxwords = 0;
  395. pgr->grec_nsrcs = 0;
  396. pgr->grec_mca = pmc->multiaddr;
  397. pih = igmpv3_report_hdr(skb);
  398. pih->ngrec = htons(ntohs(pih->ngrec)+1);
  399. *ppgr = pgr;
  400. return skb;
  401. }
  402. #define AVAILABLE(skb) ((skb) ? skb_availroom(skb) : 0)
  403. static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
  404. int type, int gdeleted, int sdeleted)
  405. {
  406. struct net_device *dev = pmc->interface->dev;
  407. struct net *net = dev_net(dev);
  408. struct igmpv3_report *pih;
  409. struct igmpv3_grec *pgr = NULL;
  410. struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list;
  411. int scount, stotal, first, isquery, truncate;
  412. unsigned int mtu;
  413. if (pmc->multiaddr == IGMP_ALL_HOSTS)
  414. return skb;
  415. if (ipv4_is_local_multicast(pmc->multiaddr) &&
  416. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  417. return skb;
  418. mtu = READ_ONCE(dev->mtu);
  419. if (mtu < IPV4_MIN_MTU)
  420. return skb;
  421. isquery = type == IGMPV3_MODE_IS_INCLUDE ||
  422. type == IGMPV3_MODE_IS_EXCLUDE;
  423. truncate = type == IGMPV3_MODE_IS_EXCLUDE ||
  424. type == IGMPV3_CHANGE_TO_EXCLUDE;
  425. stotal = scount = 0;
  426. psf_list = sdeleted ? &pmc->tomb : &pmc->sources;
  427. if (!*psf_list)
  428. goto empty_source;
  429. pih = skb ? igmpv3_report_hdr(skb) : NULL;
  430. /* EX and TO_EX get a fresh packet, if needed */
  431. if (truncate) {
  432. if (pih && pih->ngrec &&
  433. AVAILABLE(skb) < grec_size(pmc, type, gdeleted, sdeleted)) {
  434. if (skb)
  435. igmpv3_sendpack(skb);
  436. skb = igmpv3_newpack(dev, mtu);
  437. }
  438. }
  439. first = 1;
  440. psf_prev = NULL;
  441. for (psf = *psf_list; psf; psf = psf_next) {
  442. __be32 *psrc;
  443. psf_next = psf->sf_next;
  444. if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {
  445. psf_prev = psf;
  446. continue;
  447. }
  448. /* Based on RFC3376 5.1. Should not send source-list change
  449. * records when there is a filter mode change.
  450. */
  451. if (((gdeleted && pmc->sfmode == MCAST_EXCLUDE) ||
  452. (!gdeleted && pmc->crcount)) &&
  453. (type == IGMPV3_ALLOW_NEW_SOURCES ||
  454. type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount)
  455. goto decrease_sf_crcount;
  456. /* clear marks on query responses */
  457. if (isquery)
  458. psf->sf_gsresp = 0;
  459. if (AVAILABLE(skb) < sizeof(__be32) +
  460. first*sizeof(struct igmpv3_grec)) {
  461. if (truncate && !first)
  462. break; /* truncate these */
  463. if (pgr)
  464. pgr->grec_nsrcs = htons(scount);
  465. if (skb)
  466. igmpv3_sendpack(skb);
  467. skb = igmpv3_newpack(dev, mtu);
  468. first = 1;
  469. scount = 0;
  470. }
  471. if (first) {
  472. skb = add_grhead(skb, pmc, type, &pgr, mtu);
  473. first = 0;
  474. }
  475. if (!skb)
  476. return NULL;
  477. psrc = skb_put(skb, sizeof(__be32));
  478. *psrc = psf->sf_inaddr;
  479. scount++; stotal++;
  480. if ((type == IGMPV3_ALLOW_NEW_SOURCES ||
  481. type == IGMPV3_BLOCK_OLD_SOURCES) && psf->sf_crcount) {
  482. decrease_sf_crcount:
  483. psf->sf_crcount--;
  484. if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
  485. if (psf_prev)
  486. psf_prev->sf_next = psf->sf_next;
  487. else
  488. *psf_list = psf->sf_next;
  489. kfree(psf);
  490. continue;
  491. }
  492. }
  493. psf_prev = psf;
  494. }
  495. empty_source:
  496. if (!stotal) {
  497. if (type == IGMPV3_ALLOW_NEW_SOURCES ||
  498. type == IGMPV3_BLOCK_OLD_SOURCES)
  499. return skb;
  500. if (pmc->crcount || isquery) {
  501. /* make sure we have room for group header */
  502. if (skb && AVAILABLE(skb) < sizeof(struct igmpv3_grec)) {
  503. igmpv3_sendpack(skb);
  504. skb = NULL; /* add_grhead will get a new one */
  505. }
  506. skb = add_grhead(skb, pmc, type, &pgr, mtu);
  507. }
  508. }
  509. if (pgr)
  510. pgr->grec_nsrcs = htons(scount);
  511. if (isquery)
  512. pmc->gsquery = 0; /* clear query state on report */
  513. return skb;
  514. }
  515. static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc)
  516. {
  517. struct sk_buff *skb = NULL;
  518. struct net *net = dev_net(in_dev->dev);
  519. int type;
  520. if (!pmc) {
  521. rcu_read_lock();
  522. for_each_pmc_rcu(in_dev, pmc) {
  523. if (pmc->multiaddr == IGMP_ALL_HOSTS)
  524. continue;
  525. if (ipv4_is_local_multicast(pmc->multiaddr) &&
  526. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  527. continue;
  528. spin_lock_bh(&pmc->lock);
  529. if (pmc->sfcount[MCAST_EXCLUDE])
  530. type = IGMPV3_MODE_IS_EXCLUDE;
  531. else
  532. type = IGMPV3_MODE_IS_INCLUDE;
  533. skb = add_grec(skb, pmc, type, 0, 0);
  534. spin_unlock_bh(&pmc->lock);
  535. }
  536. rcu_read_unlock();
  537. } else {
  538. spin_lock_bh(&pmc->lock);
  539. if (pmc->sfcount[MCAST_EXCLUDE])
  540. type = IGMPV3_MODE_IS_EXCLUDE;
  541. else
  542. type = IGMPV3_MODE_IS_INCLUDE;
  543. skb = add_grec(skb, pmc, type, 0, 0);
  544. spin_unlock_bh(&pmc->lock);
  545. }
  546. if (!skb)
  547. return 0;
  548. return igmpv3_sendpack(skb);
  549. }
  550. /*
  551. * remove zero-count source records from a source filter list
  552. */
  553. static void igmpv3_clear_zeros(struct ip_sf_list **ppsf)
  554. {
  555. struct ip_sf_list *psf_prev, *psf_next, *psf;
  556. psf_prev = NULL;
  557. for (psf = *ppsf; psf; psf = psf_next) {
  558. psf_next = psf->sf_next;
  559. if (psf->sf_crcount == 0) {
  560. if (psf_prev)
  561. psf_prev->sf_next = psf->sf_next;
  562. else
  563. *ppsf = psf->sf_next;
  564. kfree(psf);
  565. } else
  566. psf_prev = psf;
  567. }
  568. }
  569. static void kfree_pmc(struct ip_mc_list *pmc)
  570. {
  571. ip_sf_list_clear_all(pmc->sources);
  572. ip_sf_list_clear_all(pmc->tomb);
  573. kfree(pmc);
  574. }
  575. static void igmpv3_send_cr(struct in_device *in_dev)
  576. {
  577. struct ip_mc_list *pmc, *pmc_prev, *pmc_next;
  578. struct sk_buff *skb = NULL;
  579. int type, dtype;
  580. rcu_read_lock();
  581. spin_lock_bh(&in_dev->mc_tomb_lock);
  582. /* deleted MCA's */
  583. pmc_prev = NULL;
  584. for (pmc = in_dev->mc_tomb; pmc; pmc = pmc_next) {
  585. pmc_next = pmc->next;
  586. if (pmc->sfmode == MCAST_INCLUDE) {
  587. type = IGMPV3_BLOCK_OLD_SOURCES;
  588. dtype = IGMPV3_BLOCK_OLD_SOURCES;
  589. skb = add_grec(skb, pmc, type, 1, 0);
  590. skb = add_grec(skb, pmc, dtype, 1, 1);
  591. }
  592. if (pmc->crcount) {
  593. if (pmc->sfmode == MCAST_EXCLUDE) {
  594. type = IGMPV3_CHANGE_TO_INCLUDE;
  595. skb = add_grec(skb, pmc, type, 1, 0);
  596. }
  597. pmc->crcount--;
  598. if (pmc->crcount == 0) {
  599. igmpv3_clear_zeros(&pmc->tomb);
  600. igmpv3_clear_zeros(&pmc->sources);
  601. }
  602. }
  603. if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) {
  604. if (pmc_prev)
  605. pmc_prev->next = pmc_next;
  606. else
  607. in_dev->mc_tomb = pmc_next;
  608. in_dev_put(pmc->interface);
  609. kfree_pmc(pmc);
  610. } else
  611. pmc_prev = pmc;
  612. }
  613. spin_unlock_bh(&in_dev->mc_tomb_lock);
  614. /* change recs */
  615. for_each_pmc_rcu(in_dev, pmc) {
  616. spin_lock_bh(&pmc->lock);
  617. if (pmc->sfcount[MCAST_EXCLUDE]) {
  618. type = IGMPV3_BLOCK_OLD_SOURCES;
  619. dtype = IGMPV3_ALLOW_NEW_SOURCES;
  620. } else {
  621. type = IGMPV3_ALLOW_NEW_SOURCES;
  622. dtype = IGMPV3_BLOCK_OLD_SOURCES;
  623. }
  624. skb = add_grec(skb, pmc, type, 0, 0);
  625. skb = add_grec(skb, pmc, dtype, 0, 1); /* deleted sources */
  626. /* filter mode changes */
  627. if (pmc->crcount) {
  628. if (pmc->sfmode == MCAST_EXCLUDE)
  629. type = IGMPV3_CHANGE_TO_EXCLUDE;
  630. else
  631. type = IGMPV3_CHANGE_TO_INCLUDE;
  632. skb = add_grec(skb, pmc, type, 0, 0);
  633. pmc->crcount--;
  634. }
  635. spin_unlock_bh(&pmc->lock);
  636. }
  637. rcu_read_unlock();
  638. if (!skb)
  639. return;
  640. (void) igmpv3_sendpack(skb);
  641. }
  642. static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
  643. int type)
  644. {
  645. struct sk_buff *skb;
  646. struct iphdr *iph;
  647. struct igmphdr *ih;
  648. struct rtable *rt;
  649. struct net_device *dev = in_dev->dev;
  650. struct net *net = dev_net(dev);
  651. __be32 group = pmc ? pmc->multiaddr : 0;
  652. struct flowi4 fl4;
  653. __be32 dst;
  654. int hlen, tlen;
  655. if (type == IGMPV3_HOST_MEMBERSHIP_REPORT)
  656. return igmpv3_send_report(in_dev, pmc);
  657. if (ipv4_is_local_multicast(group) &&
  658. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  659. return 0;
  660. if (type == IGMP_HOST_LEAVE_MESSAGE)
  661. dst = IGMP_ALL_ROUTER;
  662. else
  663. dst = group;
  664. rt = ip_route_output_ports(net, &fl4, NULL, dst, 0,
  665. 0, 0,
  666. IPPROTO_IGMP, 0, dev->ifindex);
  667. if (IS_ERR(rt))
  668. return -1;
  669. hlen = LL_RESERVED_SPACE(dev);
  670. tlen = dev->needed_tailroom;
  671. skb = alloc_skb(IGMP_SIZE + hlen + tlen, GFP_ATOMIC);
  672. if (!skb) {
  673. ip_rt_put(rt);
  674. return -1;
  675. }
  676. skb->priority = TC_PRIO_CONTROL;
  677. skb_dst_set(skb, &rt->dst);
  678. skb_reserve(skb, hlen);
  679. skb_reset_network_header(skb);
  680. iph = ip_hdr(skb);
  681. skb_put(skb, sizeof(struct iphdr) + 4);
  682. iph->version = 4;
  683. iph->ihl = (sizeof(struct iphdr)+4)>>2;
  684. iph->tos = 0xc0;
  685. iph->frag_off = htons(IP_DF);
  686. iph->ttl = 1;
  687. iph->daddr = dst;
  688. iph->saddr = fl4.saddr;
  689. iph->protocol = IPPROTO_IGMP;
  690. ip_select_ident(net, skb, NULL);
  691. ((u8 *)&iph[1])[0] = IPOPT_RA;
  692. ((u8 *)&iph[1])[1] = 4;
  693. ((u8 *)&iph[1])[2] = 0;
  694. ((u8 *)&iph[1])[3] = 0;
  695. ih = skb_put(skb, sizeof(struct igmphdr));
  696. ih->type = type;
  697. ih->code = 0;
  698. ih->csum = 0;
  699. ih->group = group;
  700. ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
  701. return ip_local_out(net, skb->sk, skb);
  702. }
  703. static void igmp_gq_timer_expire(struct timer_list *t)
  704. {
  705. struct in_device *in_dev = from_timer(in_dev, t, mr_gq_timer);
  706. in_dev->mr_gq_running = 0;
  707. igmpv3_send_report(in_dev, NULL);
  708. in_dev_put(in_dev);
  709. }
  710. static void igmp_ifc_timer_expire(struct timer_list *t)
  711. {
  712. struct in_device *in_dev = from_timer(in_dev, t, mr_ifc_timer);
  713. u32 mr_ifc_count;
  714. igmpv3_send_cr(in_dev);
  715. restart:
  716. mr_ifc_count = READ_ONCE(in_dev->mr_ifc_count);
  717. if (mr_ifc_count) {
  718. if (cmpxchg(&in_dev->mr_ifc_count,
  719. mr_ifc_count,
  720. mr_ifc_count - 1) != mr_ifc_count)
  721. goto restart;
  722. igmp_ifc_start_timer(in_dev,
  723. unsolicited_report_interval(in_dev));
  724. }
  725. in_dev_put(in_dev);
  726. }
  727. static void igmp_ifc_event(struct in_device *in_dev)
  728. {
  729. struct net *net = dev_net(in_dev->dev);
  730. if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev))
  731. return;
  732. WRITE_ONCE(in_dev->mr_ifc_count, in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv));
  733. igmp_ifc_start_timer(in_dev, 1);
  734. }
  735. static void igmp_timer_expire(struct timer_list *t)
  736. {
  737. struct ip_mc_list *im = from_timer(im, t, timer);
  738. struct in_device *in_dev = im->interface;
  739. spin_lock(&im->lock);
  740. im->tm_running = 0;
  741. if (im->unsolicit_count && --im->unsolicit_count)
  742. igmp_start_timer(im, unsolicited_report_interval(in_dev));
  743. im->reporter = 1;
  744. spin_unlock(&im->lock);
  745. if (IGMP_V1_SEEN(in_dev))
  746. igmp_send_report(in_dev, im, IGMP_HOST_MEMBERSHIP_REPORT);
  747. else if (IGMP_V2_SEEN(in_dev))
  748. igmp_send_report(in_dev, im, IGMPV2_HOST_MEMBERSHIP_REPORT);
  749. else
  750. igmp_send_report(in_dev, im, IGMPV3_HOST_MEMBERSHIP_REPORT);
  751. ip_ma_put(im);
  752. }
  753. /* mark EXCLUDE-mode sources */
  754. static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
  755. {
  756. struct ip_sf_list *psf;
  757. int i, scount;
  758. scount = 0;
  759. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  760. if (scount == nsrcs)
  761. break;
  762. for (i = 0; i < nsrcs; i++) {
  763. /* skip inactive filters */
  764. if (psf->sf_count[MCAST_INCLUDE] ||
  765. pmc->sfcount[MCAST_EXCLUDE] !=
  766. psf->sf_count[MCAST_EXCLUDE])
  767. break;
  768. if (srcs[i] == psf->sf_inaddr) {
  769. scount++;
  770. break;
  771. }
  772. }
  773. }
  774. pmc->gsquery = 0;
  775. if (scount == nsrcs) /* all sources excluded */
  776. return 0;
  777. return 1;
  778. }
  779. static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
  780. {
  781. struct ip_sf_list *psf;
  782. int i, scount;
  783. if (pmc->sfmode == MCAST_EXCLUDE)
  784. return igmp_xmarksources(pmc, nsrcs, srcs);
  785. /* mark INCLUDE-mode sources */
  786. scount = 0;
  787. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  788. if (scount == nsrcs)
  789. break;
  790. for (i = 0; i < nsrcs; i++)
  791. if (srcs[i] == psf->sf_inaddr) {
  792. psf->sf_gsresp = 1;
  793. scount++;
  794. break;
  795. }
  796. }
  797. if (!scount) {
  798. pmc->gsquery = 0;
  799. return 0;
  800. }
  801. pmc->gsquery = 1;
  802. return 1;
  803. }
  804. /* return true if packet was dropped */
  805. static bool igmp_heard_report(struct in_device *in_dev, __be32 group)
  806. {
  807. struct ip_mc_list *im;
  808. struct net *net = dev_net(in_dev->dev);
  809. /* Timers are only set for non-local groups */
  810. if (group == IGMP_ALL_HOSTS)
  811. return false;
  812. if (ipv4_is_local_multicast(group) &&
  813. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  814. return false;
  815. rcu_read_lock();
  816. for_each_pmc_rcu(in_dev, im) {
  817. if (im->multiaddr == group) {
  818. igmp_stop_timer(im);
  819. break;
  820. }
  821. }
  822. rcu_read_unlock();
  823. return false;
  824. }
  825. /* return true if packet was dropped */
  826. static bool igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
  827. int len)
  828. {
  829. struct igmphdr *ih = igmp_hdr(skb);
  830. struct igmpv3_query *ih3 = igmpv3_query_hdr(skb);
  831. struct ip_mc_list *im;
  832. __be32 group = ih->group;
  833. int max_delay;
  834. int mark = 0;
  835. struct net *net = dev_net(in_dev->dev);
  836. if (len == 8) {
  837. if (ih->code == 0) {
  838. /* Alas, old v1 router presents here. */
  839. max_delay = IGMP_QUERY_RESPONSE_INTERVAL;
  840. in_dev->mr_v1_seen = jiffies +
  841. (in_dev->mr_qrv * in_dev->mr_qi) +
  842. in_dev->mr_qri;
  843. group = 0;
  844. } else {
  845. /* v2 router present */
  846. max_delay = ih->code*(HZ/IGMP_TIMER_SCALE);
  847. in_dev->mr_v2_seen = jiffies +
  848. (in_dev->mr_qrv * in_dev->mr_qi) +
  849. in_dev->mr_qri;
  850. }
  851. /* cancel the interface change timer */
  852. WRITE_ONCE(in_dev->mr_ifc_count, 0);
  853. if (del_timer(&in_dev->mr_ifc_timer))
  854. __in_dev_put(in_dev);
  855. /* clear deleted report items */
  856. igmpv3_clear_delrec(in_dev);
  857. } else if (len < 12) {
  858. return true; /* ignore bogus packet; freed by caller */
  859. } else if (IGMP_V1_SEEN(in_dev)) {
  860. /* This is a v3 query with v1 queriers present */
  861. max_delay = IGMP_QUERY_RESPONSE_INTERVAL;
  862. group = 0;
  863. } else if (IGMP_V2_SEEN(in_dev)) {
  864. /* this is a v3 query with v2 queriers present;
  865. * Interpretation of the max_delay code is problematic here.
  866. * A real v2 host would use ih_code directly, while v3 has a
  867. * different encoding. We use the v3 encoding as more likely
  868. * to be intended in a v3 query.
  869. */
  870. max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
  871. if (!max_delay)
  872. max_delay = 1; /* can't mod w/ 0 */
  873. } else { /* v3 */
  874. if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
  875. return true;
  876. ih3 = igmpv3_query_hdr(skb);
  877. if (ih3->nsrcs) {
  878. if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)
  879. + ntohs(ih3->nsrcs)*sizeof(__be32)))
  880. return true;
  881. ih3 = igmpv3_query_hdr(skb);
  882. }
  883. max_delay = IGMPV3_MRC(ih3->code)*(HZ/IGMP_TIMER_SCALE);
  884. if (!max_delay)
  885. max_delay = 1; /* can't mod w/ 0 */
  886. in_dev->mr_maxdelay = max_delay;
  887. /* RFC3376, 4.1.6. QRV and 4.1.7. QQIC, when the most recently
  888. * received value was zero, use the default or statically
  889. * configured value.
  890. */
  891. in_dev->mr_qrv = ih3->qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  892. in_dev->mr_qi = IGMPV3_QQIC(ih3->qqic)*HZ ?: IGMP_QUERY_INTERVAL;
  893. /* RFC3376, 8.3. Query Response Interval:
  894. * The number of seconds represented by the [Query Response
  895. * Interval] must be less than the [Query Interval].
  896. */
  897. if (in_dev->mr_qri >= in_dev->mr_qi)
  898. in_dev->mr_qri = (in_dev->mr_qi/HZ - 1)*HZ;
  899. if (!group) { /* general query */
  900. if (ih3->nsrcs)
  901. return true; /* no sources allowed */
  902. igmp_gq_start_timer(in_dev);
  903. return false;
  904. }
  905. /* mark sources to include, if group & source-specific */
  906. mark = ih3->nsrcs != 0;
  907. }
  908. /*
  909. * - Start the timers in all of our membership records
  910. * that the query applies to for the interface on
  911. * which the query arrived excl. those that belong
  912. * to a "local" group (224.0.0.X)
  913. * - For timers already running check if they need to
  914. * be reset.
  915. * - Use the igmp->igmp_code field as the maximum
  916. * delay possible
  917. */
  918. rcu_read_lock();
  919. for_each_pmc_rcu(in_dev, im) {
  920. int changed;
  921. if (group && group != im->multiaddr)
  922. continue;
  923. if (im->multiaddr == IGMP_ALL_HOSTS)
  924. continue;
  925. if (ipv4_is_local_multicast(im->multiaddr) &&
  926. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  927. continue;
  928. spin_lock_bh(&im->lock);
  929. if (im->tm_running)
  930. im->gsquery = im->gsquery && mark;
  931. else
  932. im->gsquery = mark;
  933. changed = !im->gsquery ||
  934. igmp_marksources(im, ntohs(ih3->nsrcs), ih3->srcs);
  935. spin_unlock_bh(&im->lock);
  936. if (changed)
  937. igmp_mod_timer(im, max_delay);
  938. }
  939. rcu_read_unlock();
  940. return false;
  941. }
  942. /* called in rcu_read_lock() section */
  943. int igmp_rcv(struct sk_buff *skb)
  944. {
  945. /* This basically follows the spec line by line -- see RFC1112 */
  946. struct igmphdr *ih;
  947. struct net_device *dev = skb->dev;
  948. struct in_device *in_dev;
  949. int len = skb->len;
  950. bool dropped = true;
  951. if (netif_is_l3_master(dev)) {
  952. dev = dev_get_by_index_rcu(dev_net(dev), IPCB(skb)->iif);
  953. if (!dev)
  954. goto drop;
  955. }
  956. in_dev = __in_dev_get_rcu(dev);
  957. if (!in_dev)
  958. goto drop;
  959. if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
  960. goto drop;
  961. if (skb_checksum_simple_validate(skb))
  962. goto drop;
  963. ih = igmp_hdr(skb);
  964. switch (ih->type) {
  965. case IGMP_HOST_MEMBERSHIP_QUERY:
  966. dropped = igmp_heard_query(in_dev, skb, len);
  967. break;
  968. case IGMP_HOST_MEMBERSHIP_REPORT:
  969. case IGMPV2_HOST_MEMBERSHIP_REPORT:
  970. /* Is it our report looped back? */
  971. if (rt_is_output_route(skb_rtable(skb)))
  972. break;
  973. /* don't rely on MC router hearing unicast reports */
  974. if (skb->pkt_type == PACKET_MULTICAST ||
  975. skb->pkt_type == PACKET_BROADCAST)
  976. dropped = igmp_heard_report(in_dev, ih->group);
  977. break;
  978. case IGMP_PIM:
  979. #ifdef CONFIG_IP_PIMSM_V1
  980. return pim_rcv_v1(skb);
  981. #endif
  982. case IGMPV3_HOST_MEMBERSHIP_REPORT:
  983. case IGMP_DVMRP:
  984. case IGMP_TRACE:
  985. case IGMP_HOST_LEAVE_MESSAGE:
  986. case IGMP_MTRACE:
  987. case IGMP_MTRACE_RESP:
  988. break;
  989. default:
  990. break;
  991. }
  992. drop:
  993. if (dropped)
  994. kfree_skb(skb);
  995. else
  996. consume_skb(skb);
  997. return 0;
  998. }
  999. #endif
  1000. /*
  1001. * Add a filter to a device
  1002. */
  1003. static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
  1004. {
  1005. char buf[MAX_ADDR_LEN];
  1006. struct net_device *dev = in_dev->dev;
  1007. /* Checking for IFF_MULTICAST here is WRONG-WRONG-WRONG.
  1008. We will get multicast token leakage, when IFF_MULTICAST
  1009. is changed. This check should be done in ndo_set_rx_mode
  1010. routine. Something sort of:
  1011. if (dev->mc_list && dev->flags&IFF_MULTICAST) { do it; }
  1012. --ANK
  1013. */
  1014. if (arp_mc_map(addr, buf, dev, 0) == 0)
  1015. dev_mc_add(dev, buf);
  1016. }
  1017. /*
  1018. * Remove a filter from a device
  1019. */
  1020. static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
  1021. {
  1022. char buf[MAX_ADDR_LEN];
  1023. struct net_device *dev = in_dev->dev;
  1024. if (arp_mc_map(addr, buf, dev, 0) == 0)
  1025. dev_mc_del(dev, buf);
  1026. }
  1027. #ifdef CONFIG_IP_MULTICAST
  1028. /*
  1029. * deleted ip_mc_list manipulation
  1030. */
  1031. static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im,
  1032. gfp_t gfp)
  1033. {
  1034. struct ip_mc_list *pmc;
  1035. struct net *net = dev_net(in_dev->dev);
  1036. /* this is an "ip_mc_list" for convenience; only the fields below
  1037. * are actually used. In particular, the refcnt and users are not
  1038. * used for management of the delete list. Using the same structure
  1039. * for deleted items allows change reports to use common code with
  1040. * non-deleted or query-response MCA's.
  1041. */
  1042. pmc = kzalloc(sizeof(*pmc), gfp);
  1043. if (!pmc)
  1044. return;
  1045. spin_lock_init(&pmc->lock);
  1046. spin_lock_bh(&im->lock);
  1047. pmc->interface = im->interface;
  1048. in_dev_hold(in_dev);
  1049. pmc->multiaddr = im->multiaddr;
  1050. pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1051. pmc->sfmode = im->sfmode;
  1052. if (pmc->sfmode == MCAST_INCLUDE) {
  1053. struct ip_sf_list *psf;
  1054. pmc->tomb = im->tomb;
  1055. pmc->sources = im->sources;
  1056. im->tomb = im->sources = NULL;
  1057. for (psf = pmc->sources; psf; psf = psf->sf_next)
  1058. psf->sf_crcount = pmc->crcount;
  1059. }
  1060. spin_unlock_bh(&im->lock);
  1061. spin_lock_bh(&in_dev->mc_tomb_lock);
  1062. pmc->next = in_dev->mc_tomb;
  1063. in_dev->mc_tomb = pmc;
  1064. spin_unlock_bh(&in_dev->mc_tomb_lock);
  1065. }
  1066. /*
  1067. * restore ip_mc_list deleted records
  1068. */
  1069. static void igmpv3_del_delrec(struct in_device *in_dev, struct ip_mc_list *im)
  1070. {
  1071. struct ip_mc_list *pmc, *pmc_prev;
  1072. struct ip_sf_list *psf;
  1073. struct net *net = dev_net(in_dev->dev);
  1074. __be32 multiaddr = im->multiaddr;
  1075. spin_lock_bh(&in_dev->mc_tomb_lock);
  1076. pmc_prev = NULL;
  1077. for (pmc = in_dev->mc_tomb; pmc; pmc = pmc->next) {
  1078. if (pmc->multiaddr == multiaddr)
  1079. break;
  1080. pmc_prev = pmc;
  1081. }
  1082. if (pmc) {
  1083. if (pmc_prev)
  1084. pmc_prev->next = pmc->next;
  1085. else
  1086. in_dev->mc_tomb = pmc->next;
  1087. }
  1088. spin_unlock_bh(&in_dev->mc_tomb_lock);
  1089. spin_lock_bh(&im->lock);
  1090. if (pmc) {
  1091. im->interface = pmc->interface;
  1092. if (im->sfmode == MCAST_INCLUDE) {
  1093. swap(im->tomb, pmc->tomb);
  1094. swap(im->sources, pmc->sources);
  1095. for (psf = im->sources; psf; psf = psf->sf_next)
  1096. psf->sf_crcount = in_dev->mr_qrv ?:
  1097. READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1098. } else {
  1099. im->crcount = in_dev->mr_qrv ?:
  1100. READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1101. }
  1102. in_dev_put(pmc->interface);
  1103. kfree_pmc(pmc);
  1104. }
  1105. spin_unlock_bh(&im->lock);
  1106. }
  1107. /*
  1108. * flush ip_mc_list deleted records
  1109. */
  1110. static void igmpv3_clear_delrec(struct in_device *in_dev)
  1111. {
  1112. struct ip_mc_list *pmc, *nextpmc;
  1113. spin_lock_bh(&in_dev->mc_tomb_lock);
  1114. pmc = in_dev->mc_tomb;
  1115. in_dev->mc_tomb = NULL;
  1116. spin_unlock_bh(&in_dev->mc_tomb_lock);
  1117. for (; pmc; pmc = nextpmc) {
  1118. nextpmc = pmc->next;
  1119. ip_mc_clear_src(pmc);
  1120. in_dev_put(pmc->interface);
  1121. kfree_pmc(pmc);
  1122. }
  1123. /* clear dead sources, too */
  1124. rcu_read_lock();
  1125. for_each_pmc_rcu(in_dev, pmc) {
  1126. struct ip_sf_list *psf;
  1127. spin_lock_bh(&pmc->lock);
  1128. psf = pmc->tomb;
  1129. pmc->tomb = NULL;
  1130. spin_unlock_bh(&pmc->lock);
  1131. ip_sf_list_clear_all(psf);
  1132. }
  1133. rcu_read_unlock();
  1134. }
  1135. #endif
  1136. static void __igmp_group_dropped(struct ip_mc_list *im, gfp_t gfp)
  1137. {
  1138. struct in_device *in_dev = im->interface;
  1139. #ifdef CONFIG_IP_MULTICAST
  1140. struct net *net = dev_net(in_dev->dev);
  1141. int reporter;
  1142. #endif
  1143. if (im->loaded) {
  1144. im->loaded = 0;
  1145. ip_mc_filter_del(in_dev, im->multiaddr);
  1146. }
  1147. #ifdef CONFIG_IP_MULTICAST
  1148. if (im->multiaddr == IGMP_ALL_HOSTS)
  1149. return;
  1150. if (ipv4_is_local_multicast(im->multiaddr) &&
  1151. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  1152. return;
  1153. reporter = im->reporter;
  1154. igmp_stop_timer(im);
  1155. if (!in_dev->dead) {
  1156. if (IGMP_V1_SEEN(in_dev))
  1157. return;
  1158. if (IGMP_V2_SEEN(in_dev)) {
  1159. if (reporter)
  1160. igmp_send_report(in_dev, im, IGMP_HOST_LEAVE_MESSAGE);
  1161. return;
  1162. }
  1163. /* IGMPv3 */
  1164. igmpv3_add_delrec(in_dev, im, gfp);
  1165. igmp_ifc_event(in_dev);
  1166. }
  1167. #endif
  1168. }
  1169. static void igmp_group_dropped(struct ip_mc_list *im)
  1170. {
  1171. __igmp_group_dropped(im, GFP_KERNEL);
  1172. }
  1173. static void igmp_group_added(struct ip_mc_list *im)
  1174. {
  1175. struct in_device *in_dev = im->interface;
  1176. #ifdef CONFIG_IP_MULTICAST
  1177. struct net *net = dev_net(in_dev->dev);
  1178. #endif
  1179. if (im->loaded == 0) {
  1180. im->loaded = 1;
  1181. ip_mc_filter_add(in_dev, im->multiaddr);
  1182. }
  1183. #ifdef CONFIG_IP_MULTICAST
  1184. if (im->multiaddr == IGMP_ALL_HOSTS)
  1185. return;
  1186. if (ipv4_is_local_multicast(im->multiaddr) &&
  1187. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  1188. return;
  1189. if (in_dev->dead)
  1190. return;
  1191. im->unsolicit_count = READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1192. if (IGMP_V1_SEEN(in_dev) || IGMP_V2_SEEN(in_dev)) {
  1193. spin_lock_bh(&im->lock);
  1194. igmp_start_timer(im, IGMP_INITIAL_REPORT_DELAY);
  1195. spin_unlock_bh(&im->lock);
  1196. return;
  1197. }
  1198. /* else, v3 */
  1199. /* Based on RFC3376 5.1, for newly added INCLUDE SSM, we should
  1200. * not send filter-mode change record as the mode should be from
  1201. * IN() to IN(A).
  1202. */
  1203. if (im->sfmode == MCAST_EXCLUDE)
  1204. im->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1205. igmp_ifc_event(in_dev);
  1206. #endif
  1207. }
  1208. /*
  1209. * Multicast list managers
  1210. */
  1211. static u32 ip_mc_hash(const struct ip_mc_list *im)
  1212. {
  1213. return hash_32((__force u32)im->multiaddr, MC_HASH_SZ_LOG);
  1214. }
  1215. static void ip_mc_hash_add(struct in_device *in_dev,
  1216. struct ip_mc_list *im)
  1217. {
  1218. struct ip_mc_list __rcu **mc_hash;
  1219. u32 hash;
  1220. mc_hash = rtnl_dereference(in_dev->mc_hash);
  1221. if (mc_hash) {
  1222. hash = ip_mc_hash(im);
  1223. im->next_hash = mc_hash[hash];
  1224. rcu_assign_pointer(mc_hash[hash], im);
  1225. return;
  1226. }
  1227. /* do not use a hash table for small number of items */
  1228. if (in_dev->mc_count < 4)
  1229. return;
  1230. mc_hash = kzalloc(sizeof(struct ip_mc_list *) << MC_HASH_SZ_LOG,
  1231. GFP_KERNEL);
  1232. if (!mc_hash)
  1233. return;
  1234. for_each_pmc_rtnl(in_dev, im) {
  1235. hash = ip_mc_hash(im);
  1236. im->next_hash = mc_hash[hash];
  1237. RCU_INIT_POINTER(mc_hash[hash], im);
  1238. }
  1239. rcu_assign_pointer(in_dev->mc_hash, mc_hash);
  1240. }
  1241. static void ip_mc_hash_remove(struct in_device *in_dev,
  1242. struct ip_mc_list *im)
  1243. {
  1244. struct ip_mc_list __rcu **mc_hash = rtnl_dereference(in_dev->mc_hash);
  1245. struct ip_mc_list *aux;
  1246. if (!mc_hash)
  1247. return;
  1248. mc_hash += ip_mc_hash(im);
  1249. while ((aux = rtnl_dereference(*mc_hash)) != im)
  1250. mc_hash = &aux->next_hash;
  1251. *mc_hash = im->next_hash;
  1252. }
  1253. /*
  1254. * A socket has joined a multicast group on device dev.
  1255. */
  1256. static void ____ip_mc_inc_group(struct in_device *in_dev, __be32 addr,
  1257. unsigned int mode, gfp_t gfp)
  1258. {
  1259. struct ip_mc_list *im;
  1260. ASSERT_RTNL();
  1261. for_each_pmc_rtnl(in_dev, im) {
  1262. if (im->multiaddr == addr) {
  1263. im->users++;
  1264. ip_mc_add_src(in_dev, &addr, mode, 0, NULL, 0);
  1265. goto out;
  1266. }
  1267. }
  1268. im = kzalloc(sizeof(*im), gfp);
  1269. if (!im)
  1270. goto out;
  1271. im->users = 1;
  1272. im->interface = in_dev;
  1273. in_dev_hold(in_dev);
  1274. im->multiaddr = addr;
  1275. /* initial mode is (EX, empty) */
  1276. im->sfmode = mode;
  1277. im->sfcount[mode] = 1;
  1278. refcount_set(&im->refcnt, 1);
  1279. spin_lock_init(&im->lock);
  1280. #ifdef CONFIG_IP_MULTICAST
  1281. timer_setup(&im->timer, igmp_timer_expire, 0);
  1282. #endif
  1283. im->next_rcu = in_dev->mc_list;
  1284. in_dev->mc_count++;
  1285. rcu_assign_pointer(in_dev->mc_list, im);
  1286. ip_mc_hash_add(in_dev, im);
  1287. #ifdef CONFIG_IP_MULTICAST
  1288. igmpv3_del_delrec(in_dev, im);
  1289. #endif
  1290. igmp_group_added(im);
  1291. if (!in_dev->dead)
  1292. ip_rt_multicast_event(in_dev);
  1293. out:
  1294. return;
  1295. }
  1296. void __ip_mc_inc_group(struct in_device *in_dev, __be32 addr, gfp_t gfp)
  1297. {
  1298. ____ip_mc_inc_group(in_dev, addr, MCAST_EXCLUDE, gfp);
  1299. }
  1300. EXPORT_SYMBOL(__ip_mc_inc_group);
  1301. void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
  1302. {
  1303. __ip_mc_inc_group(in_dev, addr, GFP_KERNEL);
  1304. }
  1305. EXPORT_SYMBOL(ip_mc_inc_group);
  1306. static int ip_mc_check_iphdr(struct sk_buff *skb)
  1307. {
  1308. const struct iphdr *iph;
  1309. unsigned int len;
  1310. unsigned int offset = skb_network_offset(skb) + sizeof(*iph);
  1311. if (!pskb_may_pull(skb, offset))
  1312. return -EINVAL;
  1313. iph = ip_hdr(skb);
  1314. if (iph->version != 4 || ip_hdrlen(skb) < sizeof(*iph))
  1315. return -EINVAL;
  1316. offset += ip_hdrlen(skb) - sizeof(*iph);
  1317. if (!pskb_may_pull(skb, offset))
  1318. return -EINVAL;
  1319. iph = ip_hdr(skb);
  1320. if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
  1321. return -EINVAL;
  1322. len = skb_network_offset(skb) + ntohs(iph->tot_len);
  1323. if (skb->len < len || len < offset)
  1324. return -EINVAL;
  1325. skb_set_transport_header(skb, offset);
  1326. return 0;
  1327. }
  1328. static int ip_mc_check_igmp_reportv3(struct sk_buff *skb)
  1329. {
  1330. unsigned int len = skb_transport_offset(skb);
  1331. len += sizeof(struct igmpv3_report);
  1332. return ip_mc_may_pull(skb, len) ? 0 : -EINVAL;
  1333. }
  1334. static int ip_mc_check_igmp_query(struct sk_buff *skb)
  1335. {
  1336. unsigned int transport_len = ip_transport_len(skb);
  1337. unsigned int len;
  1338. /* IGMPv{1,2}? */
  1339. if (transport_len != sizeof(struct igmphdr)) {
  1340. /* or IGMPv3? */
  1341. if (transport_len < sizeof(struct igmpv3_query))
  1342. return -EINVAL;
  1343. len = skb_transport_offset(skb) + sizeof(struct igmpv3_query);
  1344. if (!ip_mc_may_pull(skb, len))
  1345. return -EINVAL;
  1346. }
  1347. /* RFC2236+RFC3376 (IGMPv2+IGMPv3) require the multicast link layer
  1348. * all-systems destination addresses (224.0.0.1) for general queries
  1349. */
  1350. if (!igmp_hdr(skb)->group &&
  1351. ip_hdr(skb)->daddr != htonl(INADDR_ALLHOSTS_GROUP))
  1352. return -EINVAL;
  1353. return 0;
  1354. }
  1355. static int ip_mc_check_igmp_msg(struct sk_buff *skb)
  1356. {
  1357. switch (igmp_hdr(skb)->type) {
  1358. case IGMP_HOST_LEAVE_MESSAGE:
  1359. case IGMP_HOST_MEMBERSHIP_REPORT:
  1360. case IGMPV2_HOST_MEMBERSHIP_REPORT:
  1361. return 0;
  1362. case IGMPV3_HOST_MEMBERSHIP_REPORT:
  1363. return ip_mc_check_igmp_reportv3(skb);
  1364. case IGMP_HOST_MEMBERSHIP_QUERY:
  1365. return ip_mc_check_igmp_query(skb);
  1366. default:
  1367. return -ENOMSG;
  1368. }
  1369. }
  1370. static __sum16 ip_mc_validate_checksum(struct sk_buff *skb)
  1371. {
  1372. return skb_checksum_simple_validate(skb);
  1373. }
  1374. static int ip_mc_check_igmp_csum(struct sk_buff *skb)
  1375. {
  1376. unsigned int len = skb_transport_offset(skb) + sizeof(struct igmphdr);
  1377. unsigned int transport_len = ip_transport_len(skb);
  1378. struct sk_buff *skb_chk;
  1379. if (!ip_mc_may_pull(skb, len))
  1380. return -EINVAL;
  1381. skb_chk = skb_checksum_trimmed(skb, transport_len,
  1382. ip_mc_validate_checksum);
  1383. if (!skb_chk)
  1384. return -EINVAL;
  1385. if (skb_chk != skb)
  1386. kfree_skb(skb_chk);
  1387. return 0;
  1388. }
  1389. /**
  1390. * ip_mc_check_igmp - checks whether this is a sane IGMP packet
  1391. * @skb: the skb to validate
  1392. *
  1393. * Checks whether an IPv4 packet is a valid IGMP packet. If so sets
  1394. * skb transport header accordingly and returns zero.
  1395. *
  1396. * -EINVAL: A broken packet was detected, i.e. it violates some internet
  1397. * standard
  1398. * -ENOMSG: IP header validation succeeded but it is not an IGMP packet.
  1399. * -ENOMEM: A memory allocation failure happened.
  1400. *
  1401. * Caller needs to set the skb network header and free any returned skb if it
  1402. * differs from the provided skb.
  1403. */
  1404. int ip_mc_check_igmp(struct sk_buff *skb)
  1405. {
  1406. int ret = ip_mc_check_iphdr(skb);
  1407. if (ret < 0)
  1408. return ret;
  1409. if (ip_hdr(skb)->protocol != IPPROTO_IGMP)
  1410. return -ENOMSG;
  1411. ret = ip_mc_check_igmp_csum(skb);
  1412. if (ret < 0)
  1413. return ret;
  1414. return ip_mc_check_igmp_msg(skb);
  1415. }
  1416. EXPORT_SYMBOL(ip_mc_check_igmp);
  1417. /*
  1418. * Resend IGMP JOIN report; used by netdev notifier.
  1419. */
  1420. static void ip_mc_rejoin_groups(struct in_device *in_dev)
  1421. {
  1422. #ifdef CONFIG_IP_MULTICAST
  1423. struct ip_mc_list *im;
  1424. int type;
  1425. struct net *net = dev_net(in_dev->dev);
  1426. ASSERT_RTNL();
  1427. for_each_pmc_rtnl(in_dev, im) {
  1428. if (im->multiaddr == IGMP_ALL_HOSTS)
  1429. continue;
  1430. if (ipv4_is_local_multicast(im->multiaddr) &&
  1431. !READ_ONCE(net->ipv4.sysctl_igmp_llm_reports))
  1432. continue;
  1433. /* a failover is happening and switches
  1434. * must be notified immediately
  1435. */
  1436. if (IGMP_V1_SEEN(in_dev))
  1437. type = IGMP_HOST_MEMBERSHIP_REPORT;
  1438. else if (IGMP_V2_SEEN(in_dev))
  1439. type = IGMPV2_HOST_MEMBERSHIP_REPORT;
  1440. else
  1441. type = IGMPV3_HOST_MEMBERSHIP_REPORT;
  1442. igmp_send_report(in_dev, im, type);
  1443. }
  1444. #endif
  1445. }
  1446. /*
  1447. * A socket has left a multicast group on device dev
  1448. */
  1449. void __ip_mc_dec_group(struct in_device *in_dev, __be32 addr, gfp_t gfp)
  1450. {
  1451. struct ip_mc_list *i;
  1452. struct ip_mc_list __rcu **ip;
  1453. ASSERT_RTNL();
  1454. for (ip = &in_dev->mc_list;
  1455. (i = rtnl_dereference(*ip)) != NULL;
  1456. ip = &i->next_rcu) {
  1457. if (i->multiaddr == addr) {
  1458. if (--i->users == 0) {
  1459. ip_mc_hash_remove(in_dev, i);
  1460. *ip = i->next_rcu;
  1461. in_dev->mc_count--;
  1462. __igmp_group_dropped(i, gfp);
  1463. ip_mc_clear_src(i);
  1464. if (!in_dev->dead)
  1465. ip_rt_multicast_event(in_dev);
  1466. ip_ma_put(i);
  1467. return;
  1468. }
  1469. break;
  1470. }
  1471. }
  1472. }
  1473. EXPORT_SYMBOL(__ip_mc_dec_group);
  1474. /* Device changing type */
  1475. void ip_mc_unmap(struct in_device *in_dev)
  1476. {
  1477. struct ip_mc_list *pmc;
  1478. ASSERT_RTNL();
  1479. for_each_pmc_rtnl(in_dev, pmc)
  1480. igmp_group_dropped(pmc);
  1481. }
  1482. void ip_mc_remap(struct in_device *in_dev)
  1483. {
  1484. struct ip_mc_list *pmc;
  1485. ASSERT_RTNL();
  1486. for_each_pmc_rtnl(in_dev, pmc) {
  1487. #ifdef CONFIG_IP_MULTICAST
  1488. igmpv3_del_delrec(in_dev, pmc);
  1489. #endif
  1490. igmp_group_added(pmc);
  1491. }
  1492. }
  1493. /* Device going down */
  1494. void ip_mc_down(struct in_device *in_dev)
  1495. {
  1496. struct ip_mc_list *pmc;
  1497. ASSERT_RTNL();
  1498. for_each_pmc_rtnl(in_dev, pmc)
  1499. igmp_group_dropped(pmc);
  1500. #ifdef CONFIG_IP_MULTICAST
  1501. WRITE_ONCE(in_dev->mr_ifc_count, 0);
  1502. if (del_timer(&in_dev->mr_ifc_timer))
  1503. __in_dev_put(in_dev);
  1504. in_dev->mr_gq_running = 0;
  1505. if (del_timer(&in_dev->mr_gq_timer))
  1506. __in_dev_put(in_dev);
  1507. #endif
  1508. ip_mc_dec_group(in_dev, IGMP_ALL_HOSTS);
  1509. }
  1510. #ifdef CONFIG_IP_MULTICAST
  1511. static void ip_mc_reset(struct in_device *in_dev)
  1512. {
  1513. struct net *net = dev_net(in_dev->dev);
  1514. in_dev->mr_qi = IGMP_QUERY_INTERVAL;
  1515. in_dev->mr_qri = IGMP_QUERY_RESPONSE_INTERVAL;
  1516. in_dev->mr_qrv = READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1517. }
  1518. #else
  1519. static void ip_mc_reset(struct in_device *in_dev)
  1520. {
  1521. }
  1522. #endif
  1523. void ip_mc_init_dev(struct in_device *in_dev)
  1524. {
  1525. ASSERT_RTNL();
  1526. #ifdef CONFIG_IP_MULTICAST
  1527. timer_setup(&in_dev->mr_gq_timer, igmp_gq_timer_expire, 0);
  1528. timer_setup(&in_dev->mr_ifc_timer, igmp_ifc_timer_expire, 0);
  1529. #endif
  1530. ip_mc_reset(in_dev);
  1531. spin_lock_init(&in_dev->mc_tomb_lock);
  1532. }
  1533. /* Device going up */
  1534. void ip_mc_up(struct in_device *in_dev)
  1535. {
  1536. struct ip_mc_list *pmc;
  1537. ASSERT_RTNL();
  1538. ip_mc_reset(in_dev);
  1539. ip_mc_inc_group(in_dev, IGMP_ALL_HOSTS);
  1540. for_each_pmc_rtnl(in_dev, pmc) {
  1541. #ifdef CONFIG_IP_MULTICAST
  1542. igmpv3_del_delrec(in_dev, pmc);
  1543. #endif
  1544. igmp_group_added(pmc);
  1545. }
  1546. }
  1547. /*
  1548. * Device is about to be destroyed: clean up.
  1549. */
  1550. void ip_mc_destroy_dev(struct in_device *in_dev)
  1551. {
  1552. struct ip_mc_list *i;
  1553. ASSERT_RTNL();
  1554. /* Deactivate timers */
  1555. ip_mc_down(in_dev);
  1556. #ifdef CONFIG_IP_MULTICAST
  1557. igmpv3_clear_delrec(in_dev);
  1558. #endif
  1559. while ((i = rtnl_dereference(in_dev->mc_list)) != NULL) {
  1560. in_dev->mc_list = i->next_rcu;
  1561. in_dev->mc_count--;
  1562. ip_mc_clear_src(i);
  1563. ip_ma_put(i);
  1564. }
  1565. }
  1566. /* RTNL is locked */
  1567. static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr)
  1568. {
  1569. struct net_device *dev = NULL;
  1570. struct in_device *idev = NULL;
  1571. if (imr->imr_ifindex) {
  1572. idev = inetdev_by_index(net, imr->imr_ifindex);
  1573. return idev;
  1574. }
  1575. if (imr->imr_address.s_addr) {
  1576. dev = __ip_dev_find(net, imr->imr_address.s_addr, false);
  1577. if (!dev)
  1578. return NULL;
  1579. }
  1580. if (!dev) {
  1581. struct rtable *rt = ip_route_output(net,
  1582. imr->imr_multiaddr.s_addr,
  1583. 0, 0, 0);
  1584. if (!IS_ERR(rt)) {
  1585. dev = rt->dst.dev;
  1586. ip_rt_put(rt);
  1587. }
  1588. }
  1589. if (dev) {
  1590. imr->imr_ifindex = dev->ifindex;
  1591. idev = __in_dev_get_rtnl(dev);
  1592. }
  1593. return idev;
  1594. }
  1595. /*
  1596. * Join a socket to a group
  1597. */
  1598. static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
  1599. __be32 *psfsrc)
  1600. {
  1601. struct ip_sf_list *psf, *psf_prev;
  1602. int rv = 0;
  1603. psf_prev = NULL;
  1604. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  1605. if (psf->sf_inaddr == *psfsrc)
  1606. break;
  1607. psf_prev = psf;
  1608. }
  1609. if (!psf || psf->sf_count[sfmode] == 0) {
  1610. /* source filter not found, or count wrong => bug */
  1611. return -ESRCH;
  1612. }
  1613. psf->sf_count[sfmode]--;
  1614. if (psf->sf_count[sfmode] == 0) {
  1615. ip_rt_multicast_event(pmc->interface);
  1616. }
  1617. if (!psf->sf_count[MCAST_INCLUDE] && !psf->sf_count[MCAST_EXCLUDE]) {
  1618. #ifdef CONFIG_IP_MULTICAST
  1619. struct in_device *in_dev = pmc->interface;
  1620. struct net *net = dev_net(in_dev->dev);
  1621. #endif
  1622. /* no more filters for this source */
  1623. if (psf_prev)
  1624. psf_prev->sf_next = psf->sf_next;
  1625. else
  1626. pmc->sources = psf->sf_next;
  1627. #ifdef CONFIG_IP_MULTICAST
  1628. if (psf->sf_oldin &&
  1629. !IGMP_V1_SEEN(in_dev) && !IGMP_V2_SEEN(in_dev)) {
  1630. psf->sf_crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1631. psf->sf_next = pmc->tomb;
  1632. pmc->tomb = psf;
  1633. rv = 1;
  1634. } else
  1635. #endif
  1636. kfree(psf);
  1637. }
  1638. return rv;
  1639. }
  1640. #ifndef CONFIG_IP_MULTICAST
  1641. #define igmp_ifc_event(x) do { } while (0)
  1642. #endif
  1643. static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
  1644. int sfcount, __be32 *psfsrc, int delta)
  1645. {
  1646. struct ip_mc_list *pmc;
  1647. int changerec = 0;
  1648. int i, err;
  1649. if (!in_dev)
  1650. return -ENODEV;
  1651. rcu_read_lock();
  1652. for_each_pmc_rcu(in_dev, pmc) {
  1653. if (*pmca == pmc->multiaddr)
  1654. break;
  1655. }
  1656. if (!pmc) {
  1657. /* MCA not found?? bug */
  1658. rcu_read_unlock();
  1659. return -ESRCH;
  1660. }
  1661. spin_lock_bh(&pmc->lock);
  1662. rcu_read_unlock();
  1663. #ifdef CONFIG_IP_MULTICAST
  1664. sf_markstate(pmc);
  1665. #endif
  1666. if (!delta) {
  1667. err = -EINVAL;
  1668. if (!pmc->sfcount[sfmode])
  1669. goto out_unlock;
  1670. pmc->sfcount[sfmode]--;
  1671. }
  1672. err = 0;
  1673. for (i = 0; i < sfcount; i++) {
  1674. int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
  1675. changerec |= rv > 0;
  1676. if (!err && rv < 0)
  1677. err = rv;
  1678. }
  1679. if (pmc->sfmode == MCAST_EXCLUDE &&
  1680. pmc->sfcount[MCAST_EXCLUDE] == 0 &&
  1681. pmc->sfcount[MCAST_INCLUDE]) {
  1682. #ifdef CONFIG_IP_MULTICAST
  1683. struct ip_sf_list *psf;
  1684. struct net *net = dev_net(in_dev->dev);
  1685. #endif
  1686. /* filter mode change */
  1687. pmc->sfmode = MCAST_INCLUDE;
  1688. #ifdef CONFIG_IP_MULTICAST
  1689. pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1690. WRITE_ONCE(in_dev->mr_ifc_count, pmc->crcount);
  1691. for (psf = pmc->sources; psf; psf = psf->sf_next)
  1692. psf->sf_crcount = 0;
  1693. igmp_ifc_event(pmc->interface);
  1694. } else if (sf_setstate(pmc) || changerec) {
  1695. igmp_ifc_event(pmc->interface);
  1696. #endif
  1697. }
  1698. out_unlock:
  1699. spin_unlock_bh(&pmc->lock);
  1700. return err;
  1701. }
  1702. /*
  1703. * Add multicast single-source filter to the interface list
  1704. */
  1705. static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,
  1706. __be32 *psfsrc)
  1707. {
  1708. struct ip_sf_list *psf, *psf_prev;
  1709. psf_prev = NULL;
  1710. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  1711. if (psf->sf_inaddr == *psfsrc)
  1712. break;
  1713. psf_prev = psf;
  1714. }
  1715. if (!psf) {
  1716. psf = kzalloc(sizeof(*psf), GFP_ATOMIC);
  1717. if (!psf)
  1718. return -ENOBUFS;
  1719. psf->sf_inaddr = *psfsrc;
  1720. if (psf_prev) {
  1721. psf_prev->sf_next = psf;
  1722. } else
  1723. pmc->sources = psf;
  1724. }
  1725. psf->sf_count[sfmode]++;
  1726. if (psf->sf_count[sfmode] == 1) {
  1727. ip_rt_multicast_event(pmc->interface);
  1728. }
  1729. return 0;
  1730. }
  1731. #ifdef CONFIG_IP_MULTICAST
  1732. static void sf_markstate(struct ip_mc_list *pmc)
  1733. {
  1734. struct ip_sf_list *psf;
  1735. int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
  1736. for (psf = pmc->sources; psf; psf = psf->sf_next)
  1737. if (pmc->sfcount[MCAST_EXCLUDE]) {
  1738. psf->sf_oldin = mca_xcount ==
  1739. psf->sf_count[MCAST_EXCLUDE] &&
  1740. !psf->sf_count[MCAST_INCLUDE];
  1741. } else
  1742. psf->sf_oldin = psf->sf_count[MCAST_INCLUDE] != 0;
  1743. }
  1744. static int sf_setstate(struct ip_mc_list *pmc)
  1745. {
  1746. struct ip_sf_list *psf, *dpsf;
  1747. int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
  1748. int qrv = pmc->interface->mr_qrv;
  1749. int new_in, rv;
  1750. rv = 0;
  1751. for (psf = pmc->sources; psf; psf = psf->sf_next) {
  1752. if (pmc->sfcount[MCAST_EXCLUDE]) {
  1753. new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
  1754. !psf->sf_count[MCAST_INCLUDE];
  1755. } else
  1756. new_in = psf->sf_count[MCAST_INCLUDE] != 0;
  1757. if (new_in) {
  1758. if (!psf->sf_oldin) {
  1759. struct ip_sf_list *prev = NULL;
  1760. for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next) {
  1761. if (dpsf->sf_inaddr == psf->sf_inaddr)
  1762. break;
  1763. prev = dpsf;
  1764. }
  1765. if (dpsf) {
  1766. if (prev)
  1767. prev->sf_next = dpsf->sf_next;
  1768. else
  1769. pmc->tomb = dpsf->sf_next;
  1770. kfree(dpsf);
  1771. }
  1772. psf->sf_crcount = qrv;
  1773. rv++;
  1774. }
  1775. } else if (psf->sf_oldin) {
  1776. psf->sf_crcount = 0;
  1777. /*
  1778. * add or update "delete" records if an active filter
  1779. * is now inactive
  1780. */
  1781. for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next)
  1782. if (dpsf->sf_inaddr == psf->sf_inaddr)
  1783. break;
  1784. if (!dpsf) {
  1785. dpsf = kmalloc(sizeof(*dpsf), GFP_ATOMIC);
  1786. if (!dpsf)
  1787. continue;
  1788. *dpsf = *psf;
  1789. /* pmc->lock held by callers */
  1790. dpsf->sf_next = pmc->tomb;
  1791. pmc->tomb = dpsf;
  1792. }
  1793. dpsf->sf_crcount = qrv;
  1794. rv++;
  1795. }
  1796. }
  1797. return rv;
  1798. }
  1799. #endif
  1800. /*
  1801. * Add multicast source filter list to the interface list
  1802. */
  1803. static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
  1804. int sfcount, __be32 *psfsrc, int delta)
  1805. {
  1806. struct ip_mc_list *pmc;
  1807. int isexclude;
  1808. int i, err;
  1809. if (!in_dev)
  1810. return -ENODEV;
  1811. rcu_read_lock();
  1812. for_each_pmc_rcu(in_dev, pmc) {
  1813. if (*pmca == pmc->multiaddr)
  1814. break;
  1815. }
  1816. if (!pmc) {
  1817. /* MCA not found?? bug */
  1818. rcu_read_unlock();
  1819. return -ESRCH;
  1820. }
  1821. spin_lock_bh(&pmc->lock);
  1822. rcu_read_unlock();
  1823. #ifdef CONFIG_IP_MULTICAST
  1824. sf_markstate(pmc);
  1825. #endif
  1826. isexclude = pmc->sfmode == MCAST_EXCLUDE;
  1827. if (!delta)
  1828. pmc->sfcount[sfmode]++;
  1829. err = 0;
  1830. for (i = 0; i < sfcount; i++) {
  1831. err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]);
  1832. if (err)
  1833. break;
  1834. }
  1835. if (err) {
  1836. int j;
  1837. if (!delta)
  1838. pmc->sfcount[sfmode]--;
  1839. for (j = 0; j < i; j++)
  1840. (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]);
  1841. } else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {
  1842. #ifdef CONFIG_IP_MULTICAST
  1843. struct ip_sf_list *psf;
  1844. struct net *net = dev_net(pmc->interface->dev);
  1845. in_dev = pmc->interface;
  1846. #endif
  1847. /* filter mode change */
  1848. if (pmc->sfcount[MCAST_EXCLUDE])
  1849. pmc->sfmode = MCAST_EXCLUDE;
  1850. else if (pmc->sfcount[MCAST_INCLUDE])
  1851. pmc->sfmode = MCAST_INCLUDE;
  1852. #ifdef CONFIG_IP_MULTICAST
  1853. /* else no filters; keep old mode for reports */
  1854. pmc->crcount = in_dev->mr_qrv ?: READ_ONCE(net->ipv4.sysctl_igmp_qrv);
  1855. WRITE_ONCE(in_dev->mr_ifc_count, pmc->crcount);
  1856. for (psf = pmc->sources; psf; psf = psf->sf_next)
  1857. psf->sf_crcount = 0;
  1858. igmp_ifc_event(in_dev);
  1859. } else if (sf_setstate(pmc)) {
  1860. igmp_ifc_event(in_dev);
  1861. #endif
  1862. }
  1863. spin_unlock_bh(&pmc->lock);
  1864. return err;
  1865. }
  1866. static void ip_mc_clear_src(struct ip_mc_list *pmc)
  1867. {
  1868. struct ip_sf_list *tomb, *sources;
  1869. spin_lock_bh(&pmc->lock);
  1870. tomb = pmc->tomb;
  1871. pmc->tomb = NULL;
  1872. sources = pmc->sources;
  1873. pmc->sources = NULL;
  1874. pmc->sfmode = MCAST_EXCLUDE;
  1875. pmc->sfcount[MCAST_INCLUDE] = 0;
  1876. pmc->sfcount[MCAST_EXCLUDE] = 1;
  1877. spin_unlock_bh(&pmc->lock);
  1878. ip_sf_list_clear_all(tomb);
  1879. ip_sf_list_clear_all(sources);
  1880. }
  1881. /* Join a multicast group
  1882. */
  1883. static int __ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr,
  1884. unsigned int mode)
  1885. {
  1886. __be32 addr = imr->imr_multiaddr.s_addr;
  1887. struct ip_mc_socklist *iml, *i;
  1888. struct in_device *in_dev;
  1889. struct inet_sock *inet = inet_sk(sk);
  1890. struct net *net = sock_net(sk);
  1891. int ifindex;
  1892. int count = 0;
  1893. int err;
  1894. ASSERT_RTNL();
  1895. if (!ipv4_is_multicast(addr))
  1896. return -EINVAL;
  1897. in_dev = ip_mc_find_dev(net, imr);
  1898. if (!in_dev) {
  1899. err = -ENODEV;
  1900. goto done;
  1901. }
  1902. err = -EADDRINUSE;
  1903. ifindex = imr->imr_ifindex;
  1904. for_each_pmc_rtnl(inet, i) {
  1905. if (i->multi.imr_multiaddr.s_addr == addr &&
  1906. i->multi.imr_ifindex == ifindex)
  1907. goto done;
  1908. count++;
  1909. }
  1910. err = -ENOBUFS;
  1911. if (count >= READ_ONCE(net->ipv4.sysctl_igmp_max_memberships))
  1912. goto done;
  1913. iml = sock_kmalloc(sk, sizeof(*iml), GFP_KERNEL);
  1914. if (!iml)
  1915. goto done;
  1916. memcpy(&iml->multi, imr, sizeof(*imr));
  1917. iml->next_rcu = inet->mc_list;
  1918. iml->sflist = NULL;
  1919. iml->sfmode = mode;
  1920. rcu_assign_pointer(inet->mc_list, iml);
  1921. ____ip_mc_inc_group(in_dev, addr, mode, GFP_KERNEL);
  1922. err = 0;
  1923. done:
  1924. return err;
  1925. }
  1926. /* Join ASM (Any-Source Multicast) group
  1927. */
  1928. int ip_mc_join_group(struct sock *sk, struct ip_mreqn *imr)
  1929. {
  1930. return __ip_mc_join_group(sk, imr, MCAST_EXCLUDE);
  1931. }
  1932. EXPORT_SYMBOL(ip_mc_join_group);
  1933. /* Join SSM (Source-Specific Multicast) group
  1934. */
  1935. int ip_mc_join_group_ssm(struct sock *sk, struct ip_mreqn *imr,
  1936. unsigned int mode)
  1937. {
  1938. return __ip_mc_join_group(sk, imr, mode);
  1939. }
  1940. static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
  1941. struct in_device *in_dev)
  1942. {
  1943. struct ip_sf_socklist *psf = rtnl_dereference(iml->sflist);
  1944. int err;
  1945. if (!psf) {
  1946. /* any-source empty exclude case */
  1947. return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
  1948. iml->sfmode, 0, NULL, 0);
  1949. }
  1950. err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
  1951. iml->sfmode, psf->sl_count, psf->sl_addr, 0);
  1952. RCU_INIT_POINTER(iml->sflist, NULL);
  1953. /* decrease mem now to avoid the memleak warning */
  1954. atomic_sub(struct_size(psf, sl_addr, psf->sl_max), &sk->sk_omem_alloc);
  1955. kfree_rcu(psf, rcu);
  1956. return err;
  1957. }
  1958. int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
  1959. {
  1960. struct inet_sock *inet = inet_sk(sk);
  1961. struct ip_mc_socklist *iml;
  1962. struct ip_mc_socklist __rcu **imlp;
  1963. struct in_device *in_dev;
  1964. struct net *net = sock_net(sk);
  1965. __be32 group = imr->imr_multiaddr.s_addr;
  1966. u32 ifindex;
  1967. int ret = -EADDRNOTAVAIL;
  1968. ASSERT_RTNL();
  1969. in_dev = ip_mc_find_dev(net, imr);
  1970. if (!imr->imr_ifindex && !imr->imr_address.s_addr && !in_dev) {
  1971. ret = -ENODEV;
  1972. goto out;
  1973. }
  1974. ifindex = imr->imr_ifindex;
  1975. for (imlp = &inet->mc_list;
  1976. (iml = rtnl_dereference(*imlp)) != NULL;
  1977. imlp = &iml->next_rcu) {
  1978. if (iml->multi.imr_multiaddr.s_addr != group)
  1979. continue;
  1980. if (ifindex) {
  1981. if (iml->multi.imr_ifindex != ifindex)
  1982. continue;
  1983. } else if (imr->imr_address.s_addr && imr->imr_address.s_addr !=
  1984. iml->multi.imr_address.s_addr)
  1985. continue;
  1986. (void) ip_mc_leave_src(sk, iml, in_dev);
  1987. *imlp = iml->next_rcu;
  1988. if (in_dev)
  1989. ip_mc_dec_group(in_dev, group);
  1990. /* decrease mem now to avoid the memleak warning */
  1991. atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
  1992. kfree_rcu(iml, rcu);
  1993. return 0;
  1994. }
  1995. out:
  1996. return ret;
  1997. }
  1998. EXPORT_SYMBOL(ip_mc_leave_group);
  1999. int ip_mc_source(int add, int omode, struct sock *sk, struct
  2000. ip_mreq_source *mreqs, int ifindex)
  2001. {
  2002. int err;
  2003. struct ip_mreqn imr;
  2004. __be32 addr = mreqs->imr_multiaddr;
  2005. struct ip_mc_socklist *pmc;
  2006. struct in_device *in_dev = NULL;
  2007. struct inet_sock *inet = inet_sk(sk);
  2008. struct ip_sf_socklist *psl;
  2009. struct net *net = sock_net(sk);
  2010. int leavegroup = 0;
  2011. int i, j, rv;
  2012. if (!ipv4_is_multicast(addr))
  2013. return -EINVAL;
  2014. ASSERT_RTNL();
  2015. imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
  2016. imr.imr_address.s_addr = mreqs->imr_interface;
  2017. imr.imr_ifindex = ifindex;
  2018. in_dev = ip_mc_find_dev(net, &imr);
  2019. if (!in_dev) {
  2020. err = -ENODEV;
  2021. goto done;
  2022. }
  2023. err = -EADDRNOTAVAIL;
  2024. for_each_pmc_rtnl(inet, pmc) {
  2025. if ((pmc->multi.imr_multiaddr.s_addr ==
  2026. imr.imr_multiaddr.s_addr) &&
  2027. (pmc->multi.imr_ifindex == imr.imr_ifindex))
  2028. break;
  2029. }
  2030. if (!pmc) { /* must have a prior join */
  2031. err = -EINVAL;
  2032. goto done;
  2033. }
  2034. /* if a source filter was set, must be the same mode as before */
  2035. if (pmc->sflist) {
  2036. if (pmc->sfmode != omode) {
  2037. err = -EINVAL;
  2038. goto done;
  2039. }
  2040. } else if (pmc->sfmode != omode) {
  2041. /* allow mode switches for empty-set filters */
  2042. ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, NULL, 0);
  2043. ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,
  2044. NULL, 0);
  2045. pmc->sfmode = omode;
  2046. }
  2047. psl = rtnl_dereference(pmc->sflist);
  2048. if (!add) {
  2049. if (!psl)
  2050. goto done; /* err = -EADDRNOTAVAIL */
  2051. rv = !0;
  2052. for (i = 0; i < psl->sl_count; i++) {
  2053. rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
  2054. sizeof(__be32));
  2055. if (rv == 0)
  2056. break;
  2057. }
  2058. if (rv) /* source not found */
  2059. goto done; /* err = -EADDRNOTAVAIL */
  2060. /* special case - (INCLUDE, empty) == LEAVE_GROUP */
  2061. if (psl->sl_count == 1 && omode == MCAST_INCLUDE) {
  2062. leavegroup = 1;
  2063. goto done;
  2064. }
  2065. /* update the interface filter */
  2066. ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
  2067. &mreqs->imr_sourceaddr, 1);
  2068. for (j = i+1; j < psl->sl_count; j++)
  2069. psl->sl_addr[j-1] = psl->sl_addr[j];
  2070. psl->sl_count--;
  2071. err = 0;
  2072. goto done;
  2073. }
  2074. /* else, add a new source to the filter */
  2075. if (psl && psl->sl_count >= READ_ONCE(net->ipv4.sysctl_igmp_max_msf)) {
  2076. err = -ENOBUFS;
  2077. goto done;
  2078. }
  2079. if (!psl || psl->sl_count == psl->sl_max) {
  2080. struct ip_sf_socklist *newpsl;
  2081. int count = IP_SFBLOCK;
  2082. if (psl)
  2083. count += psl->sl_max;
  2084. newpsl = sock_kmalloc(sk, struct_size(newpsl, sl_addr, count),
  2085. GFP_KERNEL);
  2086. if (!newpsl) {
  2087. err = -ENOBUFS;
  2088. goto done;
  2089. }
  2090. newpsl->sl_max = count;
  2091. newpsl->sl_count = count - IP_SFBLOCK;
  2092. if (psl) {
  2093. for (i = 0; i < psl->sl_count; i++)
  2094. newpsl->sl_addr[i] = psl->sl_addr[i];
  2095. /* decrease mem now to avoid the memleak warning */
  2096. atomic_sub(struct_size(psl, sl_addr, psl->sl_max),
  2097. &sk->sk_omem_alloc);
  2098. }
  2099. rcu_assign_pointer(pmc->sflist, newpsl);
  2100. if (psl)
  2101. kfree_rcu(psl, rcu);
  2102. psl = newpsl;
  2103. }
  2104. rv = 1; /* > 0 for insert logic below if sl_count is 0 */
  2105. for (i = 0; i < psl->sl_count; i++) {
  2106. rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
  2107. sizeof(__be32));
  2108. if (rv == 0)
  2109. break;
  2110. }
  2111. if (rv == 0) /* address already there is an error */
  2112. goto done;
  2113. for (j = psl->sl_count-1; j >= i; j--)
  2114. psl->sl_addr[j+1] = psl->sl_addr[j];
  2115. psl->sl_addr[i] = mreqs->imr_sourceaddr;
  2116. psl->sl_count++;
  2117. err = 0;
  2118. /* update the interface list */
  2119. ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
  2120. &mreqs->imr_sourceaddr, 1);
  2121. done:
  2122. if (leavegroup)
  2123. err = ip_mc_leave_group(sk, &imr);
  2124. return err;
  2125. }
  2126. int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
  2127. {
  2128. int err = 0;
  2129. struct ip_mreqn imr;
  2130. __be32 addr = msf->imsf_multiaddr;
  2131. struct ip_mc_socklist *pmc;
  2132. struct in_device *in_dev;
  2133. struct inet_sock *inet = inet_sk(sk);
  2134. struct ip_sf_socklist *newpsl, *psl;
  2135. struct net *net = sock_net(sk);
  2136. int leavegroup = 0;
  2137. if (!ipv4_is_multicast(addr))
  2138. return -EINVAL;
  2139. if (msf->imsf_fmode != MCAST_INCLUDE &&
  2140. msf->imsf_fmode != MCAST_EXCLUDE)
  2141. return -EINVAL;
  2142. ASSERT_RTNL();
  2143. imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
  2144. imr.imr_address.s_addr = msf->imsf_interface;
  2145. imr.imr_ifindex = ifindex;
  2146. in_dev = ip_mc_find_dev(net, &imr);
  2147. if (!in_dev) {
  2148. err = -ENODEV;
  2149. goto done;
  2150. }
  2151. /* special case - (INCLUDE, empty) == LEAVE_GROUP */
  2152. if (msf->imsf_fmode == MCAST_INCLUDE && msf->imsf_numsrc == 0) {
  2153. leavegroup = 1;
  2154. goto done;
  2155. }
  2156. for_each_pmc_rtnl(inet, pmc) {
  2157. if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
  2158. pmc->multi.imr_ifindex == imr.imr_ifindex)
  2159. break;
  2160. }
  2161. if (!pmc) { /* must have a prior join */
  2162. err = -EINVAL;
  2163. goto done;
  2164. }
  2165. if (msf->imsf_numsrc) {
  2166. newpsl = sock_kmalloc(sk, struct_size(newpsl, sl_addr,
  2167. msf->imsf_numsrc),
  2168. GFP_KERNEL);
  2169. if (!newpsl) {
  2170. err = -ENOBUFS;
  2171. goto done;
  2172. }
  2173. newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc;
  2174. memcpy(newpsl->sl_addr, msf->imsf_slist_flex,
  2175. flex_array_size(msf, imsf_slist_flex, msf->imsf_numsrc));
  2176. err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
  2177. msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0);
  2178. if (err) {
  2179. sock_kfree_s(sk, newpsl,
  2180. struct_size(newpsl, sl_addr,
  2181. newpsl->sl_max));
  2182. goto done;
  2183. }
  2184. } else {
  2185. newpsl = NULL;
  2186. (void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
  2187. msf->imsf_fmode, 0, NULL, 0);
  2188. }
  2189. psl = rtnl_dereference(pmc->sflist);
  2190. if (psl) {
  2191. (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
  2192. psl->sl_count, psl->sl_addr, 0);
  2193. /* decrease mem now to avoid the memleak warning */
  2194. atomic_sub(struct_size(psl, sl_addr, psl->sl_max),
  2195. &sk->sk_omem_alloc);
  2196. } else {
  2197. (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
  2198. 0, NULL, 0);
  2199. }
  2200. rcu_assign_pointer(pmc->sflist, newpsl);
  2201. if (psl)
  2202. kfree_rcu(psl, rcu);
  2203. pmc->sfmode = msf->imsf_fmode;
  2204. err = 0;
  2205. done:
  2206. if (leavegroup)
  2207. err = ip_mc_leave_group(sk, &imr);
  2208. return err;
  2209. }
  2210. int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
  2211. sockptr_t optval, sockptr_t optlen)
  2212. {
  2213. int err, len, count, copycount, msf_size;
  2214. struct ip_mreqn imr;
  2215. __be32 addr = msf->imsf_multiaddr;
  2216. struct ip_mc_socklist *pmc;
  2217. struct in_device *in_dev;
  2218. struct inet_sock *inet = inet_sk(sk);
  2219. struct ip_sf_socklist *psl;
  2220. struct net *net = sock_net(sk);
  2221. ASSERT_RTNL();
  2222. if (!ipv4_is_multicast(addr))
  2223. return -EINVAL;
  2224. imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
  2225. imr.imr_address.s_addr = msf->imsf_interface;
  2226. imr.imr_ifindex = 0;
  2227. in_dev = ip_mc_find_dev(net, &imr);
  2228. if (!in_dev) {
  2229. err = -ENODEV;
  2230. goto done;
  2231. }
  2232. err = -EADDRNOTAVAIL;
  2233. for_each_pmc_rtnl(inet, pmc) {
  2234. if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
  2235. pmc->multi.imr_ifindex == imr.imr_ifindex)
  2236. break;
  2237. }
  2238. if (!pmc) /* must have a prior join */
  2239. goto done;
  2240. msf->imsf_fmode = pmc->sfmode;
  2241. psl = rtnl_dereference(pmc->sflist);
  2242. if (!psl) {
  2243. count = 0;
  2244. } else {
  2245. count = psl->sl_count;
  2246. }
  2247. copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc;
  2248. len = flex_array_size(psl, sl_addr, copycount);
  2249. msf->imsf_numsrc = count;
  2250. msf_size = IP_MSFILTER_SIZE(copycount);
  2251. if (copy_to_sockptr(optlen, &msf_size, sizeof(int)) ||
  2252. copy_to_sockptr(optval, msf, IP_MSFILTER_SIZE(0))) {
  2253. return -EFAULT;
  2254. }
  2255. if (len &&
  2256. copy_to_sockptr_offset(optval,
  2257. offsetof(struct ip_msfilter, imsf_slist_flex),
  2258. psl->sl_addr, len))
  2259. return -EFAULT;
  2260. return 0;
  2261. done:
  2262. return err;
  2263. }
  2264. int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
  2265. sockptr_t optval, size_t ss_offset)
  2266. {
  2267. int i, count, copycount;
  2268. struct sockaddr_in *psin;
  2269. __be32 addr;
  2270. struct ip_mc_socklist *pmc;
  2271. struct inet_sock *inet = inet_sk(sk);
  2272. struct ip_sf_socklist *psl;
  2273. ASSERT_RTNL();
  2274. psin = (struct sockaddr_in *)&gsf->gf_group;
  2275. if (psin->sin_family != AF_INET)
  2276. return -EINVAL;
  2277. addr = psin->sin_addr.s_addr;
  2278. if (!ipv4_is_multicast(addr))
  2279. return -EINVAL;
  2280. for_each_pmc_rtnl(inet, pmc) {
  2281. if (pmc->multi.imr_multiaddr.s_addr == addr &&
  2282. pmc->multi.imr_ifindex == gsf->gf_interface)
  2283. break;
  2284. }
  2285. if (!pmc) /* must have a prior join */
  2286. return -EADDRNOTAVAIL;
  2287. gsf->gf_fmode = pmc->sfmode;
  2288. psl = rtnl_dereference(pmc->sflist);
  2289. count = psl ? psl->sl_count : 0;
  2290. copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
  2291. gsf->gf_numsrc = count;
  2292. for (i = 0; i < copycount; i++) {
  2293. struct sockaddr_storage ss;
  2294. psin = (struct sockaddr_in *)&ss;
  2295. memset(&ss, 0, sizeof(ss));
  2296. psin->sin_family = AF_INET;
  2297. psin->sin_addr.s_addr = psl->sl_addr[i];
  2298. if (copy_to_sockptr_offset(optval, ss_offset,
  2299. &ss, sizeof(ss)))
  2300. return -EFAULT;
  2301. ss_offset += sizeof(ss);
  2302. }
  2303. return 0;
  2304. }
  2305. /*
  2306. * check if a multicast source filter allows delivery for a given <src,dst,intf>
  2307. */
  2308. int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr,
  2309. int dif, int sdif)
  2310. {
  2311. struct inet_sock *inet = inet_sk(sk);
  2312. struct ip_mc_socklist *pmc;
  2313. struct ip_sf_socklist *psl;
  2314. int i;
  2315. int ret;
  2316. ret = 1;
  2317. if (!ipv4_is_multicast(loc_addr))
  2318. goto out;
  2319. rcu_read_lock();
  2320. for_each_pmc_rcu(inet, pmc) {
  2321. if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&
  2322. (pmc->multi.imr_ifindex == dif ||
  2323. (sdif && pmc->multi.imr_ifindex == sdif)))
  2324. break;
  2325. }
  2326. ret = inet->mc_all;
  2327. if (!pmc)
  2328. goto unlock;
  2329. psl = rcu_dereference(pmc->sflist);
  2330. ret = (pmc->sfmode == MCAST_EXCLUDE);
  2331. if (!psl)
  2332. goto unlock;
  2333. for (i = 0; i < psl->sl_count; i++) {
  2334. if (psl->sl_addr[i] == rmt_addr)
  2335. break;
  2336. }
  2337. ret = 0;
  2338. if (pmc->sfmode == MCAST_INCLUDE && i >= psl->sl_count)
  2339. goto unlock;
  2340. if (pmc->sfmode == MCAST_EXCLUDE && i < psl->sl_count)
  2341. goto unlock;
  2342. ret = 1;
  2343. unlock:
  2344. rcu_read_unlock();
  2345. out:
  2346. return ret;
  2347. }
  2348. /*
  2349. * A socket is closing.
  2350. */
  2351. void ip_mc_drop_socket(struct sock *sk)
  2352. {
  2353. struct inet_sock *inet = inet_sk(sk);
  2354. struct ip_mc_socklist *iml;
  2355. struct net *net = sock_net(sk);
  2356. if (!inet->mc_list)
  2357. return;
  2358. rtnl_lock();
  2359. while ((iml = rtnl_dereference(inet->mc_list)) != NULL) {
  2360. struct in_device *in_dev;
  2361. inet->mc_list = iml->next_rcu;
  2362. in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
  2363. (void) ip_mc_leave_src(sk, iml, in_dev);
  2364. if (in_dev)
  2365. ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
  2366. /* decrease mem now to avoid the memleak warning */
  2367. atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
  2368. kfree_rcu(iml, rcu);
  2369. }
  2370. rtnl_unlock();
  2371. }
  2372. /* called with rcu_read_lock() */
  2373. int ip_check_mc_rcu(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u8 proto)
  2374. {
  2375. struct ip_mc_list *im;
  2376. struct ip_mc_list __rcu **mc_hash;
  2377. struct ip_sf_list *psf;
  2378. int rv = 0;
  2379. mc_hash = rcu_dereference(in_dev->mc_hash);
  2380. if (mc_hash) {
  2381. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG);
  2382. for (im = rcu_dereference(mc_hash[hash]);
  2383. im != NULL;
  2384. im = rcu_dereference(im->next_hash)) {
  2385. if (im->multiaddr == mc_addr)
  2386. break;
  2387. }
  2388. } else {
  2389. for_each_pmc_rcu(in_dev, im) {
  2390. if (im->multiaddr == mc_addr)
  2391. break;
  2392. }
  2393. }
  2394. if (im && proto == IPPROTO_IGMP) {
  2395. rv = 1;
  2396. } else if (im) {
  2397. if (src_addr) {
  2398. spin_lock_bh(&im->lock);
  2399. for (psf = im->sources; psf; psf = psf->sf_next) {
  2400. if (psf->sf_inaddr == src_addr)
  2401. break;
  2402. }
  2403. if (psf)
  2404. rv = psf->sf_count[MCAST_INCLUDE] ||
  2405. psf->sf_count[MCAST_EXCLUDE] !=
  2406. im->sfcount[MCAST_EXCLUDE];
  2407. else
  2408. rv = im->sfcount[MCAST_EXCLUDE] != 0;
  2409. spin_unlock_bh(&im->lock);
  2410. } else
  2411. rv = 1; /* unspecified source; tentatively allow */
  2412. }
  2413. return rv;
  2414. }
  2415. #if defined(CONFIG_PROC_FS)
  2416. struct igmp_mc_iter_state {
  2417. struct seq_net_private p;
  2418. struct net_device *dev;
  2419. struct in_device *in_dev;
  2420. };
  2421. #define igmp_mc_seq_private(seq) ((struct igmp_mc_iter_state *)(seq)->private)
  2422. static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq)
  2423. {
  2424. struct net *net = seq_file_net(seq);
  2425. struct ip_mc_list *im = NULL;
  2426. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
  2427. state->in_dev = NULL;
  2428. for_each_netdev_rcu(net, state->dev) {
  2429. struct in_device *in_dev;
  2430. in_dev = __in_dev_get_rcu(state->dev);
  2431. if (!in_dev)
  2432. continue;
  2433. im = rcu_dereference(in_dev->mc_list);
  2434. if (im) {
  2435. state->in_dev = in_dev;
  2436. break;
  2437. }
  2438. }
  2439. return im;
  2440. }
  2441. static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im)
  2442. {
  2443. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
  2444. im = rcu_dereference(im->next_rcu);
  2445. while (!im) {
  2446. state->dev = next_net_device_rcu(state->dev);
  2447. if (!state->dev) {
  2448. state->in_dev = NULL;
  2449. break;
  2450. }
  2451. state->in_dev = __in_dev_get_rcu(state->dev);
  2452. if (!state->in_dev)
  2453. continue;
  2454. im = rcu_dereference(state->in_dev->mc_list);
  2455. }
  2456. return im;
  2457. }
  2458. static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos)
  2459. {
  2460. struct ip_mc_list *im = igmp_mc_get_first(seq);
  2461. if (im)
  2462. while (pos && (im = igmp_mc_get_next(seq, im)) != NULL)
  2463. --pos;
  2464. return pos ? NULL : im;
  2465. }
  2466. static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos)
  2467. __acquires(rcu)
  2468. {
  2469. rcu_read_lock();
  2470. return *pos ? igmp_mc_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  2471. }
  2472. static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2473. {
  2474. struct ip_mc_list *im;
  2475. if (v == SEQ_START_TOKEN)
  2476. im = igmp_mc_get_first(seq);
  2477. else
  2478. im = igmp_mc_get_next(seq, v);
  2479. ++*pos;
  2480. return im;
  2481. }
  2482. static void igmp_mc_seq_stop(struct seq_file *seq, void *v)
  2483. __releases(rcu)
  2484. {
  2485. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
  2486. state->in_dev = NULL;
  2487. state->dev = NULL;
  2488. rcu_read_unlock();
  2489. }
  2490. static int igmp_mc_seq_show(struct seq_file *seq, void *v)
  2491. {
  2492. if (v == SEQ_START_TOKEN)
  2493. seq_puts(seq,
  2494. "Idx\tDevice : Count Querier\tGroup Users Timer\tReporter\n");
  2495. else {
  2496. struct ip_mc_list *im = v;
  2497. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq);
  2498. char *querier;
  2499. long delta;
  2500. #ifdef CONFIG_IP_MULTICAST
  2501. querier = IGMP_V1_SEEN(state->in_dev) ? "V1" :
  2502. IGMP_V2_SEEN(state->in_dev) ? "V2" :
  2503. "V3";
  2504. #else
  2505. querier = "NONE";
  2506. #endif
  2507. if (rcu_access_pointer(state->in_dev->mc_list) == im) {
  2508. seq_printf(seq, "%d\t%-10s: %5d %7s\n",
  2509. state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier);
  2510. }
  2511. delta = im->timer.expires - jiffies;
  2512. seq_printf(seq,
  2513. "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
  2514. im->multiaddr, im->users,
  2515. im->tm_running,
  2516. im->tm_running ? jiffies_delta_to_clock_t(delta) : 0,
  2517. im->reporter);
  2518. }
  2519. return 0;
  2520. }
  2521. static const struct seq_operations igmp_mc_seq_ops = {
  2522. .start = igmp_mc_seq_start,
  2523. .next = igmp_mc_seq_next,
  2524. .stop = igmp_mc_seq_stop,
  2525. .show = igmp_mc_seq_show,
  2526. };
  2527. struct igmp_mcf_iter_state {
  2528. struct seq_net_private p;
  2529. struct net_device *dev;
  2530. struct in_device *idev;
  2531. struct ip_mc_list *im;
  2532. };
  2533. #define igmp_mcf_seq_private(seq) ((struct igmp_mcf_iter_state *)(seq)->private)
  2534. static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq)
  2535. {
  2536. struct net *net = seq_file_net(seq);
  2537. struct ip_sf_list *psf = NULL;
  2538. struct ip_mc_list *im = NULL;
  2539. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
  2540. state->idev = NULL;
  2541. state->im = NULL;
  2542. for_each_netdev_rcu(net, state->dev) {
  2543. struct in_device *idev;
  2544. idev = __in_dev_get_rcu(state->dev);
  2545. if (unlikely(!idev))
  2546. continue;
  2547. im = rcu_dereference(idev->mc_list);
  2548. if (likely(im)) {
  2549. spin_lock_bh(&im->lock);
  2550. psf = im->sources;
  2551. if (likely(psf)) {
  2552. state->im = im;
  2553. state->idev = idev;
  2554. break;
  2555. }
  2556. spin_unlock_bh(&im->lock);
  2557. }
  2558. }
  2559. return psf;
  2560. }
  2561. static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf)
  2562. {
  2563. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
  2564. psf = psf->sf_next;
  2565. while (!psf) {
  2566. spin_unlock_bh(&state->im->lock);
  2567. state->im = state->im->next;
  2568. while (!state->im) {
  2569. state->dev = next_net_device_rcu(state->dev);
  2570. if (!state->dev) {
  2571. state->idev = NULL;
  2572. goto out;
  2573. }
  2574. state->idev = __in_dev_get_rcu(state->dev);
  2575. if (!state->idev)
  2576. continue;
  2577. state->im = rcu_dereference(state->idev->mc_list);
  2578. }
  2579. if (!state->im)
  2580. break;
  2581. spin_lock_bh(&state->im->lock);
  2582. psf = state->im->sources;
  2583. }
  2584. out:
  2585. return psf;
  2586. }
  2587. static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos)
  2588. {
  2589. struct ip_sf_list *psf = igmp_mcf_get_first(seq);
  2590. if (psf)
  2591. while (pos && (psf = igmp_mcf_get_next(seq, psf)) != NULL)
  2592. --pos;
  2593. return pos ? NULL : psf;
  2594. }
  2595. static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos)
  2596. __acquires(rcu)
  2597. {
  2598. rcu_read_lock();
  2599. return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
  2600. }
  2601. static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2602. {
  2603. struct ip_sf_list *psf;
  2604. if (v == SEQ_START_TOKEN)
  2605. psf = igmp_mcf_get_first(seq);
  2606. else
  2607. psf = igmp_mcf_get_next(seq, v);
  2608. ++*pos;
  2609. return psf;
  2610. }
  2611. static void igmp_mcf_seq_stop(struct seq_file *seq, void *v)
  2612. __releases(rcu)
  2613. {
  2614. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
  2615. if (likely(state->im)) {
  2616. spin_unlock_bh(&state->im->lock);
  2617. state->im = NULL;
  2618. }
  2619. state->idev = NULL;
  2620. state->dev = NULL;
  2621. rcu_read_unlock();
  2622. }
  2623. static int igmp_mcf_seq_show(struct seq_file *seq, void *v)
  2624. {
  2625. struct ip_sf_list *psf = v;
  2626. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq);
  2627. if (v == SEQ_START_TOKEN) {
  2628. seq_puts(seq, "Idx Device MCA SRC INC EXC\n");
  2629. } else {
  2630. seq_printf(seq,
  2631. "%3d %6.6s 0x%08x "
  2632. "0x%08x %6lu %6lu\n",
  2633. state->dev->ifindex, state->dev->name,
  2634. ntohl(state->im->multiaddr),
  2635. ntohl(psf->sf_inaddr),
  2636. psf->sf_count[MCAST_INCLUDE],
  2637. psf->sf_count[MCAST_EXCLUDE]);
  2638. }
  2639. return 0;
  2640. }
  2641. static const struct seq_operations igmp_mcf_seq_ops = {
  2642. .start = igmp_mcf_seq_start,
  2643. .next = igmp_mcf_seq_next,
  2644. .stop = igmp_mcf_seq_stop,
  2645. .show = igmp_mcf_seq_show,
  2646. };
  2647. static int __net_init igmp_net_init(struct net *net)
  2648. {
  2649. struct proc_dir_entry *pde;
  2650. int err;
  2651. pde = proc_create_net("igmp", 0444, net->proc_net, &igmp_mc_seq_ops,
  2652. sizeof(struct igmp_mc_iter_state));
  2653. if (!pde)
  2654. goto out_igmp;
  2655. pde = proc_create_net("mcfilter", 0444, net->proc_net,
  2656. &igmp_mcf_seq_ops, sizeof(struct igmp_mcf_iter_state));
  2657. if (!pde)
  2658. goto out_mcfilter;
  2659. err = inet_ctl_sock_create(&net->ipv4.mc_autojoin_sk, AF_INET,
  2660. SOCK_DGRAM, 0, net);
  2661. if (err < 0) {
  2662. pr_err("Failed to initialize the IGMP autojoin socket (err %d)\n",
  2663. err);
  2664. goto out_sock;
  2665. }
  2666. return 0;
  2667. out_sock:
  2668. remove_proc_entry("mcfilter", net->proc_net);
  2669. out_mcfilter:
  2670. remove_proc_entry("igmp", net->proc_net);
  2671. out_igmp:
  2672. return -ENOMEM;
  2673. }
  2674. static void __net_exit igmp_net_exit(struct net *net)
  2675. {
  2676. remove_proc_entry("mcfilter", net->proc_net);
  2677. remove_proc_entry("igmp", net->proc_net);
  2678. inet_ctl_sock_destroy(net->ipv4.mc_autojoin_sk);
  2679. }
  2680. static struct pernet_operations igmp_net_ops = {
  2681. .init = igmp_net_init,
  2682. .exit = igmp_net_exit,
  2683. };
  2684. #endif
  2685. static int igmp_netdev_event(struct notifier_block *this,
  2686. unsigned long event, void *ptr)
  2687. {
  2688. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  2689. struct in_device *in_dev;
  2690. switch (event) {
  2691. case NETDEV_RESEND_IGMP:
  2692. in_dev = __in_dev_get_rtnl(dev);
  2693. if (in_dev)
  2694. ip_mc_rejoin_groups(in_dev);
  2695. break;
  2696. default:
  2697. break;
  2698. }
  2699. return NOTIFY_DONE;
  2700. }
  2701. static struct notifier_block igmp_notifier = {
  2702. .notifier_call = igmp_netdev_event,
  2703. };
  2704. int __init igmp_mc_init(void)
  2705. {
  2706. #if defined(CONFIG_PROC_FS)
  2707. int err;
  2708. err = register_pernet_subsys(&igmp_net_ops);
  2709. if (err)
  2710. return err;
  2711. err = register_netdevice_notifier(&igmp_notifier);
  2712. if (err)
  2713. goto reg_notif_fail;
  2714. return 0;
  2715. reg_notif_fail:
  2716. unregister_pernet_subsys(&igmp_net_ops);
  2717. return err;
  2718. #else
  2719. return register_netdevice_notifier(&igmp_notifier);
  2720. #endif
  2721. }