addrconf.c 125 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261
  1. /*
  2. * IPv6 Address [auto]configuration
  3. * Linux INET6 implementation
  4. *
  5. * Authors:
  6. * Pedro Roque <roque@di.fc.ul.pt>
  7. * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License
  11. * as published by the Free Software Foundation; either version
  12. * 2 of the License, or (at your option) any later version.
  13. */
  14. /*
  15. * Changes:
  16. *
  17. * Janos Farkas : delete timer on ifdown
  18. * <chexum@bankinf.banki.hu>
  19. * Andi Kleen : kill double kfree on module
  20. * unload.
  21. * Maciej W. Rozycki : FDDI support
  22. * sekiya@USAGI : Don't send too many RS
  23. * packets.
  24. * yoshfuji@USAGI : Fixed interval between DAD
  25. * packets.
  26. * YOSHIFUJI Hideaki @USAGI : improved accuracy of
  27. * address validation timer.
  28. * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041)
  29. * support.
  30. * Yuji SEKIYA @USAGI : Don't assign a same IPv6
  31. * address on a same interface.
  32. * YOSHIFUJI Hideaki @USAGI : ARCnet support
  33. * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to
  34. * seq_file.
  35. * YOSHIFUJI Hideaki @USAGI : improved source address
  36. * selection; consider scope,
  37. * status etc.
  38. */
  39. #define pr_fmt(fmt) "IPv6: " fmt
  40. #include <linux/errno.h>
  41. #include <linux/types.h>
  42. #include <linux/kernel.h>
  43. #include <linux/socket.h>
  44. #include <linux/sockios.h>
  45. #include <linux/net.h>
  46. #include <linux/in6.h>
  47. #include <linux/netdevice.h>
  48. #include <linux/if_addr.h>
  49. #include <linux/if_arp.h>
  50. #include <linux/if_arcnet.h>
  51. #include <linux/if_infiniband.h>
  52. #include <linux/route.h>
  53. #include <linux/inetdevice.h>
  54. #include <linux/init.h>
  55. #include <linux/slab.h>
  56. #ifdef CONFIG_SYSCTL
  57. #include <linux/sysctl.h>
  58. #endif
  59. #include <linux/capability.h>
  60. #include <linux/delay.h>
  61. #include <linux/notifier.h>
  62. #include <linux/string.h>
  63. #include <linux/hash.h>
  64. #include <net/net_namespace.h>
  65. #include <net/sock.h>
  66. #include <net/snmp.h>
  67. #include <net/af_ieee802154.h>
  68. #include <net/firewire.h>
  69. #include <net/ipv6.h>
  70. #include <net/protocol.h>
  71. #include <net/ndisc.h>
  72. #include <net/ip6_route.h>
  73. #include <net/addrconf.h>
  74. #include <net/tcp.h>
  75. #include <net/ip.h>
  76. #include <net/netlink.h>
  77. #include <net/pkt_sched.h>
  78. #include <linux/if_tunnel.h>
  79. #include <linux/rtnetlink.h>
  80. #include <linux/netconf.h>
  81. #ifdef CONFIG_IPV6_PRIVACY
  82. #include <linux/random.h>
  83. #endif
  84. #include <linux/uaccess.h>
  85. #include <asm/unaligned.h>
  86. #include <linux/proc_fs.h>
  87. #include <linux/seq_file.h>
  88. #include <linux/export.h>
  89. /* Set to 3 to get tracing... */
  90. #define ACONF_DEBUG 2
  91. #if ACONF_DEBUG >= 3
  92. #define ADBG(x) printk x
  93. #else
  94. #define ADBG(x)
  95. #endif
  96. #define INFINITY_LIFE_TIME 0xFFFFFFFF
  97. static inline u32 cstamp_delta(unsigned long cstamp)
  98. {
  99. return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
  100. }
  101. #ifdef CONFIG_SYSCTL
  102. static void addrconf_sysctl_register(struct inet6_dev *idev);
  103. static void addrconf_sysctl_unregister(struct inet6_dev *idev);
  104. #else
  105. static inline void addrconf_sysctl_register(struct inet6_dev *idev)
  106. {
  107. }
  108. static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
  109. {
  110. }
  111. #endif
  112. #ifdef CONFIG_IPV6_PRIVACY
  113. static void __ipv6_regen_rndid(struct inet6_dev *idev);
  114. static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
  115. static void ipv6_regen_rndid(unsigned long data);
  116. #endif
  117. static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
  118. static int ipv6_count_addresses(struct inet6_dev *idev);
  119. /*
  120. * Configured unicast address hash table
  121. */
  122. static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
  123. static DEFINE_SPINLOCK(addrconf_hash_lock);
  124. static void addrconf_verify(unsigned long);
  125. static DEFINE_TIMER(addr_chk_timer, addrconf_verify, 0, 0);
  126. static DEFINE_SPINLOCK(addrconf_verify_lock);
  127. static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
  128. static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
  129. static void addrconf_type_change(struct net_device *dev,
  130. unsigned long event);
  131. static int addrconf_ifdown(struct net_device *dev, int how);
  132. static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
  133. int plen,
  134. const struct net_device *dev,
  135. u32 flags, u32 noflags);
  136. static void addrconf_dad_start(struct inet6_ifaddr *ifp);
  137. static void addrconf_dad_timer(unsigned long data);
  138. static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
  139. static void addrconf_dad_run(struct inet6_dev *idev);
  140. static void addrconf_rs_timer(unsigned long data);
  141. static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
  142. static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
  143. static void inet6_prefix_notify(int event, struct inet6_dev *idev,
  144. struct prefix_info *pinfo);
  145. static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
  146. struct net_device *dev);
  147. static struct ipv6_devconf ipv6_devconf __read_mostly = {
  148. .forwarding = 0,
  149. .hop_limit = IPV6_DEFAULT_HOPLIMIT,
  150. .mtu6 = IPV6_MIN_MTU,
  151. .accept_ra = 1,
  152. .accept_redirects = 1,
  153. .autoconf = 1,
  154. .force_mld_version = 0,
  155. .dad_transmits = 1,
  156. .rtr_solicits = MAX_RTR_SOLICITATIONS,
  157. .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
  158. .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
  159. #ifdef CONFIG_IPV6_PRIVACY
  160. .use_tempaddr = 0,
  161. .temp_valid_lft = TEMP_VALID_LIFETIME,
  162. .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
  163. .regen_max_retry = REGEN_MAX_RETRY,
  164. .max_desync_factor = MAX_DESYNC_FACTOR,
  165. #endif
  166. .max_addresses = IPV6_MAX_ADDRESSES,
  167. .accept_ra_defrtr = 1,
  168. .accept_ra_pinfo = 1,
  169. #ifdef CONFIG_IPV6_ROUTER_PREF
  170. .accept_ra_rtr_pref = 1,
  171. .rtr_probe_interval = 60 * HZ,
  172. #ifdef CONFIG_IPV6_ROUTE_INFO
  173. .accept_ra_rt_info_max_plen = 0,
  174. #endif
  175. #endif
  176. .proxy_ndp = 0,
  177. .accept_source_route = 0, /* we do not accept RH0 by default. */
  178. .disable_ipv6 = 0,
  179. .accept_dad = 1,
  180. };
  181. static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
  182. .forwarding = 0,
  183. .hop_limit = IPV6_DEFAULT_HOPLIMIT,
  184. .mtu6 = IPV6_MIN_MTU,
  185. .accept_ra = 1,
  186. .accept_redirects = 1,
  187. .autoconf = 1,
  188. .dad_transmits = 1,
  189. .rtr_solicits = MAX_RTR_SOLICITATIONS,
  190. .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
  191. .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
  192. #ifdef CONFIG_IPV6_PRIVACY
  193. .use_tempaddr = 0,
  194. .temp_valid_lft = TEMP_VALID_LIFETIME,
  195. .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
  196. .regen_max_retry = REGEN_MAX_RETRY,
  197. .max_desync_factor = MAX_DESYNC_FACTOR,
  198. #endif
  199. .max_addresses = IPV6_MAX_ADDRESSES,
  200. .accept_ra_defrtr = 1,
  201. .accept_ra_pinfo = 1,
  202. #ifdef CONFIG_IPV6_ROUTER_PREF
  203. .accept_ra_rtr_pref = 1,
  204. .rtr_probe_interval = 60 * HZ,
  205. #ifdef CONFIG_IPV6_ROUTE_INFO
  206. .accept_ra_rt_info_max_plen = 0,
  207. #endif
  208. #endif
  209. .proxy_ndp = 0,
  210. .accept_source_route = 0, /* we do not accept RH0 by default. */
  211. .disable_ipv6 = 0,
  212. .accept_dad = 1,
  213. };
  214. /* IPv6 Wildcard Address and Loopback Address defined by RFC2553 */
  215. const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT;
  216. const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
  217. const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT;
  218. const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT;
  219. const struct in6_addr in6addr_interfacelocal_allnodes = IN6ADDR_INTERFACELOCAL_ALLNODES_INIT;
  220. const struct in6_addr in6addr_interfacelocal_allrouters = IN6ADDR_INTERFACELOCAL_ALLROUTERS_INIT;
  221. const struct in6_addr in6addr_sitelocal_allrouters = IN6ADDR_SITELOCAL_ALLROUTERS_INIT;
  222. /* Check if a valid qdisc is available */
  223. static inline bool addrconf_qdisc_ok(const struct net_device *dev)
  224. {
  225. return !qdisc_tx_is_noop(dev);
  226. }
  227. static void addrconf_del_rs_timer(struct inet6_dev *idev)
  228. {
  229. if (del_timer(&idev->rs_timer))
  230. __in6_dev_put(idev);
  231. }
  232. static void addrconf_del_dad_timer(struct inet6_ifaddr *ifp)
  233. {
  234. if (del_timer(&ifp->dad_timer))
  235. __in6_ifa_put(ifp);
  236. }
  237. static void addrconf_mod_rs_timer(struct inet6_dev *idev,
  238. unsigned long when)
  239. {
  240. if (!timer_pending(&idev->rs_timer))
  241. in6_dev_hold(idev);
  242. mod_timer(&idev->rs_timer, jiffies + when);
  243. }
  244. static void addrconf_mod_dad_timer(struct inet6_ifaddr *ifp,
  245. unsigned long when)
  246. {
  247. if (!timer_pending(&ifp->dad_timer))
  248. in6_ifa_hold(ifp);
  249. mod_timer(&ifp->dad_timer, jiffies + when);
  250. }
  251. static int snmp6_alloc_dev(struct inet6_dev *idev)
  252. {
  253. if (snmp_mib_init((void __percpu **)idev->stats.ipv6,
  254. sizeof(struct ipstats_mib),
  255. __alignof__(struct ipstats_mib)) < 0)
  256. goto err_ip;
  257. idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
  258. GFP_KERNEL);
  259. if (!idev->stats.icmpv6dev)
  260. goto err_icmp;
  261. idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
  262. GFP_KERNEL);
  263. if (!idev->stats.icmpv6msgdev)
  264. goto err_icmpmsg;
  265. return 0;
  266. err_icmpmsg:
  267. kfree(idev->stats.icmpv6dev);
  268. err_icmp:
  269. snmp_mib_free((void __percpu **)idev->stats.ipv6);
  270. err_ip:
  271. return -ENOMEM;
  272. }
  273. static void snmp6_free_dev(struct inet6_dev *idev)
  274. {
  275. kfree(idev->stats.icmpv6msgdev);
  276. kfree(idev->stats.icmpv6dev);
  277. snmp_mib_free((void __percpu **)idev->stats.ipv6);
  278. }
  279. /* Nobody refers to this device, we may destroy it. */
  280. void in6_dev_finish_destroy(struct inet6_dev *idev)
  281. {
  282. struct net_device *dev = idev->dev;
  283. WARN_ON(!list_empty(&idev->addr_list));
  284. WARN_ON(idev->mc_list != NULL);
  285. WARN_ON(timer_pending(&idev->rs_timer));
  286. #ifdef NET_REFCNT_DEBUG
  287. pr_debug("%s: %s\n", __func__, dev ? dev->name : "NIL");
  288. #endif
  289. dev_put(dev);
  290. if (!idev->dead) {
  291. pr_warn("Freeing alive inet6 device %p\n", idev);
  292. return;
  293. }
  294. snmp6_free_dev(idev);
  295. kfree_rcu(idev, rcu);
  296. }
  297. EXPORT_SYMBOL(in6_dev_finish_destroy);
  298. static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
  299. {
  300. struct inet6_dev *ndev;
  301. ASSERT_RTNL();
  302. if (dev->mtu < IPV6_MIN_MTU)
  303. return NULL;
  304. ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
  305. if (ndev == NULL)
  306. return NULL;
  307. rwlock_init(&ndev->lock);
  308. ndev->dev = dev;
  309. INIT_LIST_HEAD(&ndev->addr_list);
  310. setup_timer(&ndev->rs_timer, addrconf_rs_timer,
  311. (unsigned long)ndev);
  312. memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
  313. ndev->cnf.mtu6 = dev->mtu;
  314. ndev->cnf.sysctl = NULL;
  315. ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
  316. if (ndev->nd_parms == NULL) {
  317. kfree(ndev);
  318. return NULL;
  319. }
  320. if (ndev->cnf.forwarding)
  321. dev_disable_lro(dev);
  322. /* We refer to the device */
  323. dev_hold(dev);
  324. if (snmp6_alloc_dev(ndev) < 0) {
  325. ADBG((KERN_WARNING
  326. "%s: cannot allocate memory for statistics; dev=%s.\n",
  327. __func__, dev->name));
  328. neigh_parms_release(&nd_tbl, ndev->nd_parms);
  329. dev_put(dev);
  330. kfree(ndev);
  331. return NULL;
  332. }
  333. if (snmp6_register_dev(ndev) < 0) {
  334. ADBG((KERN_WARNING
  335. "%s: cannot create /proc/net/dev_snmp6/%s\n",
  336. __func__, dev->name));
  337. neigh_parms_release(&nd_tbl, ndev->nd_parms);
  338. ndev->dead = 1;
  339. in6_dev_finish_destroy(ndev);
  340. return NULL;
  341. }
  342. /* One reference from device. We must do this before
  343. * we invoke __ipv6_regen_rndid().
  344. */
  345. in6_dev_hold(ndev);
  346. if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
  347. ndev->cnf.accept_dad = -1;
  348. #if IS_ENABLED(CONFIG_IPV6_SIT)
  349. if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
  350. pr_info("%s: Disabled Multicast RS\n", dev->name);
  351. ndev->cnf.rtr_solicits = 0;
  352. }
  353. #endif
  354. #ifdef CONFIG_IPV6_PRIVACY
  355. INIT_LIST_HEAD(&ndev->tempaddr_list);
  356. setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
  357. if ((dev->flags&IFF_LOOPBACK) ||
  358. dev->type == ARPHRD_TUNNEL ||
  359. dev->type == ARPHRD_TUNNEL6 ||
  360. dev->type == ARPHRD_SIT ||
  361. dev->type == ARPHRD_NONE) {
  362. ndev->cnf.use_tempaddr = -1;
  363. } else {
  364. in6_dev_hold(ndev);
  365. ipv6_regen_rndid((unsigned long) ndev);
  366. }
  367. #endif
  368. ndev->token = in6addr_any;
  369. if (netif_running(dev) && addrconf_qdisc_ok(dev))
  370. ndev->if_flags |= IF_READY;
  371. ipv6_mc_init_dev(ndev);
  372. ndev->tstamp = jiffies;
  373. addrconf_sysctl_register(ndev);
  374. /* protected by rtnl_lock */
  375. rcu_assign_pointer(dev->ip6_ptr, ndev);
  376. /* Join interface-local all-node multicast group */
  377. ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
  378. /* Join all-node multicast group */
  379. ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
  380. /* Join all-router multicast group if forwarding is set */
  381. if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
  382. ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
  383. return ndev;
  384. }
  385. static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
  386. {
  387. struct inet6_dev *idev;
  388. ASSERT_RTNL();
  389. idev = __in6_dev_get(dev);
  390. if (!idev) {
  391. idev = ipv6_add_dev(dev);
  392. if (!idev)
  393. return NULL;
  394. }
  395. if (dev->flags&IFF_UP)
  396. ipv6_mc_up(idev);
  397. return idev;
  398. }
  399. static int inet6_netconf_msgsize_devconf(int type)
  400. {
  401. int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
  402. + nla_total_size(4); /* NETCONFA_IFINDEX */
  403. /* type -1 is used for ALL */
  404. if (type == -1 || type == NETCONFA_FORWARDING)
  405. size += nla_total_size(4);
  406. #ifdef CONFIG_IPV6_MROUTE
  407. if (type == -1 || type == NETCONFA_MC_FORWARDING)
  408. size += nla_total_size(4);
  409. #endif
  410. return size;
  411. }
  412. static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
  413. struct ipv6_devconf *devconf, u32 portid,
  414. u32 seq, int event, unsigned int flags,
  415. int type)
  416. {
  417. struct nlmsghdr *nlh;
  418. struct netconfmsg *ncm;
  419. nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
  420. flags);
  421. if (nlh == NULL)
  422. return -EMSGSIZE;
  423. ncm = nlmsg_data(nlh);
  424. ncm->ncm_family = AF_INET6;
  425. if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
  426. goto nla_put_failure;
  427. /* type -1 is used for ALL */
  428. if ((type == -1 || type == NETCONFA_FORWARDING) &&
  429. nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
  430. goto nla_put_failure;
  431. #ifdef CONFIG_IPV6_MROUTE
  432. if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
  433. nla_put_s32(skb, NETCONFA_MC_FORWARDING,
  434. devconf->mc_forwarding) < 0)
  435. goto nla_put_failure;
  436. #endif
  437. return nlmsg_end(skb, nlh);
  438. nla_put_failure:
  439. nlmsg_cancel(skb, nlh);
  440. return -EMSGSIZE;
  441. }
  442. void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
  443. struct ipv6_devconf *devconf)
  444. {
  445. struct sk_buff *skb;
  446. int err = -ENOBUFS;
  447. skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
  448. if (skb == NULL)
  449. goto errout;
  450. err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
  451. RTM_NEWNETCONF, 0, type);
  452. if (err < 0) {
  453. /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
  454. WARN_ON(err == -EMSGSIZE);
  455. kfree_skb(skb);
  456. goto errout;
  457. }
  458. rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_ATOMIC);
  459. return;
  460. errout:
  461. rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
  462. }
  463. static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
  464. [NETCONFA_IFINDEX] = { .len = sizeof(int) },
  465. [NETCONFA_FORWARDING] = { .len = sizeof(int) },
  466. };
  467. static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
  468. struct nlmsghdr *nlh)
  469. {
  470. struct net *net = sock_net(in_skb->sk);
  471. struct nlattr *tb[NETCONFA_MAX+1];
  472. struct netconfmsg *ncm;
  473. struct sk_buff *skb;
  474. struct ipv6_devconf *devconf;
  475. struct inet6_dev *in6_dev;
  476. struct net_device *dev;
  477. int ifindex;
  478. int err;
  479. err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
  480. devconf_ipv6_policy);
  481. if (err < 0)
  482. goto errout;
  483. err = EINVAL;
  484. if (!tb[NETCONFA_IFINDEX])
  485. goto errout;
  486. ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
  487. switch (ifindex) {
  488. case NETCONFA_IFINDEX_ALL:
  489. devconf = net->ipv6.devconf_all;
  490. break;
  491. case NETCONFA_IFINDEX_DEFAULT:
  492. devconf = net->ipv6.devconf_dflt;
  493. break;
  494. default:
  495. dev = __dev_get_by_index(net, ifindex);
  496. if (dev == NULL)
  497. goto errout;
  498. in6_dev = __in6_dev_get(dev);
  499. if (in6_dev == NULL)
  500. goto errout;
  501. devconf = &in6_dev->cnf;
  502. break;
  503. }
  504. err = -ENOBUFS;
  505. skb = nlmsg_new(inet6_netconf_msgsize_devconf(-1), GFP_ATOMIC);
  506. if (skb == NULL)
  507. goto errout;
  508. err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
  509. NETLINK_CB(in_skb).portid,
  510. nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
  511. -1);
  512. if (err < 0) {
  513. /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
  514. WARN_ON(err == -EMSGSIZE);
  515. kfree_skb(skb);
  516. goto errout;
  517. }
  518. err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
  519. errout:
  520. return err;
  521. }
  522. static int inet6_netconf_dump_devconf(struct sk_buff *skb,
  523. struct netlink_callback *cb)
  524. {
  525. struct net *net = sock_net(skb->sk);
  526. int h, s_h;
  527. int idx, s_idx;
  528. struct net_device *dev;
  529. struct inet6_dev *idev;
  530. struct hlist_head *head;
  531. s_h = cb->args[0];
  532. s_idx = idx = cb->args[1];
  533. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  534. idx = 0;
  535. head = &net->dev_index_head[h];
  536. rcu_read_lock();
  537. cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
  538. net->dev_base_seq;
  539. hlist_for_each_entry_rcu(dev, head, index_hlist) {
  540. if (idx < s_idx)
  541. goto cont;
  542. idev = __in6_dev_get(dev);
  543. if (!idev)
  544. goto cont;
  545. if (inet6_netconf_fill_devconf(skb, dev->ifindex,
  546. &idev->cnf,
  547. NETLINK_CB(cb->skb).portid,
  548. cb->nlh->nlmsg_seq,
  549. RTM_NEWNETCONF,
  550. NLM_F_MULTI,
  551. -1) <= 0) {
  552. rcu_read_unlock();
  553. goto done;
  554. }
  555. nl_dump_check_consistent(cb, nlmsg_hdr(skb));
  556. cont:
  557. idx++;
  558. }
  559. rcu_read_unlock();
  560. }
  561. if (h == NETDEV_HASHENTRIES) {
  562. if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
  563. net->ipv6.devconf_all,
  564. NETLINK_CB(cb->skb).portid,
  565. cb->nlh->nlmsg_seq,
  566. RTM_NEWNETCONF, NLM_F_MULTI,
  567. -1) <= 0)
  568. goto done;
  569. else
  570. h++;
  571. }
  572. if (h == NETDEV_HASHENTRIES + 1) {
  573. if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
  574. net->ipv6.devconf_dflt,
  575. NETLINK_CB(cb->skb).portid,
  576. cb->nlh->nlmsg_seq,
  577. RTM_NEWNETCONF, NLM_F_MULTI,
  578. -1) <= 0)
  579. goto done;
  580. else
  581. h++;
  582. }
  583. done:
  584. cb->args[0] = h;
  585. cb->args[1] = idx;
  586. return skb->len;
  587. }
  588. #ifdef CONFIG_SYSCTL
  589. static void dev_forward_change(struct inet6_dev *idev)
  590. {
  591. struct net_device *dev;
  592. struct inet6_ifaddr *ifa;
  593. if (!idev)
  594. return;
  595. dev = idev->dev;
  596. if (idev->cnf.forwarding)
  597. dev_disable_lro(dev);
  598. if (dev->flags & IFF_MULTICAST) {
  599. if (idev->cnf.forwarding) {
  600. ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
  601. ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
  602. ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
  603. } else {
  604. ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
  605. ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
  606. ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
  607. }
  608. }
  609. list_for_each_entry(ifa, &idev->addr_list, if_list) {
  610. if (ifa->flags&IFA_F_TENTATIVE)
  611. continue;
  612. if (idev->cnf.forwarding)
  613. addrconf_join_anycast(ifa);
  614. else
  615. addrconf_leave_anycast(ifa);
  616. }
  617. inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING,
  618. dev->ifindex, &idev->cnf);
  619. }
  620. static void addrconf_forward_change(struct net *net, __s32 newf)
  621. {
  622. struct net_device *dev;
  623. struct inet6_dev *idev;
  624. for_each_netdev(net, dev) {
  625. idev = __in6_dev_get(dev);
  626. if (idev) {
  627. int changed = (!idev->cnf.forwarding) ^ (!newf);
  628. idev->cnf.forwarding = newf;
  629. if (changed)
  630. dev_forward_change(idev);
  631. }
  632. }
  633. }
  634. static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
  635. {
  636. struct net *net;
  637. int old;
  638. if (!rtnl_trylock())
  639. return restart_syscall();
  640. net = (struct net *)table->extra2;
  641. old = *p;
  642. *p = newf;
  643. if (p == &net->ipv6.devconf_dflt->forwarding) {
  644. if ((!newf) ^ (!old))
  645. inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
  646. NETCONFA_IFINDEX_DEFAULT,
  647. net->ipv6.devconf_dflt);
  648. rtnl_unlock();
  649. return 0;
  650. }
  651. if (p == &net->ipv6.devconf_all->forwarding) {
  652. net->ipv6.devconf_dflt->forwarding = newf;
  653. addrconf_forward_change(net, newf);
  654. if ((!newf) ^ (!old))
  655. inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
  656. NETCONFA_IFINDEX_ALL,
  657. net->ipv6.devconf_all);
  658. } else if ((!newf) ^ (!old))
  659. dev_forward_change((struct inet6_dev *)table->extra1);
  660. rtnl_unlock();
  661. if (newf)
  662. rt6_purge_dflt_routers(net);
  663. return 1;
  664. }
  665. #endif
  666. /* Nobody refers to this ifaddr, destroy it */
  667. void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
  668. {
  669. WARN_ON(!hlist_unhashed(&ifp->addr_lst));
  670. #ifdef NET_REFCNT_DEBUG
  671. pr_debug("%s\n", __func__);
  672. #endif
  673. in6_dev_put(ifp->idev);
  674. if (del_timer(&ifp->dad_timer))
  675. pr_notice("Timer is still running, when freeing ifa=%p\n", ifp);
  676. if (ifp->state != INET6_IFADDR_STATE_DEAD) {
  677. pr_warn("Freeing alive inet6 address %p\n", ifp);
  678. return;
  679. }
  680. ip6_rt_put(ifp->rt);
  681. kfree_rcu(ifp, rcu);
  682. }
  683. static void
  684. ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
  685. {
  686. struct list_head *p;
  687. int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
  688. /*
  689. * Each device address list is sorted in order of scope -
  690. * global before linklocal.
  691. */
  692. list_for_each(p, &idev->addr_list) {
  693. struct inet6_ifaddr *ifa
  694. = list_entry(p, struct inet6_ifaddr, if_list);
  695. if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
  696. break;
  697. }
  698. list_add_tail(&ifp->if_list, p);
  699. }
  700. static u32 inet6_addr_hash(const struct in6_addr *addr)
  701. {
  702. return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT);
  703. }
  704. /* On success it returns ifp with increased reference count */
  705. static struct inet6_ifaddr *
  706. ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
  707. const struct in6_addr *peer_addr, int pfxlen,
  708. int scope, u32 flags, u32 valid_lft, u32 prefered_lft)
  709. {
  710. struct inet6_ifaddr *ifa = NULL;
  711. struct rt6_info *rt;
  712. unsigned int hash;
  713. int err = 0;
  714. int addr_type = ipv6_addr_type(addr);
  715. if (addr_type == IPV6_ADDR_ANY ||
  716. addr_type & IPV6_ADDR_MULTICAST ||
  717. (!(idev->dev->flags & IFF_LOOPBACK) &&
  718. addr_type & IPV6_ADDR_LOOPBACK))
  719. return ERR_PTR(-EADDRNOTAVAIL);
  720. rcu_read_lock_bh();
  721. if (idev->dead) {
  722. err = -ENODEV; /*XXX*/
  723. goto out2;
  724. }
  725. if (idev->cnf.disable_ipv6) {
  726. err = -EACCES;
  727. goto out2;
  728. }
  729. spin_lock(&addrconf_hash_lock);
  730. /* Ignore adding duplicate addresses on an interface */
  731. if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
  732. ADBG(("ipv6_add_addr: already assigned\n"));
  733. err = -EEXIST;
  734. goto out;
  735. }
  736. ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
  737. if (ifa == NULL) {
  738. ADBG(("ipv6_add_addr: malloc failed\n"));
  739. err = -ENOBUFS;
  740. goto out;
  741. }
  742. rt = addrconf_dst_alloc(idev, addr, false);
  743. if (IS_ERR(rt)) {
  744. err = PTR_ERR(rt);
  745. goto out;
  746. }
  747. ifa->addr = *addr;
  748. if (peer_addr)
  749. ifa->peer_addr = *peer_addr;
  750. spin_lock_init(&ifa->lock);
  751. spin_lock_init(&ifa->state_lock);
  752. setup_timer(&ifa->dad_timer, addrconf_dad_timer,
  753. (unsigned long)ifa);
  754. INIT_HLIST_NODE(&ifa->addr_lst);
  755. ifa->scope = scope;
  756. ifa->prefix_len = pfxlen;
  757. ifa->flags = flags | IFA_F_TENTATIVE;
  758. ifa->valid_lft = valid_lft;
  759. ifa->prefered_lft = prefered_lft;
  760. ifa->cstamp = ifa->tstamp = jiffies;
  761. ifa->tokenized = false;
  762. ifa->rt = rt;
  763. ifa->idev = idev;
  764. in6_dev_hold(idev);
  765. /* For caller */
  766. in6_ifa_hold(ifa);
  767. /* Add to big hash table */
  768. hash = inet6_addr_hash(addr);
  769. hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
  770. spin_unlock(&addrconf_hash_lock);
  771. write_lock(&idev->lock);
  772. /* Add to inet6_dev unicast addr list. */
  773. ipv6_link_dev_addr(idev, ifa);
  774. #ifdef CONFIG_IPV6_PRIVACY
  775. if (ifa->flags&IFA_F_TEMPORARY) {
  776. list_add(&ifa->tmp_list, &idev->tempaddr_list);
  777. in6_ifa_hold(ifa);
  778. }
  779. #endif
  780. in6_ifa_hold(ifa);
  781. write_unlock(&idev->lock);
  782. out2:
  783. rcu_read_unlock_bh();
  784. if (likely(err == 0))
  785. inet6addr_notifier_call_chain(NETDEV_UP, ifa);
  786. else {
  787. kfree(ifa);
  788. ifa = ERR_PTR(err);
  789. }
  790. return ifa;
  791. out:
  792. spin_unlock(&addrconf_hash_lock);
  793. goto out2;
  794. }
  795. /* This function wants to get referenced ifp and releases it before return */
  796. static void ipv6_del_addr(struct inet6_ifaddr *ifp)
  797. {
  798. struct inet6_ifaddr *ifa, *ifn;
  799. struct inet6_dev *idev = ifp->idev;
  800. int state;
  801. int deleted = 0, onlink = 0;
  802. unsigned long expires = jiffies;
  803. spin_lock_bh(&ifp->state_lock);
  804. state = ifp->state;
  805. ifp->state = INET6_IFADDR_STATE_DEAD;
  806. spin_unlock_bh(&ifp->state_lock);
  807. if (state == INET6_IFADDR_STATE_DEAD)
  808. goto out;
  809. spin_lock_bh(&addrconf_hash_lock);
  810. hlist_del_init_rcu(&ifp->addr_lst);
  811. spin_unlock_bh(&addrconf_hash_lock);
  812. write_lock_bh(&idev->lock);
  813. #ifdef CONFIG_IPV6_PRIVACY
  814. if (ifp->flags&IFA_F_TEMPORARY) {
  815. list_del(&ifp->tmp_list);
  816. if (ifp->ifpub) {
  817. in6_ifa_put(ifp->ifpub);
  818. ifp->ifpub = NULL;
  819. }
  820. __in6_ifa_put(ifp);
  821. }
  822. #endif
  823. list_for_each_entry_safe(ifa, ifn, &idev->addr_list, if_list) {
  824. if (ifa == ifp) {
  825. list_del_init(&ifp->if_list);
  826. __in6_ifa_put(ifp);
  827. if (!(ifp->flags & IFA_F_PERMANENT) || onlink > 0)
  828. break;
  829. deleted = 1;
  830. continue;
  831. } else if (ifp->flags & IFA_F_PERMANENT) {
  832. if (ipv6_prefix_equal(&ifa->addr, &ifp->addr,
  833. ifp->prefix_len)) {
  834. if (ifa->flags & IFA_F_PERMANENT) {
  835. onlink = 1;
  836. if (deleted)
  837. break;
  838. } else {
  839. unsigned long lifetime;
  840. if (!onlink)
  841. onlink = -1;
  842. spin_lock(&ifa->lock);
  843. lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
  844. /*
  845. * Note: Because this address is
  846. * not permanent, lifetime <
  847. * LONG_MAX / HZ here.
  848. */
  849. if (time_before(expires,
  850. ifa->tstamp + lifetime * HZ))
  851. expires = ifa->tstamp + lifetime * HZ;
  852. spin_unlock(&ifa->lock);
  853. }
  854. }
  855. }
  856. }
  857. write_unlock_bh(&idev->lock);
  858. addrconf_del_dad_timer(ifp);
  859. ipv6_ifa_notify(RTM_DELADDR, ifp);
  860. inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
  861. /*
  862. * Purge or update corresponding prefix
  863. *
  864. * 1) we don't purge prefix here if address was not permanent.
  865. * prefix is managed by its own lifetime.
  866. * 2) if there're no addresses, delete prefix.
  867. * 3) if there're still other permanent address(es),
  868. * corresponding prefix is still permanent.
  869. * 4) otherwise, update prefix lifetime to the
  870. * longest valid lifetime among the corresponding
  871. * addresses on the device.
  872. * Note: subsequent RA will update lifetime.
  873. *
  874. * --yoshfuji
  875. */
  876. if ((ifp->flags & IFA_F_PERMANENT) && onlink < 1) {
  877. struct in6_addr prefix;
  878. struct rt6_info *rt;
  879. ipv6_addr_prefix(&prefix, &ifp->addr, ifp->prefix_len);
  880. rt = addrconf_get_prefix_route(&prefix,
  881. ifp->prefix_len,
  882. ifp->idev->dev,
  883. 0, RTF_GATEWAY | RTF_DEFAULT);
  884. if (rt) {
  885. if (onlink == 0) {
  886. ip6_del_rt(rt);
  887. rt = NULL;
  888. } else if (!(rt->rt6i_flags & RTF_EXPIRES)) {
  889. rt6_set_expires(rt, expires);
  890. }
  891. }
  892. ip6_rt_put(rt);
  893. }
  894. /* clean up prefsrc entries */
  895. rt6_remove_prefsrc(ifp);
  896. out:
  897. in6_ifa_put(ifp);
  898. }
  899. #ifdef CONFIG_IPV6_PRIVACY
  900. static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
  901. {
  902. struct inet6_dev *idev = ifp->idev;
  903. struct in6_addr addr, *tmpaddr;
  904. unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
  905. unsigned long regen_advance;
  906. int tmp_plen;
  907. int ret = 0;
  908. int max_addresses;
  909. u32 addr_flags;
  910. unsigned long now = jiffies;
  911. write_lock(&idev->lock);
  912. if (ift) {
  913. spin_lock_bh(&ift->lock);
  914. memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
  915. spin_unlock_bh(&ift->lock);
  916. tmpaddr = &addr;
  917. } else {
  918. tmpaddr = NULL;
  919. }
  920. retry:
  921. in6_dev_hold(idev);
  922. if (idev->cnf.use_tempaddr <= 0) {
  923. write_unlock(&idev->lock);
  924. pr_info("%s: use_tempaddr is disabled\n", __func__);
  925. in6_dev_put(idev);
  926. ret = -1;
  927. goto out;
  928. }
  929. spin_lock_bh(&ifp->lock);
  930. if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
  931. idev->cnf.use_tempaddr = -1; /*XXX*/
  932. spin_unlock_bh(&ifp->lock);
  933. write_unlock(&idev->lock);
  934. pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
  935. __func__);
  936. in6_dev_put(idev);
  937. ret = -1;
  938. goto out;
  939. }
  940. in6_ifa_hold(ifp);
  941. memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
  942. __ipv6_try_regen_rndid(idev, tmpaddr);
  943. memcpy(&addr.s6_addr[8], idev->rndid, 8);
  944. age = (now - ifp->tstamp) / HZ;
  945. tmp_valid_lft = min_t(__u32,
  946. ifp->valid_lft,
  947. idev->cnf.temp_valid_lft + age);
  948. tmp_prefered_lft = min_t(__u32,
  949. ifp->prefered_lft,
  950. idev->cnf.temp_prefered_lft + age -
  951. idev->cnf.max_desync_factor);
  952. tmp_plen = ifp->prefix_len;
  953. max_addresses = idev->cnf.max_addresses;
  954. tmp_tstamp = ifp->tstamp;
  955. spin_unlock_bh(&ifp->lock);
  956. regen_advance = idev->cnf.regen_max_retry *
  957. idev->cnf.dad_transmits *
  958. idev->nd_parms->retrans_time / HZ;
  959. write_unlock(&idev->lock);
  960. /* A temporary address is created only if this calculated Preferred
  961. * Lifetime is greater than REGEN_ADVANCE time units. In particular,
  962. * an implementation must not create a temporary address with a zero
  963. * Preferred Lifetime.
  964. */
  965. if (tmp_prefered_lft <= regen_advance) {
  966. in6_ifa_put(ifp);
  967. in6_dev_put(idev);
  968. ret = -1;
  969. goto out;
  970. }
  971. addr_flags = IFA_F_TEMPORARY;
  972. /* set in addrconf_prefix_rcv() */
  973. if (ifp->flags & IFA_F_OPTIMISTIC)
  974. addr_flags |= IFA_F_OPTIMISTIC;
  975. ift = !max_addresses ||
  976. ipv6_count_addresses(idev) < max_addresses ?
  977. ipv6_add_addr(idev, &addr, NULL, tmp_plen,
  978. ipv6_addr_scope(&addr), addr_flags,
  979. tmp_valid_lft, tmp_prefered_lft) : NULL;
  980. if (IS_ERR_OR_NULL(ift)) {
  981. in6_ifa_put(ifp);
  982. in6_dev_put(idev);
  983. pr_info("%s: retry temporary address regeneration\n", __func__);
  984. tmpaddr = &addr;
  985. write_lock(&idev->lock);
  986. goto retry;
  987. }
  988. spin_lock_bh(&ift->lock);
  989. ift->ifpub = ifp;
  990. ift->cstamp = now;
  991. ift->tstamp = tmp_tstamp;
  992. spin_unlock_bh(&ift->lock);
  993. addrconf_dad_start(ift);
  994. in6_ifa_put(ift);
  995. in6_dev_put(idev);
  996. out:
  997. return ret;
  998. }
  999. #endif
  1000. /*
  1001. * Choose an appropriate source address (RFC3484)
  1002. */
  1003. enum {
  1004. IPV6_SADDR_RULE_INIT = 0,
  1005. IPV6_SADDR_RULE_LOCAL,
  1006. IPV6_SADDR_RULE_SCOPE,
  1007. IPV6_SADDR_RULE_PREFERRED,
  1008. #ifdef CONFIG_IPV6_MIP6
  1009. IPV6_SADDR_RULE_HOA,
  1010. #endif
  1011. IPV6_SADDR_RULE_OIF,
  1012. IPV6_SADDR_RULE_LABEL,
  1013. #ifdef CONFIG_IPV6_PRIVACY
  1014. IPV6_SADDR_RULE_PRIVACY,
  1015. #endif
  1016. IPV6_SADDR_RULE_ORCHID,
  1017. IPV6_SADDR_RULE_PREFIX,
  1018. IPV6_SADDR_RULE_MAX
  1019. };
  1020. struct ipv6_saddr_score {
  1021. int rule;
  1022. int addr_type;
  1023. struct inet6_ifaddr *ifa;
  1024. DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
  1025. int scopedist;
  1026. int matchlen;
  1027. };
  1028. struct ipv6_saddr_dst {
  1029. const struct in6_addr *addr;
  1030. int ifindex;
  1031. int scope;
  1032. int label;
  1033. unsigned int prefs;
  1034. };
  1035. static inline int ipv6_saddr_preferred(int type)
  1036. {
  1037. if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
  1038. return 1;
  1039. return 0;
  1040. }
  1041. static int ipv6_get_saddr_eval(struct net *net,
  1042. struct ipv6_saddr_score *score,
  1043. struct ipv6_saddr_dst *dst,
  1044. int i)
  1045. {
  1046. int ret;
  1047. if (i <= score->rule) {
  1048. switch (i) {
  1049. case IPV6_SADDR_RULE_SCOPE:
  1050. ret = score->scopedist;
  1051. break;
  1052. case IPV6_SADDR_RULE_PREFIX:
  1053. ret = score->matchlen;
  1054. break;
  1055. default:
  1056. ret = !!test_bit(i, score->scorebits);
  1057. }
  1058. goto out;
  1059. }
  1060. switch (i) {
  1061. case IPV6_SADDR_RULE_INIT:
  1062. /* Rule 0: remember if hiscore is not ready yet */
  1063. ret = !!score->ifa;
  1064. break;
  1065. case IPV6_SADDR_RULE_LOCAL:
  1066. /* Rule 1: Prefer same address */
  1067. ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
  1068. break;
  1069. case IPV6_SADDR_RULE_SCOPE:
  1070. /* Rule 2: Prefer appropriate scope
  1071. *
  1072. * ret
  1073. * ^
  1074. * -1 | d 15
  1075. * ---+--+-+---> scope
  1076. * |
  1077. * | d is scope of the destination.
  1078. * B-d | \
  1079. * | \ <- smaller scope is better if
  1080. * B-15 | \ if scope is enough for destinaion.
  1081. * | ret = B - scope (-1 <= scope >= d <= 15).
  1082. * d-C-1 | /
  1083. * |/ <- greater is better
  1084. * -C / if scope is not enough for destination.
  1085. * /| ret = scope - C (-1 <= d < scope <= 15).
  1086. *
  1087. * d - C - 1 < B -15 (for all -1 <= d <= 15).
  1088. * C > d + 14 - B >= 15 + 14 - B = 29 - B.
  1089. * Assume B = 0 and we get C > 29.
  1090. */
  1091. ret = __ipv6_addr_src_scope(score->addr_type);
  1092. if (ret >= dst->scope)
  1093. ret = -ret;
  1094. else
  1095. ret -= 128; /* 30 is enough */
  1096. score->scopedist = ret;
  1097. break;
  1098. case IPV6_SADDR_RULE_PREFERRED:
  1099. /* Rule 3: Avoid deprecated and optimistic addresses */
  1100. ret = ipv6_saddr_preferred(score->addr_type) ||
  1101. !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
  1102. break;
  1103. #ifdef CONFIG_IPV6_MIP6
  1104. case IPV6_SADDR_RULE_HOA:
  1105. {
  1106. /* Rule 4: Prefer home address */
  1107. int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
  1108. ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
  1109. break;
  1110. }
  1111. #endif
  1112. case IPV6_SADDR_RULE_OIF:
  1113. /* Rule 5: Prefer outgoing interface */
  1114. ret = (!dst->ifindex ||
  1115. dst->ifindex == score->ifa->idev->dev->ifindex);
  1116. break;
  1117. case IPV6_SADDR_RULE_LABEL:
  1118. /* Rule 6: Prefer matching label */
  1119. ret = ipv6_addr_label(net,
  1120. &score->ifa->addr, score->addr_type,
  1121. score->ifa->idev->dev->ifindex) == dst->label;
  1122. break;
  1123. #ifdef CONFIG_IPV6_PRIVACY
  1124. case IPV6_SADDR_RULE_PRIVACY:
  1125. {
  1126. /* Rule 7: Prefer public address
  1127. * Note: prefer temporary address if use_tempaddr >= 2
  1128. */
  1129. int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
  1130. !!(dst->prefs & IPV6_PREFER_SRC_TMP) :
  1131. score->ifa->idev->cnf.use_tempaddr >= 2;
  1132. ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
  1133. break;
  1134. }
  1135. #endif
  1136. case IPV6_SADDR_RULE_ORCHID:
  1137. /* Rule 8-: Prefer ORCHID vs ORCHID or
  1138. * non-ORCHID vs non-ORCHID
  1139. */
  1140. ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
  1141. ipv6_addr_orchid(dst->addr));
  1142. break;
  1143. case IPV6_SADDR_RULE_PREFIX:
  1144. /* Rule 8: Use longest matching prefix */
  1145. ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
  1146. if (ret > score->ifa->prefix_len)
  1147. ret = score->ifa->prefix_len;
  1148. score->matchlen = ret;
  1149. break;
  1150. default:
  1151. ret = 0;
  1152. }
  1153. if (ret)
  1154. __set_bit(i, score->scorebits);
  1155. score->rule = i;
  1156. out:
  1157. return ret;
  1158. }
  1159. int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
  1160. const struct in6_addr *daddr, unsigned int prefs,
  1161. struct in6_addr *saddr)
  1162. {
  1163. struct ipv6_saddr_score scores[2],
  1164. *score = &scores[0], *hiscore = &scores[1];
  1165. struct ipv6_saddr_dst dst;
  1166. struct net_device *dev;
  1167. int dst_type;
  1168. dst_type = __ipv6_addr_type(daddr);
  1169. dst.addr = daddr;
  1170. dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
  1171. dst.scope = __ipv6_addr_src_scope(dst_type);
  1172. dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
  1173. dst.prefs = prefs;
  1174. hiscore->rule = -1;
  1175. hiscore->ifa = NULL;
  1176. rcu_read_lock();
  1177. for_each_netdev_rcu(net, dev) {
  1178. struct inet6_dev *idev;
  1179. /* Candidate Source Address (section 4)
  1180. * - multicast and link-local destination address,
  1181. * the set of candidate source address MUST only
  1182. * include addresses assigned to interfaces
  1183. * belonging to the same link as the outgoing
  1184. * interface.
  1185. * (- For site-local destination addresses, the
  1186. * set of candidate source addresses MUST only
  1187. * include addresses assigned to interfaces
  1188. * belonging to the same site as the outgoing
  1189. * interface.)
  1190. */
  1191. if (((dst_type & IPV6_ADDR_MULTICAST) ||
  1192. dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) &&
  1193. dst.ifindex && dev->ifindex != dst.ifindex)
  1194. continue;
  1195. idev = __in6_dev_get(dev);
  1196. if (!idev)
  1197. continue;
  1198. read_lock_bh(&idev->lock);
  1199. list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
  1200. int i;
  1201. /*
  1202. * - Tentative Address (RFC2462 section 5.4)
  1203. * - A tentative address is not considered
  1204. * "assigned to an interface" in the traditional
  1205. * sense, unless it is also flagged as optimistic.
  1206. * - Candidate Source Address (section 4)
  1207. * - In any case, anycast addresses, multicast
  1208. * addresses, and the unspecified address MUST
  1209. * NOT be included in a candidate set.
  1210. */
  1211. if ((score->ifa->flags & IFA_F_TENTATIVE) &&
  1212. (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
  1213. continue;
  1214. score->addr_type = __ipv6_addr_type(&score->ifa->addr);
  1215. if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
  1216. score->addr_type & IPV6_ADDR_MULTICAST)) {
  1217. LIMIT_NETDEBUG(KERN_DEBUG
  1218. "ADDRCONF: unspecified / multicast address "
  1219. "assigned as unicast address on %s",
  1220. dev->name);
  1221. continue;
  1222. }
  1223. score->rule = -1;
  1224. bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
  1225. for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
  1226. int minihiscore, miniscore;
  1227. minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i);
  1228. miniscore = ipv6_get_saddr_eval(net, score, &dst, i);
  1229. if (minihiscore > miniscore) {
  1230. if (i == IPV6_SADDR_RULE_SCOPE &&
  1231. score->scopedist > 0) {
  1232. /*
  1233. * special case:
  1234. * each remaining entry
  1235. * has too small (not enough)
  1236. * scope, because ifa entries
  1237. * are sorted by their scope
  1238. * values.
  1239. */
  1240. goto try_nextdev;
  1241. }
  1242. break;
  1243. } else if (minihiscore < miniscore) {
  1244. if (hiscore->ifa)
  1245. in6_ifa_put(hiscore->ifa);
  1246. in6_ifa_hold(score->ifa);
  1247. swap(hiscore, score);
  1248. /* restore our iterator */
  1249. score->ifa = hiscore->ifa;
  1250. break;
  1251. }
  1252. }
  1253. }
  1254. try_nextdev:
  1255. read_unlock_bh(&idev->lock);
  1256. }
  1257. rcu_read_unlock();
  1258. if (!hiscore->ifa)
  1259. return -EADDRNOTAVAIL;
  1260. *saddr = hiscore->ifa->addr;
  1261. in6_ifa_put(hiscore->ifa);
  1262. return 0;
  1263. }
  1264. EXPORT_SYMBOL(ipv6_dev_get_saddr);
  1265. int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
  1266. unsigned char banned_flags)
  1267. {
  1268. struct inet6_ifaddr *ifp;
  1269. int err = -EADDRNOTAVAIL;
  1270. list_for_each_entry(ifp, &idev->addr_list, if_list) {
  1271. if (ifp->scope == IFA_LINK &&
  1272. !(ifp->flags & banned_flags)) {
  1273. *addr = ifp->addr;
  1274. err = 0;
  1275. break;
  1276. }
  1277. }
  1278. return err;
  1279. }
  1280. int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
  1281. unsigned char banned_flags)
  1282. {
  1283. struct inet6_dev *idev;
  1284. int err = -EADDRNOTAVAIL;
  1285. rcu_read_lock();
  1286. idev = __in6_dev_get(dev);
  1287. if (idev) {
  1288. read_lock_bh(&idev->lock);
  1289. err = __ipv6_get_lladdr(idev, addr, banned_flags);
  1290. read_unlock_bh(&idev->lock);
  1291. }
  1292. rcu_read_unlock();
  1293. return err;
  1294. }
  1295. static int ipv6_count_addresses(struct inet6_dev *idev)
  1296. {
  1297. int cnt = 0;
  1298. struct inet6_ifaddr *ifp;
  1299. read_lock_bh(&idev->lock);
  1300. list_for_each_entry(ifp, &idev->addr_list, if_list)
  1301. cnt++;
  1302. read_unlock_bh(&idev->lock);
  1303. return cnt;
  1304. }
  1305. int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
  1306. const struct net_device *dev, int strict)
  1307. {
  1308. struct inet6_ifaddr *ifp;
  1309. unsigned int hash = inet6_addr_hash(addr);
  1310. rcu_read_lock_bh();
  1311. hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
  1312. if (!net_eq(dev_net(ifp->idev->dev), net))
  1313. continue;
  1314. if (ipv6_addr_equal(&ifp->addr, addr) &&
  1315. !(ifp->flags&IFA_F_TENTATIVE) &&
  1316. (dev == NULL || ifp->idev->dev == dev ||
  1317. !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
  1318. rcu_read_unlock_bh();
  1319. return 1;
  1320. }
  1321. }
  1322. rcu_read_unlock_bh();
  1323. return 0;
  1324. }
  1325. EXPORT_SYMBOL(ipv6_chk_addr);
  1326. static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
  1327. struct net_device *dev)
  1328. {
  1329. unsigned int hash = inet6_addr_hash(addr);
  1330. struct inet6_ifaddr *ifp;
  1331. hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
  1332. if (!net_eq(dev_net(ifp->idev->dev), net))
  1333. continue;
  1334. if (ipv6_addr_equal(&ifp->addr, addr)) {
  1335. if (dev == NULL || ifp->idev->dev == dev)
  1336. return true;
  1337. }
  1338. }
  1339. return false;
  1340. }
  1341. int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
  1342. {
  1343. struct inet6_dev *idev;
  1344. struct inet6_ifaddr *ifa;
  1345. int onlink;
  1346. onlink = 0;
  1347. rcu_read_lock();
  1348. idev = __in6_dev_get(dev);
  1349. if (idev) {
  1350. read_lock_bh(&idev->lock);
  1351. list_for_each_entry(ifa, &idev->addr_list, if_list) {
  1352. onlink = ipv6_prefix_equal(addr, &ifa->addr,
  1353. ifa->prefix_len);
  1354. if (onlink)
  1355. break;
  1356. }
  1357. read_unlock_bh(&idev->lock);
  1358. }
  1359. rcu_read_unlock();
  1360. return onlink;
  1361. }
  1362. EXPORT_SYMBOL(ipv6_chk_prefix);
  1363. struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
  1364. struct net_device *dev, int strict)
  1365. {
  1366. struct inet6_ifaddr *ifp, *result = NULL;
  1367. unsigned int hash = inet6_addr_hash(addr);
  1368. rcu_read_lock_bh();
  1369. hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
  1370. if (!net_eq(dev_net(ifp->idev->dev), net))
  1371. continue;
  1372. if (ipv6_addr_equal(&ifp->addr, addr)) {
  1373. if (dev == NULL || ifp->idev->dev == dev ||
  1374. !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
  1375. result = ifp;
  1376. in6_ifa_hold(ifp);
  1377. break;
  1378. }
  1379. }
  1380. }
  1381. rcu_read_unlock_bh();
  1382. return result;
  1383. }
  1384. /* Gets referenced address, destroys ifaddr */
  1385. static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
  1386. {
  1387. if (ifp->flags&IFA_F_PERMANENT) {
  1388. spin_lock_bh(&ifp->lock);
  1389. addrconf_del_dad_timer(ifp);
  1390. ifp->flags |= IFA_F_TENTATIVE;
  1391. if (dad_failed)
  1392. ifp->flags |= IFA_F_DADFAILED;
  1393. spin_unlock_bh(&ifp->lock);
  1394. if (dad_failed)
  1395. ipv6_ifa_notify(0, ifp);
  1396. in6_ifa_put(ifp);
  1397. #ifdef CONFIG_IPV6_PRIVACY
  1398. } else if (ifp->flags&IFA_F_TEMPORARY) {
  1399. struct inet6_ifaddr *ifpub;
  1400. spin_lock_bh(&ifp->lock);
  1401. ifpub = ifp->ifpub;
  1402. if (ifpub) {
  1403. in6_ifa_hold(ifpub);
  1404. spin_unlock_bh(&ifp->lock);
  1405. ipv6_create_tempaddr(ifpub, ifp);
  1406. in6_ifa_put(ifpub);
  1407. } else {
  1408. spin_unlock_bh(&ifp->lock);
  1409. }
  1410. ipv6_del_addr(ifp);
  1411. #endif
  1412. } else
  1413. ipv6_del_addr(ifp);
  1414. }
  1415. static int addrconf_dad_end(struct inet6_ifaddr *ifp)
  1416. {
  1417. int err = -ENOENT;
  1418. spin_lock(&ifp->state_lock);
  1419. if (ifp->state == INET6_IFADDR_STATE_DAD) {
  1420. ifp->state = INET6_IFADDR_STATE_POSTDAD;
  1421. err = 0;
  1422. }
  1423. spin_unlock(&ifp->state_lock);
  1424. return err;
  1425. }
  1426. void addrconf_dad_failure(struct inet6_ifaddr *ifp)
  1427. {
  1428. struct inet6_dev *idev = ifp->idev;
  1429. if (addrconf_dad_end(ifp)) {
  1430. in6_ifa_put(ifp);
  1431. return;
  1432. }
  1433. net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n",
  1434. ifp->idev->dev->name, &ifp->addr);
  1435. if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
  1436. struct in6_addr addr;
  1437. addr.s6_addr32[0] = htonl(0xfe800000);
  1438. addr.s6_addr32[1] = 0;
  1439. if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
  1440. ipv6_addr_equal(&ifp->addr, &addr)) {
  1441. /* DAD failed for link-local based on MAC address */
  1442. idev->cnf.disable_ipv6 = 1;
  1443. pr_info("%s: IPv6 being disabled!\n",
  1444. ifp->idev->dev->name);
  1445. }
  1446. }
  1447. addrconf_dad_stop(ifp, 1);
  1448. }
  1449. /* Join to solicited addr multicast group. */
  1450. void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
  1451. {
  1452. struct in6_addr maddr;
  1453. if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
  1454. return;
  1455. addrconf_addr_solict_mult(addr, &maddr);
  1456. ipv6_dev_mc_inc(dev, &maddr);
  1457. }
  1458. void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
  1459. {
  1460. struct in6_addr maddr;
  1461. if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
  1462. return;
  1463. addrconf_addr_solict_mult(addr, &maddr);
  1464. __ipv6_dev_mc_dec(idev, &maddr);
  1465. }
  1466. static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
  1467. {
  1468. struct in6_addr addr;
  1469. if (ifp->prefix_len == 127) /* RFC 6164 */
  1470. return;
  1471. ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
  1472. if (ipv6_addr_any(&addr))
  1473. return;
  1474. ipv6_dev_ac_inc(ifp->idev->dev, &addr);
  1475. }
  1476. static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
  1477. {
  1478. struct in6_addr addr;
  1479. if (ifp->prefix_len == 127) /* RFC 6164 */
  1480. return;
  1481. ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
  1482. if (ipv6_addr_any(&addr))
  1483. return;
  1484. __ipv6_dev_ac_dec(ifp->idev, &addr);
  1485. }
  1486. static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
  1487. {
  1488. if (dev->addr_len != ETH_ALEN)
  1489. return -1;
  1490. memcpy(eui, dev->dev_addr, 3);
  1491. memcpy(eui + 5, dev->dev_addr + 3, 3);
  1492. /*
  1493. * The zSeries OSA network cards can be shared among various
  1494. * OS instances, but the OSA cards have only one MAC address.
  1495. * This leads to duplicate address conflicts in conjunction
  1496. * with IPv6 if more than one instance uses the same card.
  1497. *
  1498. * The driver for these cards can deliver a unique 16-bit
  1499. * identifier for each instance sharing the same card. It is
  1500. * placed instead of 0xFFFE in the interface identifier. The
  1501. * "u" bit of the interface identifier is not inverted in this
  1502. * case. Hence the resulting interface identifier has local
  1503. * scope according to RFC2373.
  1504. */
  1505. if (dev->dev_id) {
  1506. eui[3] = (dev->dev_id >> 8) & 0xFF;
  1507. eui[4] = dev->dev_id & 0xFF;
  1508. } else {
  1509. eui[3] = 0xFF;
  1510. eui[4] = 0xFE;
  1511. eui[0] ^= 2;
  1512. }
  1513. return 0;
  1514. }
  1515. static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev)
  1516. {
  1517. if (dev->addr_len != IEEE802154_ADDR_LEN)
  1518. return -1;
  1519. memcpy(eui, dev->dev_addr, 8);
  1520. eui[0] ^= 2;
  1521. return 0;
  1522. }
  1523. static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
  1524. {
  1525. union fwnet_hwaddr *ha;
  1526. if (dev->addr_len != FWNET_ALEN)
  1527. return -1;
  1528. ha = (union fwnet_hwaddr *)dev->dev_addr;
  1529. memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
  1530. eui[0] ^= 2;
  1531. return 0;
  1532. }
  1533. static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
  1534. {
  1535. /* XXX: inherit EUI-64 from other interface -- yoshfuji */
  1536. if (dev->addr_len != ARCNET_ALEN)
  1537. return -1;
  1538. memset(eui, 0, 7);
  1539. eui[7] = *(u8 *)dev->dev_addr;
  1540. return 0;
  1541. }
  1542. static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
  1543. {
  1544. if (dev->addr_len != INFINIBAND_ALEN)
  1545. return -1;
  1546. memcpy(eui, dev->dev_addr + 12, 8);
  1547. eui[0] |= 2;
  1548. return 0;
  1549. }
  1550. static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
  1551. {
  1552. if (addr == 0)
  1553. return -1;
  1554. eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
  1555. ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
  1556. ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
  1557. ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
  1558. ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
  1559. ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
  1560. eui[1] = 0;
  1561. eui[2] = 0x5E;
  1562. eui[3] = 0xFE;
  1563. memcpy(eui + 4, &addr, 4);
  1564. return 0;
  1565. }
  1566. static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
  1567. {
  1568. if (dev->priv_flags & IFF_ISATAP)
  1569. return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
  1570. return -1;
  1571. }
  1572. static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
  1573. {
  1574. return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
  1575. }
  1576. static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
  1577. {
  1578. switch (dev->type) {
  1579. case ARPHRD_ETHER:
  1580. case ARPHRD_FDDI:
  1581. return addrconf_ifid_eui48(eui, dev);
  1582. case ARPHRD_ARCNET:
  1583. return addrconf_ifid_arcnet(eui, dev);
  1584. case ARPHRD_INFINIBAND:
  1585. return addrconf_ifid_infiniband(eui, dev);
  1586. case ARPHRD_SIT:
  1587. return addrconf_ifid_sit(eui, dev);
  1588. case ARPHRD_IPGRE:
  1589. return addrconf_ifid_gre(eui, dev);
  1590. case ARPHRD_IEEE802154:
  1591. return addrconf_ifid_eui64(eui, dev);
  1592. case ARPHRD_IEEE1394:
  1593. return addrconf_ifid_ieee1394(eui, dev);
  1594. }
  1595. return -1;
  1596. }
  1597. static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
  1598. {
  1599. int err = -1;
  1600. struct inet6_ifaddr *ifp;
  1601. read_lock_bh(&idev->lock);
  1602. list_for_each_entry(ifp, &idev->addr_list, if_list) {
  1603. if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
  1604. memcpy(eui, ifp->addr.s6_addr+8, 8);
  1605. err = 0;
  1606. break;
  1607. }
  1608. }
  1609. read_unlock_bh(&idev->lock);
  1610. return err;
  1611. }
  1612. #ifdef CONFIG_IPV6_PRIVACY
  1613. /* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
  1614. static void __ipv6_regen_rndid(struct inet6_dev *idev)
  1615. {
  1616. regen:
  1617. get_random_bytes(idev->rndid, sizeof(idev->rndid));
  1618. idev->rndid[0] &= ~0x02;
  1619. /*
  1620. * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
  1621. * check if generated address is not inappropriate
  1622. *
  1623. * - Reserved subnet anycast (RFC 2526)
  1624. * 11111101 11....11 1xxxxxxx
  1625. * - ISATAP (RFC4214) 6.1
  1626. * 00-00-5E-FE-xx-xx-xx-xx
  1627. * - value 0
  1628. * - XXX: already assigned to an address on the device
  1629. */
  1630. if (idev->rndid[0] == 0xfd &&
  1631. (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
  1632. (idev->rndid[7]&0x80))
  1633. goto regen;
  1634. if ((idev->rndid[0]|idev->rndid[1]) == 0) {
  1635. if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
  1636. goto regen;
  1637. if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
  1638. goto regen;
  1639. }
  1640. }
  1641. static void ipv6_regen_rndid(unsigned long data)
  1642. {
  1643. struct inet6_dev *idev = (struct inet6_dev *) data;
  1644. unsigned long expires;
  1645. rcu_read_lock_bh();
  1646. write_lock_bh(&idev->lock);
  1647. if (idev->dead)
  1648. goto out;
  1649. __ipv6_regen_rndid(idev);
  1650. expires = jiffies +
  1651. idev->cnf.temp_prefered_lft * HZ -
  1652. idev->cnf.regen_max_retry * idev->cnf.dad_transmits * idev->nd_parms->retrans_time -
  1653. idev->cnf.max_desync_factor * HZ;
  1654. if (time_before(expires, jiffies)) {
  1655. pr_warn("%s: too short regeneration interval; timer disabled for %s\n",
  1656. __func__, idev->dev->name);
  1657. goto out;
  1658. }
  1659. if (!mod_timer(&idev->regen_timer, expires))
  1660. in6_dev_hold(idev);
  1661. out:
  1662. write_unlock_bh(&idev->lock);
  1663. rcu_read_unlock_bh();
  1664. in6_dev_put(idev);
  1665. }
  1666. static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
  1667. {
  1668. if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
  1669. __ipv6_regen_rndid(idev);
  1670. }
  1671. #endif
  1672. /*
  1673. * Add prefix route.
  1674. */
  1675. static void
  1676. addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
  1677. unsigned long expires, u32 flags)
  1678. {
  1679. struct fib6_config cfg = {
  1680. .fc_table = RT6_TABLE_PREFIX,
  1681. .fc_metric = IP6_RT_PRIO_ADDRCONF,
  1682. .fc_ifindex = dev->ifindex,
  1683. .fc_expires = expires,
  1684. .fc_dst_len = plen,
  1685. .fc_flags = RTF_UP | flags,
  1686. .fc_nlinfo.nl_net = dev_net(dev),
  1687. .fc_protocol = RTPROT_KERNEL,
  1688. };
  1689. cfg.fc_dst = *pfx;
  1690. /* Prevent useless cloning on PtP SIT.
  1691. This thing is done here expecting that the whole
  1692. class of non-broadcast devices need not cloning.
  1693. */
  1694. #if IS_ENABLED(CONFIG_IPV6_SIT)
  1695. if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
  1696. cfg.fc_flags |= RTF_NONEXTHOP;
  1697. #endif
  1698. ip6_route_add(&cfg);
  1699. }
  1700. static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
  1701. int plen,
  1702. const struct net_device *dev,
  1703. u32 flags, u32 noflags)
  1704. {
  1705. struct fib6_node *fn;
  1706. struct rt6_info *rt = NULL;
  1707. struct fib6_table *table;
  1708. table = fib6_get_table(dev_net(dev), RT6_TABLE_PREFIX);
  1709. if (table == NULL)
  1710. return NULL;
  1711. read_lock_bh(&table->tb6_lock);
  1712. fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0);
  1713. if (!fn)
  1714. goto out;
  1715. for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
  1716. if (rt->dst.dev->ifindex != dev->ifindex)
  1717. continue;
  1718. if ((rt->rt6i_flags & flags) != flags)
  1719. continue;
  1720. if ((rt->rt6i_flags & noflags) != 0)
  1721. continue;
  1722. dst_hold(&rt->dst);
  1723. break;
  1724. }
  1725. out:
  1726. read_unlock_bh(&table->tb6_lock);
  1727. return rt;
  1728. }
  1729. /* Create "default" multicast route to the interface */
  1730. static void addrconf_add_mroute(struct net_device *dev)
  1731. {
  1732. struct fib6_config cfg = {
  1733. .fc_table = RT6_TABLE_LOCAL,
  1734. .fc_metric = IP6_RT_PRIO_ADDRCONF,
  1735. .fc_ifindex = dev->ifindex,
  1736. .fc_dst_len = 8,
  1737. .fc_flags = RTF_UP,
  1738. .fc_nlinfo.nl_net = dev_net(dev),
  1739. };
  1740. ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
  1741. ip6_route_add(&cfg);
  1742. }
  1743. #if IS_ENABLED(CONFIG_IPV6_SIT)
  1744. static void sit_route_add(struct net_device *dev)
  1745. {
  1746. struct fib6_config cfg = {
  1747. .fc_table = RT6_TABLE_MAIN,
  1748. .fc_metric = IP6_RT_PRIO_ADDRCONF,
  1749. .fc_ifindex = dev->ifindex,
  1750. .fc_dst_len = 96,
  1751. .fc_flags = RTF_UP | RTF_NONEXTHOP,
  1752. .fc_nlinfo.nl_net = dev_net(dev),
  1753. };
  1754. /* prefix length - 96 bits "::d.d.d.d" */
  1755. ip6_route_add(&cfg);
  1756. }
  1757. #endif
  1758. static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
  1759. {
  1760. struct inet6_dev *idev;
  1761. ASSERT_RTNL();
  1762. idev = ipv6_find_idev(dev);
  1763. if (!idev)
  1764. return ERR_PTR(-ENOBUFS);
  1765. if (idev->cnf.disable_ipv6)
  1766. return ERR_PTR(-EACCES);
  1767. /* Add default multicast route */
  1768. if (!(dev->flags & IFF_LOOPBACK))
  1769. addrconf_add_mroute(dev);
  1770. return idev;
  1771. }
  1772. void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
  1773. {
  1774. struct prefix_info *pinfo;
  1775. __u32 valid_lft;
  1776. __u32 prefered_lft;
  1777. int addr_type;
  1778. struct inet6_dev *in6_dev;
  1779. struct net *net = dev_net(dev);
  1780. pinfo = (struct prefix_info *) opt;
  1781. if (len < sizeof(struct prefix_info)) {
  1782. ADBG(("addrconf: prefix option too short\n"));
  1783. return;
  1784. }
  1785. /*
  1786. * Validation checks ([ADDRCONF], page 19)
  1787. */
  1788. addr_type = ipv6_addr_type(&pinfo->prefix);
  1789. if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
  1790. return;
  1791. valid_lft = ntohl(pinfo->valid);
  1792. prefered_lft = ntohl(pinfo->prefered);
  1793. if (prefered_lft > valid_lft) {
  1794. net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
  1795. return;
  1796. }
  1797. in6_dev = in6_dev_get(dev);
  1798. if (in6_dev == NULL) {
  1799. net_dbg_ratelimited("addrconf: device %s not configured\n",
  1800. dev->name);
  1801. return;
  1802. }
  1803. /*
  1804. * Two things going on here:
  1805. * 1) Add routes for on-link prefixes
  1806. * 2) Configure prefixes with the auto flag set
  1807. */
  1808. if (pinfo->onlink) {
  1809. struct rt6_info *rt;
  1810. unsigned long rt_expires;
  1811. /* Avoid arithmetic overflow. Really, we could
  1812. * save rt_expires in seconds, likely valid_lft,
  1813. * but it would require division in fib gc, that it
  1814. * not good.
  1815. */
  1816. if (HZ > USER_HZ)
  1817. rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
  1818. else
  1819. rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
  1820. if (addrconf_finite_timeout(rt_expires))
  1821. rt_expires *= HZ;
  1822. rt = addrconf_get_prefix_route(&pinfo->prefix,
  1823. pinfo->prefix_len,
  1824. dev,
  1825. RTF_ADDRCONF | RTF_PREFIX_RT,
  1826. RTF_GATEWAY | RTF_DEFAULT);
  1827. if (rt) {
  1828. /* Autoconf prefix route */
  1829. if (valid_lft == 0) {
  1830. ip6_del_rt(rt);
  1831. rt = NULL;
  1832. } else if (addrconf_finite_timeout(rt_expires)) {
  1833. /* not infinity */
  1834. rt6_set_expires(rt, jiffies + rt_expires);
  1835. } else {
  1836. rt6_clean_expires(rt);
  1837. }
  1838. } else if (valid_lft) {
  1839. clock_t expires = 0;
  1840. int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
  1841. if (addrconf_finite_timeout(rt_expires)) {
  1842. /* not infinity */
  1843. flags |= RTF_EXPIRES;
  1844. expires = jiffies_to_clock_t(rt_expires);
  1845. }
  1846. addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
  1847. dev, expires, flags);
  1848. }
  1849. ip6_rt_put(rt);
  1850. }
  1851. /* Try to figure out our local address for this prefix */
  1852. if (pinfo->autoconf && in6_dev->cnf.autoconf) {
  1853. struct inet6_ifaddr *ifp;
  1854. struct in6_addr addr;
  1855. int create = 0, update_lft = 0;
  1856. bool tokenized = false;
  1857. if (pinfo->prefix_len == 64) {
  1858. memcpy(&addr, &pinfo->prefix, 8);
  1859. if (!ipv6_addr_any(&in6_dev->token)) {
  1860. read_lock_bh(&in6_dev->lock);
  1861. memcpy(addr.s6_addr + 8,
  1862. in6_dev->token.s6_addr + 8, 8);
  1863. read_unlock_bh(&in6_dev->lock);
  1864. tokenized = true;
  1865. } else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
  1866. ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
  1867. in6_dev_put(in6_dev);
  1868. return;
  1869. }
  1870. goto ok;
  1871. }
  1872. net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
  1873. pinfo->prefix_len);
  1874. in6_dev_put(in6_dev);
  1875. return;
  1876. ok:
  1877. ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
  1878. if (ifp == NULL && valid_lft) {
  1879. int max_addresses = in6_dev->cnf.max_addresses;
  1880. u32 addr_flags = 0;
  1881. #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
  1882. if (in6_dev->cnf.optimistic_dad &&
  1883. !net->ipv6.devconf_all->forwarding && sllao)
  1884. addr_flags = IFA_F_OPTIMISTIC;
  1885. #endif
  1886. /* Do not allow to create too much of autoconfigured
  1887. * addresses; this would be too easy way to crash kernel.
  1888. */
  1889. if (!max_addresses ||
  1890. ipv6_count_addresses(in6_dev) < max_addresses)
  1891. ifp = ipv6_add_addr(in6_dev, &addr, NULL,
  1892. pinfo->prefix_len,
  1893. addr_type&IPV6_ADDR_SCOPE_MASK,
  1894. addr_flags, valid_lft,
  1895. prefered_lft);
  1896. if (IS_ERR_OR_NULL(ifp)) {
  1897. in6_dev_put(in6_dev);
  1898. return;
  1899. }
  1900. update_lft = 0;
  1901. create = 1;
  1902. ifp->cstamp = jiffies;
  1903. ifp->tokenized = tokenized;
  1904. addrconf_dad_start(ifp);
  1905. }
  1906. if (ifp) {
  1907. int flags;
  1908. unsigned long now;
  1909. #ifdef CONFIG_IPV6_PRIVACY
  1910. struct inet6_ifaddr *ift;
  1911. #endif
  1912. u32 stored_lft;
  1913. /* update lifetime (RFC2462 5.5.3 e) */
  1914. spin_lock(&ifp->lock);
  1915. now = jiffies;
  1916. if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
  1917. stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
  1918. else
  1919. stored_lft = 0;
  1920. if (!update_lft && !create && stored_lft) {
  1921. if (valid_lft > MIN_VALID_LIFETIME ||
  1922. valid_lft > stored_lft)
  1923. update_lft = 1;
  1924. else if (stored_lft <= MIN_VALID_LIFETIME) {
  1925. /* valid_lft <= stored_lft is always true */
  1926. /*
  1927. * RFC 4862 Section 5.5.3e:
  1928. * "Note that the preferred lifetime of
  1929. * the corresponding address is always
  1930. * reset to the Preferred Lifetime in
  1931. * the received Prefix Information
  1932. * option, regardless of whether the
  1933. * valid lifetime is also reset or
  1934. * ignored."
  1935. *
  1936. * So if the preferred lifetime in
  1937. * this advertisement is different
  1938. * than what we have stored, but the
  1939. * valid lifetime is invalid, just
  1940. * reset prefered_lft.
  1941. *
  1942. * We must set the valid lifetime
  1943. * to the stored lifetime since we'll
  1944. * be updating the timestamp below,
  1945. * else we'll set it back to the
  1946. * minimum.
  1947. */
  1948. if (prefered_lft != ifp->prefered_lft) {
  1949. valid_lft = stored_lft;
  1950. update_lft = 1;
  1951. }
  1952. } else {
  1953. valid_lft = MIN_VALID_LIFETIME;
  1954. if (valid_lft < prefered_lft)
  1955. prefered_lft = valid_lft;
  1956. update_lft = 1;
  1957. }
  1958. }
  1959. if (update_lft) {
  1960. ifp->valid_lft = valid_lft;
  1961. ifp->prefered_lft = prefered_lft;
  1962. ifp->tstamp = now;
  1963. flags = ifp->flags;
  1964. ifp->flags &= ~IFA_F_DEPRECATED;
  1965. spin_unlock(&ifp->lock);
  1966. if (!(flags&IFA_F_TENTATIVE))
  1967. ipv6_ifa_notify(0, ifp);
  1968. } else
  1969. spin_unlock(&ifp->lock);
  1970. #ifdef CONFIG_IPV6_PRIVACY
  1971. read_lock_bh(&in6_dev->lock);
  1972. /* update all temporary addresses in the list */
  1973. list_for_each_entry(ift, &in6_dev->tempaddr_list,
  1974. tmp_list) {
  1975. int age, max_valid, max_prefered;
  1976. if (ifp != ift->ifpub)
  1977. continue;
  1978. /*
  1979. * RFC 4941 section 3.3:
  1980. * If a received option will extend the lifetime
  1981. * of a public address, the lifetimes of
  1982. * temporary addresses should be extended,
  1983. * subject to the overall constraint that no
  1984. * temporary addresses should ever remain
  1985. * "valid" or "preferred" for a time longer than
  1986. * (TEMP_VALID_LIFETIME) or
  1987. * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR),
  1988. * respectively.
  1989. */
  1990. age = (now - ift->cstamp) / HZ;
  1991. max_valid = in6_dev->cnf.temp_valid_lft - age;
  1992. if (max_valid < 0)
  1993. max_valid = 0;
  1994. max_prefered = in6_dev->cnf.temp_prefered_lft -
  1995. in6_dev->cnf.max_desync_factor -
  1996. age;
  1997. if (max_prefered < 0)
  1998. max_prefered = 0;
  1999. if (valid_lft > max_valid)
  2000. valid_lft = max_valid;
  2001. if (prefered_lft > max_prefered)
  2002. prefered_lft = max_prefered;
  2003. spin_lock(&ift->lock);
  2004. flags = ift->flags;
  2005. ift->valid_lft = valid_lft;
  2006. ift->prefered_lft = prefered_lft;
  2007. ift->tstamp = now;
  2008. if (prefered_lft > 0)
  2009. ift->flags &= ~IFA_F_DEPRECATED;
  2010. spin_unlock(&ift->lock);
  2011. if (!(flags&IFA_F_TENTATIVE))
  2012. ipv6_ifa_notify(0, ift);
  2013. }
  2014. if ((create || list_empty(&in6_dev->tempaddr_list)) && in6_dev->cnf.use_tempaddr > 0) {
  2015. /*
  2016. * When a new public address is created as
  2017. * described in [ADDRCONF], also create a new
  2018. * temporary address. Also create a temporary
  2019. * address if it's enabled but no temporary
  2020. * address currently exists.
  2021. */
  2022. read_unlock_bh(&in6_dev->lock);
  2023. ipv6_create_tempaddr(ifp, NULL);
  2024. } else {
  2025. read_unlock_bh(&in6_dev->lock);
  2026. }
  2027. #endif
  2028. in6_ifa_put(ifp);
  2029. addrconf_verify(0);
  2030. }
  2031. }
  2032. inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
  2033. in6_dev_put(in6_dev);
  2034. }
  2035. /*
  2036. * Set destination address.
  2037. * Special case for SIT interfaces where we create a new "virtual"
  2038. * device.
  2039. */
  2040. int addrconf_set_dstaddr(struct net *net, void __user *arg)
  2041. {
  2042. struct in6_ifreq ireq;
  2043. struct net_device *dev;
  2044. int err = -EINVAL;
  2045. rtnl_lock();
  2046. err = -EFAULT;
  2047. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  2048. goto err_exit;
  2049. dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
  2050. err = -ENODEV;
  2051. if (dev == NULL)
  2052. goto err_exit;
  2053. #if IS_ENABLED(CONFIG_IPV6_SIT)
  2054. if (dev->type == ARPHRD_SIT) {
  2055. const struct net_device_ops *ops = dev->netdev_ops;
  2056. struct ifreq ifr;
  2057. struct ip_tunnel_parm p;
  2058. err = -EADDRNOTAVAIL;
  2059. if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
  2060. goto err_exit;
  2061. memset(&p, 0, sizeof(p));
  2062. p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
  2063. p.iph.saddr = 0;
  2064. p.iph.version = 4;
  2065. p.iph.ihl = 5;
  2066. p.iph.protocol = IPPROTO_IPV6;
  2067. p.iph.ttl = 64;
  2068. ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
  2069. if (ops->ndo_do_ioctl) {
  2070. mm_segment_t oldfs = get_fs();
  2071. set_fs(KERNEL_DS);
  2072. err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
  2073. set_fs(oldfs);
  2074. } else
  2075. err = -EOPNOTSUPP;
  2076. if (err == 0) {
  2077. err = -ENOBUFS;
  2078. dev = __dev_get_by_name(net, p.name);
  2079. if (!dev)
  2080. goto err_exit;
  2081. err = dev_open(dev);
  2082. }
  2083. }
  2084. #endif
  2085. err_exit:
  2086. rtnl_unlock();
  2087. return err;
  2088. }
  2089. /*
  2090. * Manual configuration of address on an interface
  2091. */
  2092. static int inet6_addr_add(struct net *net, int ifindex, const struct in6_addr *pfx,
  2093. const struct in6_addr *peer_pfx,
  2094. unsigned int plen, __u8 ifa_flags, __u32 prefered_lft,
  2095. __u32 valid_lft)
  2096. {
  2097. struct inet6_ifaddr *ifp;
  2098. struct inet6_dev *idev;
  2099. struct net_device *dev;
  2100. int scope;
  2101. u32 flags;
  2102. clock_t expires;
  2103. unsigned long timeout;
  2104. ASSERT_RTNL();
  2105. if (plen > 128)
  2106. return -EINVAL;
  2107. /* check the lifetime */
  2108. if (!valid_lft || prefered_lft > valid_lft)
  2109. return -EINVAL;
  2110. dev = __dev_get_by_index(net, ifindex);
  2111. if (!dev)
  2112. return -ENODEV;
  2113. idev = addrconf_add_dev(dev);
  2114. if (IS_ERR(idev))
  2115. return PTR_ERR(idev);
  2116. scope = ipv6_addr_scope(pfx);
  2117. timeout = addrconf_timeout_fixup(valid_lft, HZ);
  2118. if (addrconf_finite_timeout(timeout)) {
  2119. expires = jiffies_to_clock_t(timeout * HZ);
  2120. valid_lft = timeout;
  2121. flags = RTF_EXPIRES;
  2122. } else {
  2123. expires = 0;
  2124. flags = 0;
  2125. ifa_flags |= IFA_F_PERMANENT;
  2126. }
  2127. timeout = addrconf_timeout_fixup(prefered_lft, HZ);
  2128. if (addrconf_finite_timeout(timeout)) {
  2129. if (timeout == 0)
  2130. ifa_flags |= IFA_F_DEPRECATED;
  2131. prefered_lft = timeout;
  2132. }
  2133. ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
  2134. valid_lft, prefered_lft);
  2135. if (!IS_ERR(ifp)) {
  2136. addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
  2137. expires, flags);
  2138. /*
  2139. * Note that section 3.1 of RFC 4429 indicates
  2140. * that the Optimistic flag should not be set for
  2141. * manually configured addresses
  2142. */
  2143. addrconf_dad_start(ifp);
  2144. in6_ifa_put(ifp);
  2145. addrconf_verify(0);
  2146. return 0;
  2147. }
  2148. return PTR_ERR(ifp);
  2149. }
  2150. static int inet6_addr_del(struct net *net, int ifindex, const struct in6_addr *pfx,
  2151. unsigned int plen)
  2152. {
  2153. struct inet6_ifaddr *ifp;
  2154. struct inet6_dev *idev;
  2155. struct net_device *dev;
  2156. if (plen > 128)
  2157. return -EINVAL;
  2158. dev = __dev_get_by_index(net, ifindex);
  2159. if (!dev)
  2160. return -ENODEV;
  2161. if ((idev = __in6_dev_get(dev)) == NULL)
  2162. return -ENXIO;
  2163. read_lock_bh(&idev->lock);
  2164. list_for_each_entry(ifp, &idev->addr_list, if_list) {
  2165. if (ifp->prefix_len == plen &&
  2166. ipv6_addr_equal(pfx, &ifp->addr)) {
  2167. in6_ifa_hold(ifp);
  2168. read_unlock_bh(&idev->lock);
  2169. ipv6_del_addr(ifp);
  2170. return 0;
  2171. }
  2172. }
  2173. read_unlock_bh(&idev->lock);
  2174. return -EADDRNOTAVAIL;
  2175. }
  2176. int addrconf_add_ifaddr(struct net *net, void __user *arg)
  2177. {
  2178. struct in6_ifreq ireq;
  2179. int err;
  2180. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  2181. return -EPERM;
  2182. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  2183. return -EFAULT;
  2184. rtnl_lock();
  2185. err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
  2186. ireq.ifr6_prefixlen, IFA_F_PERMANENT,
  2187. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
  2188. rtnl_unlock();
  2189. return err;
  2190. }
  2191. int addrconf_del_ifaddr(struct net *net, void __user *arg)
  2192. {
  2193. struct in6_ifreq ireq;
  2194. int err;
  2195. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  2196. return -EPERM;
  2197. if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
  2198. return -EFAULT;
  2199. rtnl_lock();
  2200. err = inet6_addr_del(net, ireq.ifr6_ifindex, &ireq.ifr6_addr,
  2201. ireq.ifr6_prefixlen);
  2202. rtnl_unlock();
  2203. return err;
  2204. }
  2205. static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
  2206. int plen, int scope)
  2207. {
  2208. struct inet6_ifaddr *ifp;
  2209. ifp = ipv6_add_addr(idev, addr, NULL, plen,
  2210. scope, IFA_F_PERMANENT, 0, 0);
  2211. if (!IS_ERR(ifp)) {
  2212. spin_lock_bh(&ifp->lock);
  2213. ifp->flags &= ~IFA_F_TENTATIVE;
  2214. spin_unlock_bh(&ifp->lock);
  2215. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  2216. in6_ifa_put(ifp);
  2217. }
  2218. }
  2219. #if IS_ENABLED(CONFIG_IPV6_SIT)
  2220. static void sit_add_v4_addrs(struct inet6_dev *idev)
  2221. {
  2222. struct in6_addr addr;
  2223. struct net_device *dev;
  2224. struct net *net = dev_net(idev->dev);
  2225. int scope;
  2226. ASSERT_RTNL();
  2227. memset(&addr, 0, sizeof(struct in6_addr));
  2228. memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
  2229. if (idev->dev->flags&IFF_POINTOPOINT) {
  2230. addr.s6_addr32[0] = htonl(0xfe800000);
  2231. scope = IFA_LINK;
  2232. } else {
  2233. scope = IPV6_ADDR_COMPATv4;
  2234. }
  2235. if (addr.s6_addr32[3]) {
  2236. add_addr(idev, &addr, 128, scope);
  2237. return;
  2238. }
  2239. for_each_netdev(net, dev) {
  2240. struct in_device *in_dev = __in_dev_get_rtnl(dev);
  2241. if (in_dev && (dev->flags & IFF_UP)) {
  2242. struct in_ifaddr *ifa;
  2243. int flag = scope;
  2244. for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
  2245. int plen;
  2246. addr.s6_addr32[3] = ifa->ifa_local;
  2247. if (ifa->ifa_scope == RT_SCOPE_LINK)
  2248. continue;
  2249. if (ifa->ifa_scope >= RT_SCOPE_HOST) {
  2250. if (idev->dev->flags&IFF_POINTOPOINT)
  2251. continue;
  2252. flag |= IFA_HOST;
  2253. }
  2254. if (idev->dev->flags&IFF_POINTOPOINT)
  2255. plen = 64;
  2256. else
  2257. plen = 96;
  2258. add_addr(idev, &addr, plen, flag);
  2259. }
  2260. }
  2261. }
  2262. }
  2263. #endif
  2264. static void init_loopback(struct net_device *dev)
  2265. {
  2266. struct inet6_dev *idev;
  2267. struct net_device *sp_dev;
  2268. struct inet6_ifaddr *sp_ifa;
  2269. struct rt6_info *sp_rt;
  2270. /* ::1 */
  2271. ASSERT_RTNL();
  2272. if ((idev = ipv6_find_idev(dev)) == NULL) {
  2273. pr_debug("%s: add_dev failed\n", __func__);
  2274. return;
  2275. }
  2276. add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
  2277. /* Add routes to other interface's IPv6 addresses */
  2278. for_each_netdev(dev_net(dev), sp_dev) {
  2279. if (!strcmp(sp_dev->name, dev->name))
  2280. continue;
  2281. idev = __in6_dev_get(sp_dev);
  2282. if (!idev)
  2283. continue;
  2284. read_lock_bh(&idev->lock);
  2285. list_for_each_entry(sp_ifa, &idev->addr_list, if_list) {
  2286. if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))
  2287. continue;
  2288. if (sp_ifa->rt)
  2289. continue;
  2290. sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, 0);
  2291. /* Failure cases are ignored */
  2292. if (!IS_ERR(sp_rt)) {
  2293. sp_ifa->rt = sp_rt;
  2294. ip6_ins_rt(sp_rt);
  2295. }
  2296. }
  2297. read_unlock_bh(&idev->lock);
  2298. }
  2299. }
  2300. static void addrconf_add_linklocal(struct inet6_dev *idev, const struct in6_addr *addr)
  2301. {
  2302. struct inet6_ifaddr *ifp;
  2303. u32 addr_flags = IFA_F_PERMANENT;
  2304. #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
  2305. if (idev->cnf.optimistic_dad &&
  2306. !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
  2307. addr_flags |= IFA_F_OPTIMISTIC;
  2308. #endif
  2309. ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags, 0, 0);
  2310. if (!IS_ERR(ifp)) {
  2311. addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
  2312. addrconf_dad_start(ifp);
  2313. in6_ifa_put(ifp);
  2314. }
  2315. }
  2316. static void addrconf_dev_config(struct net_device *dev)
  2317. {
  2318. struct in6_addr addr;
  2319. struct inet6_dev *idev;
  2320. ASSERT_RTNL();
  2321. if ((dev->type != ARPHRD_ETHER) &&
  2322. (dev->type != ARPHRD_FDDI) &&
  2323. (dev->type != ARPHRD_ARCNET) &&
  2324. (dev->type != ARPHRD_INFINIBAND) &&
  2325. (dev->type != ARPHRD_IEEE802154) &&
  2326. (dev->type != ARPHRD_IEEE1394)) {
  2327. /* Alas, we support only Ethernet autoconfiguration. */
  2328. return;
  2329. }
  2330. idev = addrconf_add_dev(dev);
  2331. if (IS_ERR(idev))
  2332. return;
  2333. memset(&addr, 0, sizeof(struct in6_addr));
  2334. addr.s6_addr32[0] = htonl(0xFE800000);
  2335. if (ipv6_generate_eui64(addr.s6_addr + 8, dev) == 0)
  2336. addrconf_add_linklocal(idev, &addr);
  2337. }
  2338. #if IS_ENABLED(CONFIG_IPV6_SIT)
  2339. static void addrconf_sit_config(struct net_device *dev)
  2340. {
  2341. struct inet6_dev *idev;
  2342. ASSERT_RTNL();
  2343. /*
  2344. * Configure the tunnel with one of our IPv4
  2345. * addresses... we should configure all of
  2346. * our v4 addrs in the tunnel
  2347. */
  2348. if ((idev = ipv6_find_idev(dev)) == NULL) {
  2349. pr_debug("%s: add_dev failed\n", __func__);
  2350. return;
  2351. }
  2352. if (dev->priv_flags & IFF_ISATAP) {
  2353. struct in6_addr addr;
  2354. ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
  2355. addrconf_prefix_route(&addr, 64, dev, 0, 0);
  2356. if (!ipv6_generate_eui64(addr.s6_addr + 8, dev))
  2357. addrconf_add_linklocal(idev, &addr);
  2358. return;
  2359. }
  2360. sit_add_v4_addrs(idev);
  2361. if (dev->flags&IFF_POINTOPOINT)
  2362. addrconf_add_mroute(dev);
  2363. else
  2364. sit_route_add(dev);
  2365. }
  2366. #endif
  2367. #if IS_ENABLED(CONFIG_NET_IPGRE)
  2368. static void addrconf_gre_config(struct net_device *dev)
  2369. {
  2370. struct inet6_dev *idev;
  2371. struct in6_addr addr;
  2372. ASSERT_RTNL();
  2373. if ((idev = ipv6_find_idev(dev)) == NULL) {
  2374. pr_debug("%s: add_dev failed\n", __func__);
  2375. return;
  2376. }
  2377. ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
  2378. addrconf_prefix_route(&addr, 64, dev, 0, 0);
  2379. if (!ipv6_generate_eui64(addr.s6_addr + 8, dev))
  2380. addrconf_add_linklocal(idev, &addr);
  2381. }
  2382. #endif
  2383. static inline int
  2384. ipv6_inherit_linklocal(struct inet6_dev *idev, struct net_device *link_dev)
  2385. {
  2386. struct in6_addr lladdr;
  2387. if (!ipv6_get_lladdr(link_dev, &lladdr, IFA_F_TENTATIVE)) {
  2388. addrconf_add_linklocal(idev, &lladdr);
  2389. return 0;
  2390. }
  2391. return -1;
  2392. }
  2393. static void ip6_tnl_add_linklocal(struct inet6_dev *idev)
  2394. {
  2395. struct net_device *link_dev;
  2396. struct net *net = dev_net(idev->dev);
  2397. /* first try to inherit the link-local address from the link device */
  2398. if (idev->dev->iflink &&
  2399. (link_dev = __dev_get_by_index(net, idev->dev->iflink))) {
  2400. if (!ipv6_inherit_linklocal(idev, link_dev))
  2401. return;
  2402. }
  2403. /* then try to inherit it from any device */
  2404. for_each_netdev(net, link_dev) {
  2405. if (!ipv6_inherit_linklocal(idev, link_dev))
  2406. return;
  2407. }
  2408. pr_debug("init ip6-ip6: add_linklocal failed\n");
  2409. }
  2410. /*
  2411. * Autoconfigure tunnel with a link-local address so routing protocols,
  2412. * DHCPv6, MLD etc. can be run over the virtual link
  2413. */
  2414. static void addrconf_ip6_tnl_config(struct net_device *dev)
  2415. {
  2416. struct inet6_dev *idev;
  2417. ASSERT_RTNL();
  2418. idev = addrconf_add_dev(dev);
  2419. if (IS_ERR(idev)) {
  2420. pr_debug("init ip6-ip6: add_dev failed\n");
  2421. return;
  2422. }
  2423. ip6_tnl_add_linklocal(idev);
  2424. }
  2425. static int addrconf_notify(struct notifier_block *this, unsigned long event,
  2426. void *ptr)
  2427. {
  2428. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  2429. struct inet6_dev *idev = __in6_dev_get(dev);
  2430. int run_pending = 0;
  2431. int err;
  2432. switch (event) {
  2433. case NETDEV_REGISTER:
  2434. if (!idev && dev->mtu >= IPV6_MIN_MTU) {
  2435. idev = ipv6_add_dev(dev);
  2436. if (!idev)
  2437. return notifier_from_errno(-ENOMEM);
  2438. }
  2439. break;
  2440. case NETDEV_UP:
  2441. case NETDEV_CHANGE:
  2442. if (dev->flags & IFF_SLAVE)
  2443. break;
  2444. if (event == NETDEV_UP) {
  2445. if (!addrconf_qdisc_ok(dev)) {
  2446. /* device is not ready yet. */
  2447. pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
  2448. dev->name);
  2449. break;
  2450. }
  2451. if (!idev && dev->mtu >= IPV6_MIN_MTU)
  2452. idev = ipv6_add_dev(dev);
  2453. if (idev) {
  2454. idev->if_flags |= IF_READY;
  2455. run_pending = 1;
  2456. }
  2457. } else {
  2458. if (!addrconf_qdisc_ok(dev)) {
  2459. /* device is still not ready. */
  2460. break;
  2461. }
  2462. if (idev) {
  2463. if (idev->if_flags & IF_READY)
  2464. /* device is already configured. */
  2465. break;
  2466. idev->if_flags |= IF_READY;
  2467. }
  2468. pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
  2469. dev->name);
  2470. run_pending = 1;
  2471. }
  2472. switch (dev->type) {
  2473. #if IS_ENABLED(CONFIG_IPV6_SIT)
  2474. case ARPHRD_SIT:
  2475. addrconf_sit_config(dev);
  2476. break;
  2477. #endif
  2478. #if IS_ENABLED(CONFIG_NET_IPGRE)
  2479. case ARPHRD_IPGRE:
  2480. addrconf_gre_config(dev);
  2481. break;
  2482. #endif
  2483. case ARPHRD_TUNNEL6:
  2484. addrconf_ip6_tnl_config(dev);
  2485. break;
  2486. case ARPHRD_LOOPBACK:
  2487. init_loopback(dev);
  2488. break;
  2489. default:
  2490. addrconf_dev_config(dev);
  2491. break;
  2492. }
  2493. if (idev) {
  2494. if (run_pending)
  2495. addrconf_dad_run(idev);
  2496. /*
  2497. * If the MTU changed during the interface down,
  2498. * when the interface up, the changed MTU must be
  2499. * reflected in the idev as well as routers.
  2500. */
  2501. if (idev->cnf.mtu6 != dev->mtu &&
  2502. dev->mtu >= IPV6_MIN_MTU) {
  2503. rt6_mtu_change(dev, dev->mtu);
  2504. idev->cnf.mtu6 = dev->mtu;
  2505. }
  2506. idev->tstamp = jiffies;
  2507. inet6_ifinfo_notify(RTM_NEWLINK, idev);
  2508. /*
  2509. * If the changed mtu during down is lower than
  2510. * IPV6_MIN_MTU stop IPv6 on this interface.
  2511. */
  2512. if (dev->mtu < IPV6_MIN_MTU)
  2513. addrconf_ifdown(dev, 1);
  2514. }
  2515. break;
  2516. case NETDEV_CHANGEMTU:
  2517. if (idev && dev->mtu >= IPV6_MIN_MTU) {
  2518. rt6_mtu_change(dev, dev->mtu);
  2519. idev->cnf.mtu6 = dev->mtu;
  2520. break;
  2521. }
  2522. if (!idev && dev->mtu >= IPV6_MIN_MTU) {
  2523. idev = ipv6_add_dev(dev);
  2524. if (idev)
  2525. break;
  2526. }
  2527. /*
  2528. * MTU falled under IPV6_MIN_MTU.
  2529. * Stop IPv6 on this interface.
  2530. */
  2531. case NETDEV_DOWN:
  2532. case NETDEV_UNREGISTER:
  2533. /*
  2534. * Remove all addresses from this interface.
  2535. */
  2536. addrconf_ifdown(dev, event != NETDEV_DOWN);
  2537. break;
  2538. case NETDEV_CHANGENAME:
  2539. if (idev) {
  2540. snmp6_unregister_dev(idev);
  2541. addrconf_sysctl_unregister(idev);
  2542. addrconf_sysctl_register(idev);
  2543. err = snmp6_register_dev(idev);
  2544. if (err)
  2545. return notifier_from_errno(err);
  2546. }
  2547. break;
  2548. case NETDEV_PRE_TYPE_CHANGE:
  2549. case NETDEV_POST_TYPE_CHANGE:
  2550. addrconf_type_change(dev, event);
  2551. break;
  2552. }
  2553. return NOTIFY_OK;
  2554. }
  2555. /*
  2556. * addrconf module should be notified of a device going up
  2557. */
  2558. static struct notifier_block ipv6_dev_notf = {
  2559. .notifier_call = addrconf_notify,
  2560. };
  2561. static void addrconf_type_change(struct net_device *dev, unsigned long event)
  2562. {
  2563. struct inet6_dev *idev;
  2564. ASSERT_RTNL();
  2565. idev = __in6_dev_get(dev);
  2566. if (event == NETDEV_POST_TYPE_CHANGE)
  2567. ipv6_mc_remap(idev);
  2568. else if (event == NETDEV_PRE_TYPE_CHANGE)
  2569. ipv6_mc_unmap(idev);
  2570. }
  2571. static int addrconf_ifdown(struct net_device *dev, int how)
  2572. {
  2573. struct net *net = dev_net(dev);
  2574. struct inet6_dev *idev;
  2575. struct inet6_ifaddr *ifa;
  2576. int state, i;
  2577. ASSERT_RTNL();
  2578. rt6_ifdown(net, dev);
  2579. neigh_ifdown(&nd_tbl, dev);
  2580. idev = __in6_dev_get(dev);
  2581. if (idev == NULL)
  2582. return -ENODEV;
  2583. /*
  2584. * Step 1: remove reference to ipv6 device from parent device.
  2585. * Do not dev_put!
  2586. */
  2587. if (how) {
  2588. idev->dead = 1;
  2589. /* protected by rtnl_lock */
  2590. RCU_INIT_POINTER(dev->ip6_ptr, NULL);
  2591. /* Step 1.5: remove snmp6 entry */
  2592. snmp6_unregister_dev(idev);
  2593. }
  2594. /* Step 2: clear hash table */
  2595. for (i = 0; i < IN6_ADDR_HSIZE; i++) {
  2596. struct hlist_head *h = &inet6_addr_lst[i];
  2597. spin_lock_bh(&addrconf_hash_lock);
  2598. restart:
  2599. hlist_for_each_entry_rcu(ifa, h, addr_lst) {
  2600. if (ifa->idev == idev) {
  2601. hlist_del_init_rcu(&ifa->addr_lst);
  2602. addrconf_del_dad_timer(ifa);
  2603. goto restart;
  2604. }
  2605. }
  2606. spin_unlock_bh(&addrconf_hash_lock);
  2607. }
  2608. write_lock_bh(&idev->lock);
  2609. addrconf_del_rs_timer(idev);
  2610. /* Step 2: clear flags for stateless addrconf */
  2611. if (!how)
  2612. idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
  2613. #ifdef CONFIG_IPV6_PRIVACY
  2614. if (how && del_timer(&idev->regen_timer))
  2615. in6_dev_put(idev);
  2616. /* Step 3: clear tempaddr list */
  2617. while (!list_empty(&idev->tempaddr_list)) {
  2618. ifa = list_first_entry(&idev->tempaddr_list,
  2619. struct inet6_ifaddr, tmp_list);
  2620. list_del(&ifa->tmp_list);
  2621. write_unlock_bh(&idev->lock);
  2622. spin_lock_bh(&ifa->lock);
  2623. if (ifa->ifpub) {
  2624. in6_ifa_put(ifa->ifpub);
  2625. ifa->ifpub = NULL;
  2626. }
  2627. spin_unlock_bh(&ifa->lock);
  2628. in6_ifa_put(ifa);
  2629. write_lock_bh(&idev->lock);
  2630. }
  2631. #endif
  2632. while (!list_empty(&idev->addr_list)) {
  2633. ifa = list_first_entry(&idev->addr_list,
  2634. struct inet6_ifaddr, if_list);
  2635. addrconf_del_dad_timer(ifa);
  2636. list_del(&ifa->if_list);
  2637. write_unlock_bh(&idev->lock);
  2638. spin_lock_bh(&ifa->state_lock);
  2639. state = ifa->state;
  2640. ifa->state = INET6_IFADDR_STATE_DEAD;
  2641. spin_unlock_bh(&ifa->state_lock);
  2642. if (state != INET6_IFADDR_STATE_DEAD) {
  2643. __ipv6_ifa_notify(RTM_DELADDR, ifa);
  2644. inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
  2645. }
  2646. in6_ifa_put(ifa);
  2647. write_lock_bh(&idev->lock);
  2648. }
  2649. write_unlock_bh(&idev->lock);
  2650. /* Step 5: Discard multicast list */
  2651. if (how)
  2652. ipv6_mc_destroy_dev(idev);
  2653. else
  2654. ipv6_mc_down(idev);
  2655. idev->tstamp = jiffies;
  2656. /* Last: Shot the device (if unregistered) */
  2657. if (how) {
  2658. addrconf_sysctl_unregister(idev);
  2659. neigh_parms_release(&nd_tbl, idev->nd_parms);
  2660. neigh_ifdown(&nd_tbl, dev);
  2661. in6_dev_put(idev);
  2662. }
  2663. return 0;
  2664. }
  2665. static void addrconf_rs_timer(unsigned long data)
  2666. {
  2667. struct inet6_dev *idev = (struct inet6_dev *)data;
  2668. struct in6_addr lladdr;
  2669. write_lock(&idev->lock);
  2670. if (idev->dead || !(idev->if_flags & IF_READY))
  2671. goto out;
  2672. if (!ipv6_accept_ra(idev))
  2673. goto out;
  2674. /* Announcement received after solicitation was sent */
  2675. if (idev->if_flags & IF_RA_RCVD)
  2676. goto out;
  2677. if (idev->rs_probes++ < idev->cnf.rtr_solicits) {
  2678. if (!__ipv6_get_lladdr(idev, &lladdr, IFA_F_TENTATIVE))
  2679. ndisc_send_rs(idev->dev, &lladdr,
  2680. &in6addr_linklocal_allrouters);
  2681. else
  2682. goto out;
  2683. /* The wait after the last probe can be shorter */
  2684. addrconf_mod_rs_timer(idev, (idev->rs_probes ==
  2685. idev->cnf.rtr_solicits) ?
  2686. idev->cnf.rtr_solicit_delay :
  2687. idev->cnf.rtr_solicit_interval);
  2688. } else {
  2689. /*
  2690. * Note: we do not support deprecated "all on-link"
  2691. * assumption any longer.
  2692. */
  2693. pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
  2694. }
  2695. out:
  2696. write_unlock(&idev->lock);
  2697. in6_dev_put(idev);
  2698. }
  2699. /*
  2700. * Duplicate Address Detection
  2701. */
  2702. static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
  2703. {
  2704. unsigned long rand_num;
  2705. struct inet6_dev *idev = ifp->idev;
  2706. if (ifp->flags & IFA_F_OPTIMISTIC)
  2707. rand_num = 0;
  2708. else
  2709. rand_num = net_random() % (idev->cnf.rtr_solicit_delay ? : 1);
  2710. ifp->dad_probes = idev->cnf.dad_transmits;
  2711. addrconf_mod_dad_timer(ifp, rand_num);
  2712. }
  2713. static void addrconf_dad_start(struct inet6_ifaddr *ifp)
  2714. {
  2715. struct inet6_dev *idev = ifp->idev;
  2716. struct net_device *dev = idev->dev;
  2717. addrconf_join_solict(dev, &ifp->addr);
  2718. net_srandom(ifp->addr.s6_addr32[3]);
  2719. read_lock_bh(&idev->lock);
  2720. spin_lock(&ifp->lock);
  2721. if (ifp->state == INET6_IFADDR_STATE_DEAD)
  2722. goto out;
  2723. if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
  2724. idev->cnf.accept_dad < 1 ||
  2725. !(ifp->flags&IFA_F_TENTATIVE) ||
  2726. ifp->flags & IFA_F_NODAD) {
  2727. ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
  2728. spin_unlock(&ifp->lock);
  2729. read_unlock_bh(&idev->lock);
  2730. addrconf_dad_completed(ifp);
  2731. return;
  2732. }
  2733. if (!(idev->if_flags & IF_READY)) {
  2734. spin_unlock(&ifp->lock);
  2735. read_unlock_bh(&idev->lock);
  2736. /*
  2737. * If the device is not ready:
  2738. * - keep it tentative if it is a permanent address.
  2739. * - otherwise, kill it.
  2740. */
  2741. in6_ifa_hold(ifp);
  2742. addrconf_dad_stop(ifp, 0);
  2743. return;
  2744. }
  2745. /*
  2746. * Optimistic nodes can start receiving
  2747. * Frames right away
  2748. */
  2749. if (ifp->flags & IFA_F_OPTIMISTIC)
  2750. ip6_ins_rt(ifp->rt);
  2751. addrconf_dad_kick(ifp);
  2752. out:
  2753. spin_unlock(&ifp->lock);
  2754. read_unlock_bh(&idev->lock);
  2755. }
  2756. static void addrconf_dad_timer(unsigned long data)
  2757. {
  2758. struct inet6_ifaddr *ifp = (struct inet6_ifaddr *) data;
  2759. struct inet6_dev *idev = ifp->idev;
  2760. struct in6_addr mcaddr;
  2761. if (!ifp->dad_probes && addrconf_dad_end(ifp))
  2762. goto out;
  2763. write_lock(&idev->lock);
  2764. if (idev->dead || !(idev->if_flags & IF_READY)) {
  2765. write_unlock(&idev->lock);
  2766. goto out;
  2767. }
  2768. spin_lock(&ifp->lock);
  2769. if (ifp->state == INET6_IFADDR_STATE_DEAD) {
  2770. spin_unlock(&ifp->lock);
  2771. write_unlock(&idev->lock);
  2772. goto out;
  2773. }
  2774. if (ifp->dad_probes == 0) {
  2775. /*
  2776. * DAD was successful
  2777. */
  2778. ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
  2779. spin_unlock(&ifp->lock);
  2780. write_unlock(&idev->lock);
  2781. addrconf_dad_completed(ifp);
  2782. goto out;
  2783. }
  2784. ifp->dad_probes--;
  2785. addrconf_mod_dad_timer(ifp, ifp->idev->nd_parms->retrans_time);
  2786. spin_unlock(&ifp->lock);
  2787. write_unlock(&idev->lock);
  2788. /* send a neighbour solicitation for our addr */
  2789. addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
  2790. ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any);
  2791. out:
  2792. in6_ifa_put(ifp);
  2793. }
  2794. static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
  2795. {
  2796. struct net_device *dev = ifp->idev->dev;
  2797. struct in6_addr lladdr;
  2798. bool send_rs, send_mld;
  2799. addrconf_del_dad_timer(ifp);
  2800. /*
  2801. * Configure the address for reception. Now it is valid.
  2802. */
  2803. ipv6_ifa_notify(RTM_NEWADDR, ifp);
  2804. /* If added prefix is link local and we are prepared to process
  2805. router advertisements, start sending router solicitations.
  2806. */
  2807. read_lock_bh(&ifp->idev->lock);
  2808. spin_lock(&ifp->lock);
  2809. send_mld = ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL &&
  2810. ifp->idev->valid_ll_addr_cnt == 1;
  2811. send_rs = send_mld &&
  2812. ipv6_accept_ra(ifp->idev) &&
  2813. ifp->idev->cnf.rtr_solicits > 0 &&
  2814. (dev->flags&IFF_LOOPBACK) == 0;
  2815. spin_unlock(&ifp->lock);
  2816. read_unlock_bh(&ifp->idev->lock);
  2817. /* While dad is in progress mld report's source address is in6_addrany.
  2818. * Resend with proper ll now.
  2819. */
  2820. if (send_mld)
  2821. ipv6_mc_dad_complete(ifp->idev);
  2822. if (send_rs) {
  2823. /*
  2824. * If a host as already performed a random delay
  2825. * [...] as part of DAD [...] there is no need
  2826. * to delay again before sending the first RS
  2827. */
  2828. if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
  2829. return;
  2830. ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
  2831. write_lock_bh(&ifp->idev->lock);
  2832. spin_lock(&ifp->lock);
  2833. ifp->idev->rs_probes = 1;
  2834. ifp->idev->if_flags |= IF_RS_SENT;
  2835. addrconf_mod_rs_timer(ifp->idev,
  2836. ifp->idev->cnf.rtr_solicit_interval);
  2837. spin_unlock(&ifp->lock);
  2838. write_unlock_bh(&ifp->idev->lock);
  2839. }
  2840. }
  2841. static void addrconf_dad_run(struct inet6_dev *idev)
  2842. {
  2843. struct inet6_ifaddr *ifp;
  2844. read_lock_bh(&idev->lock);
  2845. list_for_each_entry(ifp, &idev->addr_list, if_list) {
  2846. spin_lock(&ifp->lock);
  2847. if (ifp->flags & IFA_F_TENTATIVE &&
  2848. ifp->state == INET6_IFADDR_STATE_DAD)
  2849. addrconf_dad_kick(ifp);
  2850. spin_unlock(&ifp->lock);
  2851. }
  2852. read_unlock_bh(&idev->lock);
  2853. }
  2854. #ifdef CONFIG_PROC_FS
  2855. struct if6_iter_state {
  2856. struct seq_net_private p;
  2857. int bucket;
  2858. int offset;
  2859. };
  2860. static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
  2861. {
  2862. struct inet6_ifaddr *ifa = NULL;
  2863. struct if6_iter_state *state = seq->private;
  2864. struct net *net = seq_file_net(seq);
  2865. int p = 0;
  2866. /* initial bucket if pos is 0 */
  2867. if (pos == 0) {
  2868. state->bucket = 0;
  2869. state->offset = 0;
  2870. }
  2871. for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
  2872. hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket],
  2873. addr_lst) {
  2874. if (!net_eq(dev_net(ifa->idev->dev), net))
  2875. continue;
  2876. /* sync with offset */
  2877. if (p < state->offset) {
  2878. p++;
  2879. continue;
  2880. }
  2881. state->offset++;
  2882. return ifa;
  2883. }
  2884. /* prepare for next bucket */
  2885. state->offset = 0;
  2886. p = 0;
  2887. }
  2888. return NULL;
  2889. }
  2890. static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
  2891. struct inet6_ifaddr *ifa)
  2892. {
  2893. struct if6_iter_state *state = seq->private;
  2894. struct net *net = seq_file_net(seq);
  2895. hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) {
  2896. if (!net_eq(dev_net(ifa->idev->dev), net))
  2897. continue;
  2898. state->offset++;
  2899. return ifa;
  2900. }
  2901. while (++state->bucket < IN6_ADDR_HSIZE) {
  2902. state->offset = 0;
  2903. hlist_for_each_entry_rcu_bh(ifa,
  2904. &inet6_addr_lst[state->bucket], addr_lst) {
  2905. if (!net_eq(dev_net(ifa->idev->dev), net))
  2906. continue;
  2907. state->offset++;
  2908. return ifa;
  2909. }
  2910. }
  2911. return NULL;
  2912. }
  2913. static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
  2914. __acquires(rcu_bh)
  2915. {
  2916. rcu_read_lock_bh();
  2917. return if6_get_first(seq, *pos);
  2918. }
  2919. static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2920. {
  2921. struct inet6_ifaddr *ifa;
  2922. ifa = if6_get_next(seq, v);
  2923. ++*pos;
  2924. return ifa;
  2925. }
  2926. static void if6_seq_stop(struct seq_file *seq, void *v)
  2927. __releases(rcu_bh)
  2928. {
  2929. rcu_read_unlock_bh();
  2930. }
  2931. static int if6_seq_show(struct seq_file *seq, void *v)
  2932. {
  2933. struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
  2934. seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
  2935. &ifp->addr,
  2936. ifp->idev->dev->ifindex,
  2937. ifp->prefix_len,
  2938. ifp->scope,
  2939. ifp->flags,
  2940. ifp->idev->dev->name);
  2941. return 0;
  2942. }
  2943. static const struct seq_operations if6_seq_ops = {
  2944. .start = if6_seq_start,
  2945. .next = if6_seq_next,
  2946. .show = if6_seq_show,
  2947. .stop = if6_seq_stop,
  2948. };
  2949. static int if6_seq_open(struct inode *inode, struct file *file)
  2950. {
  2951. return seq_open_net(inode, file, &if6_seq_ops,
  2952. sizeof(struct if6_iter_state));
  2953. }
  2954. static const struct file_operations if6_fops = {
  2955. .owner = THIS_MODULE,
  2956. .open = if6_seq_open,
  2957. .read = seq_read,
  2958. .llseek = seq_lseek,
  2959. .release = seq_release_net,
  2960. };
  2961. static int __net_init if6_proc_net_init(struct net *net)
  2962. {
  2963. if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops))
  2964. return -ENOMEM;
  2965. return 0;
  2966. }
  2967. static void __net_exit if6_proc_net_exit(struct net *net)
  2968. {
  2969. remove_proc_entry("if_inet6", net->proc_net);
  2970. }
  2971. static struct pernet_operations if6_proc_net_ops = {
  2972. .init = if6_proc_net_init,
  2973. .exit = if6_proc_net_exit,
  2974. };
  2975. int __init if6_proc_init(void)
  2976. {
  2977. return register_pernet_subsys(&if6_proc_net_ops);
  2978. }
  2979. void if6_proc_exit(void)
  2980. {
  2981. unregister_pernet_subsys(&if6_proc_net_ops);
  2982. }
  2983. #endif /* CONFIG_PROC_FS */
  2984. #if IS_ENABLED(CONFIG_IPV6_MIP6)
  2985. /* Check if address is a home address configured on any interface. */
  2986. int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
  2987. {
  2988. int ret = 0;
  2989. struct inet6_ifaddr *ifp = NULL;
  2990. unsigned int hash = inet6_addr_hash(addr);
  2991. rcu_read_lock_bh();
  2992. hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
  2993. if (!net_eq(dev_net(ifp->idev->dev), net))
  2994. continue;
  2995. if (ipv6_addr_equal(&ifp->addr, addr) &&
  2996. (ifp->flags & IFA_F_HOMEADDRESS)) {
  2997. ret = 1;
  2998. break;
  2999. }
  3000. }
  3001. rcu_read_unlock_bh();
  3002. return ret;
  3003. }
  3004. #endif
  3005. /*
  3006. * Periodic address status verification
  3007. */
  3008. static void addrconf_verify(unsigned long foo)
  3009. {
  3010. unsigned long now, next, next_sec, next_sched;
  3011. struct inet6_ifaddr *ifp;
  3012. int i;
  3013. rcu_read_lock_bh();
  3014. spin_lock(&addrconf_verify_lock);
  3015. now = jiffies;
  3016. next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
  3017. del_timer(&addr_chk_timer);
  3018. for (i = 0; i < IN6_ADDR_HSIZE; i++) {
  3019. restart:
  3020. hlist_for_each_entry_rcu_bh(ifp,
  3021. &inet6_addr_lst[i], addr_lst) {
  3022. unsigned long age;
  3023. if (ifp->flags & IFA_F_PERMANENT)
  3024. continue;
  3025. spin_lock(&ifp->lock);
  3026. /* We try to batch several events at once. */
  3027. age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
  3028. if (ifp->valid_lft != INFINITY_LIFE_TIME &&
  3029. age >= ifp->valid_lft) {
  3030. spin_unlock(&ifp->lock);
  3031. in6_ifa_hold(ifp);
  3032. ipv6_del_addr(ifp);
  3033. goto restart;
  3034. } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
  3035. spin_unlock(&ifp->lock);
  3036. continue;
  3037. } else if (age >= ifp->prefered_lft) {
  3038. /* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
  3039. int deprecate = 0;
  3040. if (!(ifp->flags&IFA_F_DEPRECATED)) {
  3041. deprecate = 1;
  3042. ifp->flags |= IFA_F_DEPRECATED;
  3043. }
  3044. if (time_before(ifp->tstamp + ifp->valid_lft * HZ, next))
  3045. next = ifp->tstamp + ifp->valid_lft * HZ;
  3046. spin_unlock(&ifp->lock);
  3047. if (deprecate) {
  3048. in6_ifa_hold(ifp);
  3049. ipv6_ifa_notify(0, ifp);
  3050. in6_ifa_put(ifp);
  3051. goto restart;
  3052. }
  3053. #ifdef CONFIG_IPV6_PRIVACY
  3054. } else if ((ifp->flags&IFA_F_TEMPORARY) &&
  3055. !(ifp->flags&IFA_F_TENTATIVE)) {
  3056. unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
  3057. ifp->idev->cnf.dad_transmits *
  3058. ifp->idev->nd_parms->retrans_time / HZ;
  3059. if (age >= ifp->prefered_lft - regen_advance) {
  3060. struct inet6_ifaddr *ifpub = ifp->ifpub;
  3061. if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
  3062. next = ifp->tstamp + ifp->prefered_lft * HZ;
  3063. if (!ifp->regen_count && ifpub) {
  3064. ifp->regen_count++;
  3065. in6_ifa_hold(ifp);
  3066. in6_ifa_hold(ifpub);
  3067. spin_unlock(&ifp->lock);
  3068. spin_lock(&ifpub->lock);
  3069. ifpub->regen_count = 0;
  3070. spin_unlock(&ifpub->lock);
  3071. ipv6_create_tempaddr(ifpub, ifp);
  3072. in6_ifa_put(ifpub);
  3073. in6_ifa_put(ifp);
  3074. goto restart;
  3075. }
  3076. } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
  3077. next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
  3078. spin_unlock(&ifp->lock);
  3079. #endif
  3080. } else {
  3081. /* ifp->prefered_lft <= ifp->valid_lft */
  3082. if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
  3083. next = ifp->tstamp + ifp->prefered_lft * HZ;
  3084. spin_unlock(&ifp->lock);
  3085. }
  3086. }
  3087. }
  3088. next_sec = round_jiffies_up(next);
  3089. next_sched = next;
  3090. /* If rounded timeout is accurate enough, accept it. */
  3091. if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
  3092. next_sched = next_sec;
  3093. /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
  3094. if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
  3095. next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
  3096. ADBG((KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
  3097. now, next, next_sec, next_sched));
  3098. addr_chk_timer.expires = next_sched;
  3099. add_timer(&addr_chk_timer);
  3100. spin_unlock(&addrconf_verify_lock);
  3101. rcu_read_unlock_bh();
  3102. }
  3103. static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
  3104. struct in6_addr **peer_pfx)
  3105. {
  3106. struct in6_addr *pfx = NULL;
  3107. *peer_pfx = NULL;
  3108. if (addr)
  3109. pfx = nla_data(addr);
  3110. if (local) {
  3111. if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
  3112. *peer_pfx = pfx;
  3113. pfx = nla_data(local);
  3114. }
  3115. return pfx;
  3116. }
  3117. static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
  3118. [IFA_ADDRESS] = { .len = sizeof(struct in6_addr) },
  3119. [IFA_LOCAL] = { .len = sizeof(struct in6_addr) },
  3120. [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
  3121. };
  3122. static int
  3123. inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
  3124. {
  3125. struct net *net = sock_net(skb->sk);
  3126. struct ifaddrmsg *ifm;
  3127. struct nlattr *tb[IFA_MAX+1];
  3128. struct in6_addr *pfx, *peer_pfx;
  3129. int err;
  3130. err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
  3131. if (err < 0)
  3132. return err;
  3133. ifm = nlmsg_data(nlh);
  3134. pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
  3135. if (pfx == NULL)
  3136. return -EINVAL;
  3137. return inet6_addr_del(net, ifm->ifa_index, pfx, ifm->ifa_prefixlen);
  3138. }
  3139. static int inet6_addr_modify(struct inet6_ifaddr *ifp, u8 ifa_flags,
  3140. u32 prefered_lft, u32 valid_lft)
  3141. {
  3142. u32 flags;
  3143. clock_t expires;
  3144. unsigned long timeout;
  3145. if (!valid_lft || (prefered_lft > valid_lft))
  3146. return -EINVAL;
  3147. timeout = addrconf_timeout_fixup(valid_lft, HZ);
  3148. if (addrconf_finite_timeout(timeout)) {
  3149. expires = jiffies_to_clock_t(timeout * HZ);
  3150. valid_lft = timeout;
  3151. flags = RTF_EXPIRES;
  3152. } else {
  3153. expires = 0;
  3154. flags = 0;
  3155. ifa_flags |= IFA_F_PERMANENT;
  3156. }
  3157. timeout = addrconf_timeout_fixup(prefered_lft, HZ);
  3158. if (addrconf_finite_timeout(timeout)) {
  3159. if (timeout == 0)
  3160. ifa_flags |= IFA_F_DEPRECATED;
  3161. prefered_lft = timeout;
  3162. }
  3163. spin_lock_bh(&ifp->lock);
  3164. ifp->flags = (ifp->flags & ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD | IFA_F_HOMEADDRESS)) | ifa_flags;
  3165. ifp->tstamp = jiffies;
  3166. ifp->valid_lft = valid_lft;
  3167. ifp->prefered_lft = prefered_lft;
  3168. spin_unlock_bh(&ifp->lock);
  3169. if (!(ifp->flags&IFA_F_TENTATIVE))
  3170. ipv6_ifa_notify(0, ifp);
  3171. addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
  3172. expires, flags);
  3173. addrconf_verify(0);
  3174. return 0;
  3175. }
  3176. static int
  3177. inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
  3178. {
  3179. struct net *net = sock_net(skb->sk);
  3180. struct ifaddrmsg *ifm;
  3181. struct nlattr *tb[IFA_MAX+1];
  3182. struct in6_addr *pfx, *peer_pfx;
  3183. struct inet6_ifaddr *ifa;
  3184. struct net_device *dev;
  3185. u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
  3186. u8 ifa_flags;
  3187. int err;
  3188. err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
  3189. if (err < 0)
  3190. return err;
  3191. ifm = nlmsg_data(nlh);
  3192. pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
  3193. if (pfx == NULL)
  3194. return -EINVAL;
  3195. if (tb[IFA_CACHEINFO]) {
  3196. struct ifa_cacheinfo *ci;
  3197. ci = nla_data(tb[IFA_CACHEINFO]);
  3198. valid_lft = ci->ifa_valid;
  3199. preferred_lft = ci->ifa_prefered;
  3200. } else {
  3201. preferred_lft = INFINITY_LIFE_TIME;
  3202. valid_lft = INFINITY_LIFE_TIME;
  3203. }
  3204. dev = __dev_get_by_index(net, ifm->ifa_index);
  3205. if (dev == NULL)
  3206. return -ENODEV;
  3207. /* We ignore other flags so far. */
  3208. ifa_flags = ifm->ifa_flags & (IFA_F_NODAD | IFA_F_HOMEADDRESS);
  3209. ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
  3210. if (ifa == NULL) {
  3211. /*
  3212. * It would be best to check for !NLM_F_CREATE here but
  3213. * userspace alreay relies on not having to provide this.
  3214. */
  3215. return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
  3216. ifm->ifa_prefixlen, ifa_flags,
  3217. preferred_lft, valid_lft);
  3218. }
  3219. if (nlh->nlmsg_flags & NLM_F_EXCL ||
  3220. !(nlh->nlmsg_flags & NLM_F_REPLACE))
  3221. err = -EEXIST;
  3222. else
  3223. err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
  3224. in6_ifa_put(ifa);
  3225. return err;
  3226. }
  3227. static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u8 flags,
  3228. u8 scope, int ifindex)
  3229. {
  3230. struct ifaddrmsg *ifm;
  3231. ifm = nlmsg_data(nlh);
  3232. ifm->ifa_family = AF_INET6;
  3233. ifm->ifa_prefixlen = prefixlen;
  3234. ifm->ifa_flags = flags;
  3235. ifm->ifa_scope = scope;
  3236. ifm->ifa_index = ifindex;
  3237. }
  3238. static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
  3239. unsigned long tstamp, u32 preferred, u32 valid)
  3240. {
  3241. struct ifa_cacheinfo ci;
  3242. ci.cstamp = cstamp_delta(cstamp);
  3243. ci.tstamp = cstamp_delta(tstamp);
  3244. ci.ifa_prefered = preferred;
  3245. ci.ifa_valid = valid;
  3246. return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
  3247. }
  3248. static inline int rt_scope(int ifa_scope)
  3249. {
  3250. if (ifa_scope & IFA_HOST)
  3251. return RT_SCOPE_HOST;
  3252. else if (ifa_scope & IFA_LINK)
  3253. return RT_SCOPE_LINK;
  3254. else if (ifa_scope & IFA_SITE)
  3255. return RT_SCOPE_SITE;
  3256. else
  3257. return RT_SCOPE_UNIVERSE;
  3258. }
  3259. static inline int inet6_ifaddr_msgsize(void)
  3260. {
  3261. return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
  3262. + nla_total_size(16) /* IFA_LOCAL */
  3263. + nla_total_size(16) /* IFA_ADDRESS */
  3264. + nla_total_size(sizeof(struct ifa_cacheinfo));
  3265. }
  3266. static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
  3267. u32 portid, u32 seq, int event, unsigned int flags)
  3268. {
  3269. struct nlmsghdr *nlh;
  3270. u32 preferred, valid;
  3271. nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
  3272. if (nlh == NULL)
  3273. return -EMSGSIZE;
  3274. put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
  3275. ifa->idev->dev->ifindex);
  3276. if (!(ifa->flags&IFA_F_PERMANENT)) {
  3277. preferred = ifa->prefered_lft;
  3278. valid = ifa->valid_lft;
  3279. if (preferred != INFINITY_LIFE_TIME) {
  3280. long tval = (jiffies - ifa->tstamp)/HZ;
  3281. if (preferred > tval)
  3282. preferred -= tval;
  3283. else
  3284. preferred = 0;
  3285. if (valid != INFINITY_LIFE_TIME) {
  3286. if (valid > tval)
  3287. valid -= tval;
  3288. else
  3289. valid = 0;
  3290. }
  3291. }
  3292. } else {
  3293. preferred = INFINITY_LIFE_TIME;
  3294. valid = INFINITY_LIFE_TIME;
  3295. }
  3296. if (!ipv6_addr_any(&ifa->peer_addr)) {
  3297. if (nla_put(skb, IFA_LOCAL, 16, &ifa->addr) < 0 ||
  3298. nla_put(skb, IFA_ADDRESS, 16, &ifa->peer_addr) < 0)
  3299. goto error;
  3300. } else
  3301. if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0)
  3302. goto error;
  3303. if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
  3304. goto error;
  3305. return nlmsg_end(skb, nlh);
  3306. error:
  3307. nlmsg_cancel(skb, nlh);
  3308. return -EMSGSIZE;
  3309. }
  3310. static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
  3311. u32 portid, u32 seq, int event, u16 flags)
  3312. {
  3313. struct nlmsghdr *nlh;
  3314. u8 scope = RT_SCOPE_UNIVERSE;
  3315. int ifindex = ifmca->idev->dev->ifindex;
  3316. if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
  3317. scope = RT_SCOPE_SITE;
  3318. nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
  3319. if (nlh == NULL)
  3320. return -EMSGSIZE;
  3321. put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
  3322. if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 ||
  3323. put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
  3324. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
  3325. nlmsg_cancel(skb, nlh);
  3326. return -EMSGSIZE;
  3327. }
  3328. return nlmsg_end(skb, nlh);
  3329. }
  3330. static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
  3331. u32 portid, u32 seq, int event, unsigned int flags)
  3332. {
  3333. struct nlmsghdr *nlh;
  3334. u8 scope = RT_SCOPE_UNIVERSE;
  3335. int ifindex = ifaca->aca_idev->dev->ifindex;
  3336. if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
  3337. scope = RT_SCOPE_SITE;
  3338. nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
  3339. if (nlh == NULL)
  3340. return -EMSGSIZE;
  3341. put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
  3342. if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 ||
  3343. put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
  3344. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
  3345. nlmsg_cancel(skb, nlh);
  3346. return -EMSGSIZE;
  3347. }
  3348. return nlmsg_end(skb, nlh);
  3349. }
  3350. enum addr_type_t {
  3351. UNICAST_ADDR,
  3352. MULTICAST_ADDR,
  3353. ANYCAST_ADDR,
  3354. };
  3355. /* called with rcu_read_lock() */
  3356. static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
  3357. struct netlink_callback *cb, enum addr_type_t type,
  3358. int s_ip_idx, int *p_ip_idx)
  3359. {
  3360. struct ifmcaddr6 *ifmca;
  3361. struct ifacaddr6 *ifaca;
  3362. int err = 1;
  3363. int ip_idx = *p_ip_idx;
  3364. read_lock_bh(&idev->lock);
  3365. switch (type) {
  3366. case UNICAST_ADDR: {
  3367. struct inet6_ifaddr *ifa;
  3368. /* unicast address incl. temp addr */
  3369. list_for_each_entry(ifa, &idev->addr_list, if_list) {
  3370. if (++ip_idx < s_ip_idx)
  3371. continue;
  3372. err = inet6_fill_ifaddr(skb, ifa,
  3373. NETLINK_CB(cb->skb).portid,
  3374. cb->nlh->nlmsg_seq,
  3375. RTM_NEWADDR,
  3376. NLM_F_MULTI);
  3377. if (err <= 0)
  3378. break;
  3379. nl_dump_check_consistent(cb, nlmsg_hdr(skb));
  3380. }
  3381. break;
  3382. }
  3383. case MULTICAST_ADDR:
  3384. /* multicast address */
  3385. for (ifmca = idev->mc_list; ifmca;
  3386. ifmca = ifmca->next, ip_idx++) {
  3387. if (ip_idx < s_ip_idx)
  3388. continue;
  3389. err = inet6_fill_ifmcaddr(skb, ifmca,
  3390. NETLINK_CB(cb->skb).portid,
  3391. cb->nlh->nlmsg_seq,
  3392. RTM_GETMULTICAST,
  3393. NLM_F_MULTI);
  3394. if (err <= 0)
  3395. break;
  3396. }
  3397. break;
  3398. case ANYCAST_ADDR:
  3399. /* anycast address */
  3400. for (ifaca = idev->ac_list; ifaca;
  3401. ifaca = ifaca->aca_next, ip_idx++) {
  3402. if (ip_idx < s_ip_idx)
  3403. continue;
  3404. err = inet6_fill_ifacaddr(skb, ifaca,
  3405. NETLINK_CB(cb->skb).portid,
  3406. cb->nlh->nlmsg_seq,
  3407. RTM_GETANYCAST,
  3408. NLM_F_MULTI);
  3409. if (err <= 0)
  3410. break;
  3411. }
  3412. break;
  3413. default:
  3414. break;
  3415. }
  3416. read_unlock_bh(&idev->lock);
  3417. *p_ip_idx = ip_idx;
  3418. return err;
  3419. }
  3420. static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
  3421. enum addr_type_t type)
  3422. {
  3423. struct net *net = sock_net(skb->sk);
  3424. int h, s_h;
  3425. int idx, ip_idx;
  3426. int s_idx, s_ip_idx;
  3427. struct net_device *dev;
  3428. struct inet6_dev *idev;
  3429. struct hlist_head *head;
  3430. s_h = cb->args[0];
  3431. s_idx = idx = cb->args[1];
  3432. s_ip_idx = ip_idx = cb->args[2];
  3433. rcu_read_lock();
  3434. cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
  3435. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  3436. idx = 0;
  3437. head = &net->dev_index_head[h];
  3438. hlist_for_each_entry_rcu(dev, head, index_hlist) {
  3439. if (idx < s_idx)
  3440. goto cont;
  3441. if (h > s_h || idx > s_idx)
  3442. s_ip_idx = 0;
  3443. ip_idx = 0;
  3444. idev = __in6_dev_get(dev);
  3445. if (!idev)
  3446. goto cont;
  3447. if (in6_dump_addrs(idev, skb, cb, type,
  3448. s_ip_idx, &ip_idx) <= 0)
  3449. goto done;
  3450. cont:
  3451. idx++;
  3452. }
  3453. }
  3454. done:
  3455. rcu_read_unlock();
  3456. cb->args[0] = h;
  3457. cb->args[1] = idx;
  3458. cb->args[2] = ip_idx;
  3459. return skb->len;
  3460. }
  3461. static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
  3462. {
  3463. enum addr_type_t type = UNICAST_ADDR;
  3464. return inet6_dump_addr(skb, cb, type);
  3465. }
  3466. static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
  3467. {
  3468. enum addr_type_t type = MULTICAST_ADDR;
  3469. return inet6_dump_addr(skb, cb, type);
  3470. }
  3471. static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
  3472. {
  3473. enum addr_type_t type = ANYCAST_ADDR;
  3474. return inet6_dump_addr(skb, cb, type);
  3475. }
  3476. static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
  3477. {
  3478. struct net *net = sock_net(in_skb->sk);
  3479. struct ifaddrmsg *ifm;
  3480. struct nlattr *tb[IFA_MAX+1];
  3481. struct in6_addr *addr = NULL, *peer;
  3482. struct net_device *dev = NULL;
  3483. struct inet6_ifaddr *ifa;
  3484. struct sk_buff *skb;
  3485. int err;
  3486. err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
  3487. if (err < 0)
  3488. goto errout;
  3489. addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
  3490. if (addr == NULL) {
  3491. err = -EINVAL;
  3492. goto errout;
  3493. }
  3494. ifm = nlmsg_data(nlh);
  3495. if (ifm->ifa_index)
  3496. dev = __dev_get_by_index(net, ifm->ifa_index);
  3497. ifa = ipv6_get_ifaddr(net, addr, dev, 1);
  3498. if (!ifa) {
  3499. err = -EADDRNOTAVAIL;
  3500. goto errout;
  3501. }
  3502. skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
  3503. if (!skb) {
  3504. err = -ENOBUFS;
  3505. goto errout_ifa;
  3506. }
  3507. err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
  3508. nlh->nlmsg_seq, RTM_NEWADDR, 0);
  3509. if (err < 0) {
  3510. /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
  3511. WARN_ON(err == -EMSGSIZE);
  3512. kfree_skb(skb);
  3513. goto errout_ifa;
  3514. }
  3515. err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
  3516. errout_ifa:
  3517. in6_ifa_put(ifa);
  3518. errout:
  3519. return err;
  3520. }
  3521. static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
  3522. {
  3523. struct sk_buff *skb;
  3524. struct net *net = dev_net(ifa->idev->dev);
  3525. int err = -ENOBUFS;
  3526. skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
  3527. if (skb == NULL)
  3528. goto errout;
  3529. err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
  3530. if (err < 0) {
  3531. /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
  3532. WARN_ON(err == -EMSGSIZE);
  3533. kfree_skb(skb);
  3534. goto errout;
  3535. }
  3536. rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
  3537. return;
  3538. errout:
  3539. if (err < 0)
  3540. rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
  3541. }
  3542. static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
  3543. __s32 *array, int bytes)
  3544. {
  3545. BUG_ON(bytes < (DEVCONF_MAX * 4));
  3546. memset(array, 0, bytes);
  3547. array[DEVCONF_FORWARDING] = cnf->forwarding;
  3548. array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
  3549. array[DEVCONF_MTU6] = cnf->mtu6;
  3550. array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
  3551. array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
  3552. array[DEVCONF_AUTOCONF] = cnf->autoconf;
  3553. array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
  3554. array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
  3555. array[DEVCONF_RTR_SOLICIT_INTERVAL] =
  3556. jiffies_to_msecs(cnf->rtr_solicit_interval);
  3557. array[DEVCONF_RTR_SOLICIT_DELAY] =
  3558. jiffies_to_msecs(cnf->rtr_solicit_delay);
  3559. array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
  3560. #ifdef CONFIG_IPV6_PRIVACY
  3561. array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
  3562. array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
  3563. array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
  3564. array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
  3565. array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
  3566. #endif
  3567. array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
  3568. array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
  3569. array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
  3570. #ifdef CONFIG_IPV6_ROUTER_PREF
  3571. array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
  3572. array[DEVCONF_RTR_PROBE_INTERVAL] =
  3573. jiffies_to_msecs(cnf->rtr_probe_interval);
  3574. #ifdef CONFIG_IPV6_ROUTE_INFO
  3575. array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
  3576. #endif
  3577. #endif
  3578. array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
  3579. array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
  3580. #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
  3581. array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
  3582. #endif
  3583. #ifdef CONFIG_IPV6_MROUTE
  3584. array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
  3585. #endif
  3586. array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
  3587. array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
  3588. array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
  3589. array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
  3590. }
  3591. static inline size_t inet6_ifla6_size(void)
  3592. {
  3593. return nla_total_size(4) /* IFLA_INET6_FLAGS */
  3594. + nla_total_size(sizeof(struct ifla_cacheinfo))
  3595. + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
  3596. + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
  3597. + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
  3598. + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
  3599. }
  3600. static inline size_t inet6_if_nlmsg_size(void)
  3601. {
  3602. return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  3603. + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
  3604. + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  3605. + nla_total_size(4) /* IFLA_MTU */
  3606. + nla_total_size(4) /* IFLA_LINK */
  3607. + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
  3608. }
  3609. static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
  3610. int items, int bytes)
  3611. {
  3612. int i;
  3613. int pad = bytes - sizeof(u64) * items;
  3614. BUG_ON(pad < 0);
  3615. /* Use put_unaligned() because stats may not be aligned for u64. */
  3616. put_unaligned(items, &stats[0]);
  3617. for (i = 1; i < items; i++)
  3618. put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
  3619. memset(&stats[items], 0, pad);
  3620. }
  3621. static inline void __snmp6_fill_stats64(u64 *stats, void __percpu **mib,
  3622. int items, int bytes, size_t syncpoff)
  3623. {
  3624. int i;
  3625. int pad = bytes - sizeof(u64) * items;
  3626. BUG_ON(pad < 0);
  3627. /* Use put_unaligned() because stats may not be aligned for u64. */
  3628. put_unaligned(items, &stats[0]);
  3629. for (i = 1; i < items; i++)
  3630. put_unaligned(snmp_fold_field64(mib, i, syncpoff), &stats[i]);
  3631. memset(&stats[items], 0, pad);
  3632. }
  3633. static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
  3634. int bytes)
  3635. {
  3636. switch (attrtype) {
  3637. case IFLA_INET6_STATS:
  3638. __snmp6_fill_stats64(stats, (void __percpu **)idev->stats.ipv6,
  3639. IPSTATS_MIB_MAX, bytes, offsetof(struct ipstats_mib, syncp));
  3640. break;
  3641. case IFLA_INET6_ICMP6STATS:
  3642. __snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes);
  3643. break;
  3644. }
  3645. }
  3646. static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev)
  3647. {
  3648. struct nlattr *nla;
  3649. struct ifla_cacheinfo ci;
  3650. if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
  3651. goto nla_put_failure;
  3652. ci.max_reasm_len = IPV6_MAXPLEN;
  3653. ci.tstamp = cstamp_delta(idev->tstamp);
  3654. ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
  3655. ci.retrans_time = jiffies_to_msecs(idev->nd_parms->retrans_time);
  3656. if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
  3657. goto nla_put_failure;
  3658. nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
  3659. if (nla == NULL)
  3660. goto nla_put_failure;
  3661. ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
  3662. /* XXX - MC not implemented */
  3663. nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
  3664. if (nla == NULL)
  3665. goto nla_put_failure;
  3666. snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
  3667. nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
  3668. if (nla == NULL)
  3669. goto nla_put_failure;
  3670. snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
  3671. nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
  3672. if (nla == NULL)
  3673. goto nla_put_failure;
  3674. read_lock_bh(&idev->lock);
  3675. memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
  3676. read_unlock_bh(&idev->lock);
  3677. return 0;
  3678. nla_put_failure:
  3679. return -EMSGSIZE;
  3680. }
  3681. static size_t inet6_get_link_af_size(const struct net_device *dev)
  3682. {
  3683. if (!__in6_dev_get(dev))
  3684. return 0;
  3685. return inet6_ifla6_size();
  3686. }
  3687. static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
  3688. {
  3689. struct inet6_dev *idev = __in6_dev_get(dev);
  3690. if (!idev)
  3691. return -ENODATA;
  3692. if (inet6_fill_ifla6_attrs(skb, idev) < 0)
  3693. return -EMSGSIZE;
  3694. return 0;
  3695. }
  3696. static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
  3697. {
  3698. struct inet6_ifaddr *ifp;
  3699. struct net_device *dev = idev->dev;
  3700. bool update_rs = false;
  3701. struct in6_addr ll_addr;
  3702. if (token == NULL)
  3703. return -EINVAL;
  3704. if (ipv6_addr_any(token))
  3705. return -EINVAL;
  3706. if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
  3707. return -EINVAL;
  3708. if (!ipv6_accept_ra(idev))
  3709. return -EINVAL;
  3710. if (idev->cnf.rtr_solicits <= 0)
  3711. return -EINVAL;
  3712. write_lock_bh(&idev->lock);
  3713. BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
  3714. memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);
  3715. write_unlock_bh(&idev->lock);
  3716. if (!idev->dead && (idev->if_flags & IF_READY) &&
  3717. !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
  3718. IFA_F_OPTIMISTIC)) {
  3719. /* If we're not ready, then normal ifup will take care
  3720. * of this. Otherwise, we need to request our rs here.
  3721. */
  3722. ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
  3723. update_rs = true;
  3724. }
  3725. write_lock_bh(&idev->lock);
  3726. if (update_rs) {
  3727. idev->if_flags |= IF_RS_SENT;
  3728. idev->rs_probes = 1;
  3729. addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval);
  3730. }
  3731. /* Well, that's kinda nasty ... */
  3732. list_for_each_entry(ifp, &idev->addr_list, if_list) {
  3733. spin_lock(&ifp->lock);
  3734. if (ifp->tokenized) {
  3735. ifp->valid_lft = 0;
  3736. ifp->prefered_lft = 0;
  3737. }
  3738. spin_unlock(&ifp->lock);
  3739. }
  3740. write_unlock_bh(&idev->lock);
  3741. addrconf_verify(0);
  3742. return 0;
  3743. }
  3744. static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
  3745. {
  3746. int err = -EINVAL;
  3747. struct inet6_dev *idev = __in6_dev_get(dev);
  3748. struct nlattr *tb[IFLA_INET6_MAX + 1];
  3749. if (!idev)
  3750. return -EAFNOSUPPORT;
  3751. if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0)
  3752. BUG();
  3753. if (tb[IFLA_INET6_TOKEN])
  3754. err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
  3755. return err;
  3756. }
  3757. static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
  3758. u32 portid, u32 seq, int event, unsigned int flags)
  3759. {
  3760. struct net_device *dev = idev->dev;
  3761. struct ifinfomsg *hdr;
  3762. struct nlmsghdr *nlh;
  3763. void *protoinfo;
  3764. nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
  3765. if (nlh == NULL)
  3766. return -EMSGSIZE;
  3767. hdr = nlmsg_data(nlh);
  3768. hdr->ifi_family = AF_INET6;
  3769. hdr->__ifi_pad = 0;
  3770. hdr->ifi_type = dev->type;
  3771. hdr->ifi_index = dev->ifindex;
  3772. hdr->ifi_flags = dev_get_flags(dev);
  3773. hdr->ifi_change = 0;
  3774. if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
  3775. (dev->addr_len &&
  3776. nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
  3777. nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
  3778. (dev->ifindex != dev->iflink &&
  3779. nla_put_u32(skb, IFLA_LINK, dev->iflink)))
  3780. goto nla_put_failure;
  3781. protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
  3782. if (protoinfo == NULL)
  3783. goto nla_put_failure;
  3784. if (inet6_fill_ifla6_attrs(skb, idev) < 0)
  3785. goto nla_put_failure;
  3786. nla_nest_end(skb, protoinfo);
  3787. return nlmsg_end(skb, nlh);
  3788. nla_put_failure:
  3789. nlmsg_cancel(skb, nlh);
  3790. return -EMSGSIZE;
  3791. }
  3792. static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
  3793. {
  3794. struct net *net = sock_net(skb->sk);
  3795. int h, s_h;
  3796. int idx = 0, s_idx;
  3797. struct net_device *dev;
  3798. struct inet6_dev *idev;
  3799. struct hlist_head *head;
  3800. s_h = cb->args[0];
  3801. s_idx = cb->args[1];
  3802. rcu_read_lock();
  3803. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  3804. idx = 0;
  3805. head = &net->dev_index_head[h];
  3806. hlist_for_each_entry_rcu(dev, head, index_hlist) {
  3807. if (idx < s_idx)
  3808. goto cont;
  3809. idev = __in6_dev_get(dev);
  3810. if (!idev)
  3811. goto cont;
  3812. if (inet6_fill_ifinfo(skb, idev,
  3813. NETLINK_CB(cb->skb).portid,
  3814. cb->nlh->nlmsg_seq,
  3815. RTM_NEWLINK, NLM_F_MULTI) <= 0)
  3816. goto out;
  3817. cont:
  3818. idx++;
  3819. }
  3820. }
  3821. out:
  3822. rcu_read_unlock();
  3823. cb->args[1] = idx;
  3824. cb->args[0] = h;
  3825. return skb->len;
  3826. }
  3827. void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
  3828. {
  3829. struct sk_buff *skb;
  3830. struct net *net = dev_net(idev->dev);
  3831. int err = -ENOBUFS;
  3832. skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
  3833. if (skb == NULL)
  3834. goto errout;
  3835. err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
  3836. if (err < 0) {
  3837. /* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
  3838. WARN_ON(err == -EMSGSIZE);
  3839. kfree_skb(skb);
  3840. goto errout;
  3841. }
  3842. rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
  3843. return;
  3844. errout:
  3845. if (err < 0)
  3846. rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
  3847. }
  3848. static inline size_t inet6_prefix_nlmsg_size(void)
  3849. {
  3850. return NLMSG_ALIGN(sizeof(struct prefixmsg))
  3851. + nla_total_size(sizeof(struct in6_addr))
  3852. + nla_total_size(sizeof(struct prefix_cacheinfo));
  3853. }
  3854. static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
  3855. struct prefix_info *pinfo, u32 portid, u32 seq,
  3856. int event, unsigned int flags)
  3857. {
  3858. struct prefixmsg *pmsg;
  3859. struct nlmsghdr *nlh;
  3860. struct prefix_cacheinfo ci;
  3861. nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
  3862. if (nlh == NULL)
  3863. return -EMSGSIZE;
  3864. pmsg = nlmsg_data(nlh);
  3865. pmsg->prefix_family = AF_INET6;
  3866. pmsg->prefix_pad1 = 0;
  3867. pmsg->prefix_pad2 = 0;
  3868. pmsg->prefix_ifindex = idev->dev->ifindex;
  3869. pmsg->prefix_len = pinfo->prefix_len;
  3870. pmsg->prefix_type = pinfo->type;
  3871. pmsg->prefix_pad3 = 0;
  3872. pmsg->prefix_flags = 0;
  3873. if (pinfo->onlink)
  3874. pmsg->prefix_flags |= IF_PREFIX_ONLINK;
  3875. if (pinfo->autoconf)
  3876. pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
  3877. if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
  3878. goto nla_put_failure;
  3879. ci.preferred_time = ntohl(pinfo->prefered);
  3880. ci.valid_time = ntohl(pinfo->valid);
  3881. if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
  3882. goto nla_put_failure;
  3883. return nlmsg_end(skb, nlh);
  3884. nla_put_failure:
  3885. nlmsg_cancel(skb, nlh);
  3886. return -EMSGSIZE;
  3887. }
  3888. static void inet6_prefix_notify(int event, struct inet6_dev *idev,
  3889. struct prefix_info *pinfo)
  3890. {
  3891. struct sk_buff *skb;
  3892. struct net *net = dev_net(idev->dev);
  3893. int err = -ENOBUFS;
  3894. skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
  3895. if (skb == NULL)
  3896. goto errout;
  3897. err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
  3898. if (err < 0) {
  3899. /* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
  3900. WARN_ON(err == -EMSGSIZE);
  3901. kfree_skb(skb);
  3902. goto errout;
  3903. }
  3904. rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
  3905. return;
  3906. errout:
  3907. if (err < 0)
  3908. rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
  3909. }
  3910. static void update_valid_ll_addr_cnt(struct inet6_ifaddr *ifp, int count)
  3911. {
  3912. write_lock_bh(&ifp->idev->lock);
  3913. spin_lock(&ifp->lock);
  3914. if (((ifp->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|
  3915. IFA_F_DADFAILED)) == IFA_F_PERMANENT) &&
  3916. (ipv6_addr_type(&ifp->addr) & IPV6_ADDR_LINKLOCAL))
  3917. ifp->idev->valid_ll_addr_cnt += count;
  3918. WARN_ON(ifp->idev->valid_ll_addr_cnt < 0);
  3919. spin_unlock(&ifp->lock);
  3920. write_unlock_bh(&ifp->idev->lock);
  3921. }
  3922. static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
  3923. {
  3924. struct net *net = dev_net(ifp->idev->dev);
  3925. inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
  3926. switch (event) {
  3927. case RTM_NEWADDR:
  3928. update_valid_ll_addr_cnt(ifp, 1);
  3929. /*
  3930. * If the address was optimistic
  3931. * we inserted the route at the start of
  3932. * our DAD process, so we don't need
  3933. * to do it again
  3934. */
  3935. if (!(ifp->rt->rt6i_node))
  3936. ip6_ins_rt(ifp->rt);
  3937. if (ifp->idev->cnf.forwarding)
  3938. addrconf_join_anycast(ifp);
  3939. if (!ipv6_addr_any(&ifp->peer_addr))
  3940. addrconf_prefix_route(&ifp->peer_addr, 128,
  3941. ifp->idev->dev, 0, 0);
  3942. break;
  3943. case RTM_DELADDR:
  3944. update_valid_ll_addr_cnt(ifp, -1);
  3945. if (ifp->idev->cnf.forwarding)
  3946. addrconf_leave_anycast(ifp);
  3947. addrconf_leave_solict(ifp->idev, &ifp->addr);
  3948. if (!ipv6_addr_any(&ifp->peer_addr)) {
  3949. struct rt6_info *rt;
  3950. struct net_device *dev = ifp->idev->dev;
  3951. rt = rt6_lookup(dev_net(dev), &ifp->peer_addr, NULL,
  3952. dev->ifindex, 1);
  3953. if (rt) {
  3954. dst_hold(&rt->dst);
  3955. if (ip6_del_rt(rt))
  3956. dst_free(&rt->dst);
  3957. }
  3958. }
  3959. dst_hold(&ifp->rt->dst);
  3960. if (ip6_del_rt(ifp->rt))
  3961. dst_free(&ifp->rt->dst);
  3962. break;
  3963. }
  3964. atomic_inc(&net->ipv6.dev_addr_genid);
  3965. }
  3966. static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
  3967. {
  3968. rcu_read_lock_bh();
  3969. if (likely(ifp->idev->dead == 0))
  3970. __ipv6_ifa_notify(event, ifp);
  3971. rcu_read_unlock_bh();
  3972. }
  3973. #ifdef CONFIG_SYSCTL
  3974. static
  3975. int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
  3976. void __user *buffer, size_t *lenp, loff_t *ppos)
  3977. {
  3978. int *valp = ctl->data;
  3979. int val = *valp;
  3980. loff_t pos = *ppos;
  3981. struct ctl_table lctl;
  3982. int ret;
  3983. /*
  3984. * ctl->data points to idev->cnf.forwarding, we should
  3985. * not modify it until we get the rtnl lock.
  3986. */
  3987. lctl = *ctl;
  3988. lctl.data = &val;
  3989. ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
  3990. if (write)
  3991. ret = addrconf_fixup_forwarding(ctl, valp, val);
  3992. if (ret)
  3993. *ppos = pos;
  3994. return ret;
  3995. }
  3996. static void dev_disable_change(struct inet6_dev *idev)
  3997. {
  3998. struct netdev_notifier_info info;
  3999. if (!idev || !idev->dev)
  4000. return;
  4001. netdev_notifier_info_init(&info, idev->dev);
  4002. if (idev->cnf.disable_ipv6)
  4003. addrconf_notify(NULL, NETDEV_DOWN, &info);
  4004. else
  4005. addrconf_notify(NULL, NETDEV_UP, &info);
  4006. }
  4007. static void addrconf_disable_change(struct net *net, __s32 newf)
  4008. {
  4009. struct net_device *dev;
  4010. struct inet6_dev *idev;
  4011. rcu_read_lock();
  4012. for_each_netdev_rcu(net, dev) {
  4013. idev = __in6_dev_get(dev);
  4014. if (idev) {
  4015. int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
  4016. idev->cnf.disable_ipv6 = newf;
  4017. if (changed)
  4018. dev_disable_change(idev);
  4019. }
  4020. }
  4021. rcu_read_unlock();
  4022. }
  4023. static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
  4024. {
  4025. struct net *net;
  4026. int old;
  4027. if (!rtnl_trylock())
  4028. return restart_syscall();
  4029. net = (struct net *)table->extra2;
  4030. old = *p;
  4031. *p = newf;
  4032. if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
  4033. rtnl_unlock();
  4034. return 0;
  4035. }
  4036. if (p == &net->ipv6.devconf_all->disable_ipv6) {
  4037. net->ipv6.devconf_dflt->disable_ipv6 = newf;
  4038. addrconf_disable_change(net, newf);
  4039. } else if ((!newf) ^ (!old))
  4040. dev_disable_change((struct inet6_dev *)table->extra1);
  4041. rtnl_unlock();
  4042. return 0;
  4043. }
  4044. static
  4045. int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
  4046. void __user *buffer, size_t *lenp, loff_t *ppos)
  4047. {
  4048. int *valp = ctl->data;
  4049. int val = *valp;
  4050. loff_t pos = *ppos;
  4051. struct ctl_table lctl;
  4052. int ret;
  4053. /*
  4054. * ctl->data points to idev->cnf.disable_ipv6, we should
  4055. * not modify it until we get the rtnl lock.
  4056. */
  4057. lctl = *ctl;
  4058. lctl.data = &val;
  4059. ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
  4060. if (write)
  4061. ret = addrconf_disable_ipv6(ctl, valp, val);
  4062. if (ret)
  4063. *ppos = pos;
  4064. return ret;
  4065. }
  4066. static struct addrconf_sysctl_table
  4067. {
  4068. struct ctl_table_header *sysctl_header;
  4069. struct ctl_table addrconf_vars[DEVCONF_MAX+1];
  4070. } addrconf_sysctl __read_mostly = {
  4071. .sysctl_header = NULL,
  4072. .addrconf_vars = {
  4073. {
  4074. .procname = "forwarding",
  4075. .data = &ipv6_devconf.forwarding,
  4076. .maxlen = sizeof(int),
  4077. .mode = 0644,
  4078. .proc_handler = addrconf_sysctl_forward,
  4079. },
  4080. {
  4081. .procname = "hop_limit",
  4082. .data = &ipv6_devconf.hop_limit,
  4083. .maxlen = sizeof(int),
  4084. .mode = 0644,
  4085. .proc_handler = proc_dointvec,
  4086. },
  4087. {
  4088. .procname = "mtu",
  4089. .data = &ipv6_devconf.mtu6,
  4090. .maxlen = sizeof(int),
  4091. .mode = 0644,
  4092. .proc_handler = proc_dointvec,
  4093. },
  4094. {
  4095. .procname = "accept_ra",
  4096. .data = &ipv6_devconf.accept_ra,
  4097. .maxlen = sizeof(int),
  4098. .mode = 0644,
  4099. .proc_handler = proc_dointvec,
  4100. },
  4101. {
  4102. .procname = "accept_redirects",
  4103. .data = &ipv6_devconf.accept_redirects,
  4104. .maxlen = sizeof(int),
  4105. .mode = 0644,
  4106. .proc_handler = proc_dointvec,
  4107. },
  4108. {
  4109. .procname = "autoconf",
  4110. .data = &ipv6_devconf.autoconf,
  4111. .maxlen = sizeof(int),
  4112. .mode = 0644,
  4113. .proc_handler = proc_dointvec,
  4114. },
  4115. {
  4116. .procname = "dad_transmits",
  4117. .data = &ipv6_devconf.dad_transmits,
  4118. .maxlen = sizeof(int),
  4119. .mode = 0644,
  4120. .proc_handler = proc_dointvec,
  4121. },
  4122. {
  4123. .procname = "router_solicitations",
  4124. .data = &ipv6_devconf.rtr_solicits,
  4125. .maxlen = sizeof(int),
  4126. .mode = 0644,
  4127. .proc_handler = proc_dointvec,
  4128. },
  4129. {
  4130. .procname = "router_solicitation_interval",
  4131. .data = &ipv6_devconf.rtr_solicit_interval,
  4132. .maxlen = sizeof(int),
  4133. .mode = 0644,
  4134. .proc_handler = proc_dointvec_jiffies,
  4135. },
  4136. {
  4137. .procname = "router_solicitation_delay",
  4138. .data = &ipv6_devconf.rtr_solicit_delay,
  4139. .maxlen = sizeof(int),
  4140. .mode = 0644,
  4141. .proc_handler = proc_dointvec_jiffies,
  4142. },
  4143. {
  4144. .procname = "force_mld_version",
  4145. .data = &ipv6_devconf.force_mld_version,
  4146. .maxlen = sizeof(int),
  4147. .mode = 0644,
  4148. .proc_handler = proc_dointvec,
  4149. },
  4150. #ifdef CONFIG_IPV6_PRIVACY
  4151. {
  4152. .procname = "use_tempaddr",
  4153. .data = &ipv6_devconf.use_tempaddr,
  4154. .maxlen = sizeof(int),
  4155. .mode = 0644,
  4156. .proc_handler = proc_dointvec,
  4157. },
  4158. {
  4159. .procname = "temp_valid_lft",
  4160. .data = &ipv6_devconf.temp_valid_lft,
  4161. .maxlen = sizeof(int),
  4162. .mode = 0644,
  4163. .proc_handler = proc_dointvec,
  4164. },
  4165. {
  4166. .procname = "temp_prefered_lft",
  4167. .data = &ipv6_devconf.temp_prefered_lft,
  4168. .maxlen = sizeof(int),
  4169. .mode = 0644,
  4170. .proc_handler = proc_dointvec,
  4171. },
  4172. {
  4173. .procname = "regen_max_retry",
  4174. .data = &ipv6_devconf.regen_max_retry,
  4175. .maxlen = sizeof(int),
  4176. .mode = 0644,
  4177. .proc_handler = proc_dointvec,
  4178. },
  4179. {
  4180. .procname = "max_desync_factor",
  4181. .data = &ipv6_devconf.max_desync_factor,
  4182. .maxlen = sizeof(int),
  4183. .mode = 0644,
  4184. .proc_handler = proc_dointvec,
  4185. },
  4186. #endif
  4187. {
  4188. .procname = "max_addresses",
  4189. .data = &ipv6_devconf.max_addresses,
  4190. .maxlen = sizeof(int),
  4191. .mode = 0644,
  4192. .proc_handler = proc_dointvec,
  4193. },
  4194. {
  4195. .procname = "accept_ra_defrtr",
  4196. .data = &ipv6_devconf.accept_ra_defrtr,
  4197. .maxlen = sizeof(int),
  4198. .mode = 0644,
  4199. .proc_handler = proc_dointvec,
  4200. },
  4201. {
  4202. .procname = "accept_ra_pinfo",
  4203. .data = &ipv6_devconf.accept_ra_pinfo,
  4204. .maxlen = sizeof(int),
  4205. .mode = 0644,
  4206. .proc_handler = proc_dointvec,
  4207. },
  4208. #ifdef CONFIG_IPV6_ROUTER_PREF
  4209. {
  4210. .procname = "accept_ra_rtr_pref",
  4211. .data = &ipv6_devconf.accept_ra_rtr_pref,
  4212. .maxlen = sizeof(int),
  4213. .mode = 0644,
  4214. .proc_handler = proc_dointvec,
  4215. },
  4216. {
  4217. .procname = "router_probe_interval",
  4218. .data = &ipv6_devconf.rtr_probe_interval,
  4219. .maxlen = sizeof(int),
  4220. .mode = 0644,
  4221. .proc_handler = proc_dointvec_jiffies,
  4222. },
  4223. #ifdef CONFIG_IPV6_ROUTE_INFO
  4224. {
  4225. .procname = "accept_ra_rt_info_max_plen",
  4226. .data = &ipv6_devconf.accept_ra_rt_info_max_plen,
  4227. .maxlen = sizeof(int),
  4228. .mode = 0644,
  4229. .proc_handler = proc_dointvec,
  4230. },
  4231. #endif
  4232. #endif
  4233. {
  4234. .procname = "proxy_ndp",
  4235. .data = &ipv6_devconf.proxy_ndp,
  4236. .maxlen = sizeof(int),
  4237. .mode = 0644,
  4238. .proc_handler = proc_dointvec,
  4239. },
  4240. {
  4241. .procname = "accept_source_route",
  4242. .data = &ipv6_devconf.accept_source_route,
  4243. .maxlen = sizeof(int),
  4244. .mode = 0644,
  4245. .proc_handler = proc_dointvec,
  4246. },
  4247. #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
  4248. {
  4249. .procname = "optimistic_dad",
  4250. .data = &ipv6_devconf.optimistic_dad,
  4251. .maxlen = sizeof(int),
  4252. .mode = 0644,
  4253. .proc_handler = proc_dointvec,
  4254. },
  4255. #endif
  4256. #ifdef CONFIG_IPV6_MROUTE
  4257. {
  4258. .procname = "mc_forwarding",
  4259. .data = &ipv6_devconf.mc_forwarding,
  4260. .maxlen = sizeof(int),
  4261. .mode = 0444,
  4262. .proc_handler = proc_dointvec,
  4263. },
  4264. #endif
  4265. {
  4266. .procname = "disable_ipv6",
  4267. .data = &ipv6_devconf.disable_ipv6,
  4268. .maxlen = sizeof(int),
  4269. .mode = 0644,
  4270. .proc_handler = addrconf_sysctl_disable,
  4271. },
  4272. {
  4273. .procname = "accept_dad",
  4274. .data = &ipv6_devconf.accept_dad,
  4275. .maxlen = sizeof(int),
  4276. .mode = 0644,
  4277. .proc_handler = proc_dointvec,
  4278. },
  4279. {
  4280. .procname = "force_tllao",
  4281. .data = &ipv6_devconf.force_tllao,
  4282. .maxlen = sizeof(int),
  4283. .mode = 0644,
  4284. .proc_handler = proc_dointvec
  4285. },
  4286. {
  4287. .procname = "ndisc_notify",
  4288. .data = &ipv6_devconf.ndisc_notify,
  4289. .maxlen = sizeof(int),
  4290. .mode = 0644,
  4291. .proc_handler = proc_dointvec
  4292. },
  4293. {
  4294. /* sentinel */
  4295. }
  4296. },
  4297. };
  4298. static int __addrconf_sysctl_register(struct net *net, char *dev_name,
  4299. struct inet6_dev *idev, struct ipv6_devconf *p)
  4300. {
  4301. int i;
  4302. struct addrconf_sysctl_table *t;
  4303. char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
  4304. t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
  4305. if (t == NULL)
  4306. goto out;
  4307. for (i = 0; t->addrconf_vars[i].data; i++) {
  4308. t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
  4309. t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
  4310. t->addrconf_vars[i].extra2 = net;
  4311. }
  4312. snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
  4313. t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars);
  4314. if (t->sysctl_header == NULL)
  4315. goto free;
  4316. p->sysctl = t;
  4317. return 0;
  4318. free:
  4319. kfree(t);
  4320. out:
  4321. return -ENOBUFS;
  4322. }
  4323. static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
  4324. {
  4325. struct addrconf_sysctl_table *t;
  4326. if (p->sysctl == NULL)
  4327. return;
  4328. t = p->sysctl;
  4329. p->sysctl = NULL;
  4330. unregister_net_sysctl_table(t->sysctl_header);
  4331. kfree(t);
  4332. }
  4333. static void addrconf_sysctl_register(struct inet6_dev *idev)
  4334. {
  4335. neigh_sysctl_register(idev->dev, idev->nd_parms, "ipv6",
  4336. &ndisc_ifinfo_sysctl_change);
  4337. __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
  4338. idev, &idev->cnf);
  4339. }
  4340. static void addrconf_sysctl_unregister(struct inet6_dev *idev)
  4341. {
  4342. __addrconf_sysctl_unregister(&idev->cnf);
  4343. neigh_sysctl_unregister(idev->nd_parms);
  4344. }
  4345. #endif
  4346. static int __net_init addrconf_init_net(struct net *net)
  4347. {
  4348. int err = -ENOMEM;
  4349. struct ipv6_devconf *all, *dflt;
  4350. all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
  4351. if (all == NULL)
  4352. goto err_alloc_all;
  4353. dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
  4354. if (dflt == NULL)
  4355. goto err_alloc_dflt;
  4356. /* these will be inherited by all namespaces */
  4357. dflt->autoconf = ipv6_defaults.autoconf;
  4358. dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
  4359. net->ipv6.devconf_all = all;
  4360. net->ipv6.devconf_dflt = dflt;
  4361. #ifdef CONFIG_SYSCTL
  4362. err = __addrconf_sysctl_register(net, "all", NULL, all);
  4363. if (err < 0)
  4364. goto err_reg_all;
  4365. err = __addrconf_sysctl_register(net, "default", NULL, dflt);
  4366. if (err < 0)
  4367. goto err_reg_dflt;
  4368. #endif
  4369. return 0;
  4370. #ifdef CONFIG_SYSCTL
  4371. err_reg_dflt:
  4372. __addrconf_sysctl_unregister(all);
  4373. err_reg_all:
  4374. kfree(dflt);
  4375. #endif
  4376. err_alloc_dflt:
  4377. kfree(all);
  4378. err_alloc_all:
  4379. return err;
  4380. }
  4381. static void __net_exit addrconf_exit_net(struct net *net)
  4382. {
  4383. #ifdef CONFIG_SYSCTL
  4384. __addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
  4385. __addrconf_sysctl_unregister(net->ipv6.devconf_all);
  4386. #endif
  4387. if (!net_eq(net, &init_net)) {
  4388. kfree(net->ipv6.devconf_dflt);
  4389. kfree(net->ipv6.devconf_all);
  4390. }
  4391. }
  4392. static struct pernet_operations addrconf_ops = {
  4393. .init = addrconf_init_net,
  4394. .exit = addrconf_exit_net,
  4395. };
  4396. static struct rtnl_af_ops inet6_ops = {
  4397. .family = AF_INET6,
  4398. .fill_link_af = inet6_fill_link_af,
  4399. .get_link_af_size = inet6_get_link_af_size,
  4400. .set_link_af = inet6_set_link_af,
  4401. };
  4402. /*
  4403. * Init / cleanup code
  4404. */
  4405. int __init addrconf_init(void)
  4406. {
  4407. int i, err;
  4408. err = ipv6_addr_label_init();
  4409. if (err < 0) {
  4410. pr_crit("%s: cannot initialize default policy table: %d\n",
  4411. __func__, err);
  4412. goto out;
  4413. }
  4414. err = register_pernet_subsys(&addrconf_ops);
  4415. if (err < 0)
  4416. goto out_addrlabel;
  4417. /* The addrconf netdev notifier requires that loopback_dev
  4418. * has it's ipv6 private information allocated and setup
  4419. * before it can bring up and give link-local addresses
  4420. * to other devices which are up.
  4421. *
  4422. * Unfortunately, loopback_dev is not necessarily the first
  4423. * entry in the global dev_base list of net devices. In fact,
  4424. * it is likely to be the very last entry on that list.
  4425. * So this causes the notifier registry below to try and
  4426. * give link-local addresses to all devices besides loopback_dev
  4427. * first, then loopback_dev, which cases all the non-loopback_dev
  4428. * devices to fail to get a link-local address.
  4429. *
  4430. * So, as a temporary fix, allocate the ipv6 structure for
  4431. * loopback_dev first by hand.
  4432. * Longer term, all of the dependencies ipv6 has upon the loopback
  4433. * device and it being up should be removed.
  4434. */
  4435. rtnl_lock();
  4436. if (!ipv6_add_dev(init_net.loopback_dev))
  4437. err = -ENOMEM;
  4438. rtnl_unlock();
  4439. if (err)
  4440. goto errlo;
  4441. for (i = 0; i < IN6_ADDR_HSIZE; i++)
  4442. INIT_HLIST_HEAD(&inet6_addr_lst[i]);
  4443. register_netdevice_notifier(&ipv6_dev_notf);
  4444. addrconf_verify(0);
  4445. err = rtnl_af_register(&inet6_ops);
  4446. if (err < 0)
  4447. goto errout_af;
  4448. err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo,
  4449. NULL);
  4450. if (err < 0)
  4451. goto errout;
  4452. /* Only the first call to __rtnl_register can fail */
  4453. __rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL);
  4454. __rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL);
  4455. __rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr,
  4456. inet6_dump_ifaddr, NULL);
  4457. __rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL,
  4458. inet6_dump_ifmcaddr, NULL);
  4459. __rtnl_register(PF_INET6, RTM_GETANYCAST, NULL,
  4460. inet6_dump_ifacaddr, NULL);
  4461. __rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf,
  4462. inet6_netconf_dump_devconf, NULL);
  4463. ipv6_addr_label_rtnl_register();
  4464. return 0;
  4465. errout:
  4466. rtnl_af_unregister(&inet6_ops);
  4467. errout_af:
  4468. unregister_netdevice_notifier(&ipv6_dev_notf);
  4469. errlo:
  4470. unregister_pernet_subsys(&addrconf_ops);
  4471. out_addrlabel:
  4472. ipv6_addr_label_cleanup();
  4473. out:
  4474. return err;
  4475. }
  4476. void addrconf_cleanup(void)
  4477. {
  4478. struct net_device *dev;
  4479. int i;
  4480. unregister_netdevice_notifier(&ipv6_dev_notf);
  4481. unregister_pernet_subsys(&addrconf_ops);
  4482. ipv6_addr_label_cleanup();
  4483. rtnl_lock();
  4484. __rtnl_af_unregister(&inet6_ops);
  4485. /* clean dev list */
  4486. for_each_netdev(&init_net, dev) {
  4487. if (__in6_dev_get(dev) == NULL)
  4488. continue;
  4489. addrconf_ifdown(dev, 1);
  4490. }
  4491. addrconf_ifdown(init_net.loopback_dev, 2);
  4492. /*
  4493. * Check hash table.
  4494. */
  4495. spin_lock_bh(&addrconf_hash_lock);
  4496. for (i = 0; i < IN6_ADDR_HSIZE; i++)
  4497. WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
  4498. spin_unlock_bh(&addrconf_hash_lock);
  4499. del_timer(&addr_chk_timer);
  4500. rtnl_unlock();
  4501. }