routerlist.c 202 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824
  1. /* Copyright (c) 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file routerlist.c
  8. * \brief Code to
  9. * maintain and access the global list of routerinfos for known
  10. * servers.
  11. *
  12. * A "routerinfo_t" object represents a single self-signed router
  13. * descriptor, as generated by a Tor relay in order to tell the rest of
  14. * the world about its keys, address, and capabilities. An
  15. * "extrainfo_t" object represents an adjunct "extra-info" object,
  16. * certified by a corresponding router descriptor, reporting more
  17. * information about the relay that nearly all users will not need.
  18. *
  19. * Most users will not use router descriptors for most relays. Instead,
  20. * they use the information in microdescriptors and in the consensus
  21. * networkstatus.
  22. *
  23. * Right now, routerinfo_t objects are used in these ways:
  24. * <ul>
  25. * <li>By clients, in order to learn about bridge keys and capabilities.
  26. * (Bridges aren't listed in the consensus networkstatus, so they
  27. * can't have microdescriptors.)
  28. * <li>By relays, since relays want more information about other relays
  29. * than they can learn from microdescriptors. (TODO: Is this still true?)
  30. * <li>By authorities, which receive them and use them to generate the
  31. * consensus and the microdescriptors.
  32. * <li>By all directory caches, which download them in case somebody
  33. * else wants them.
  34. * </ul>
  35. *
  36. * Routerinfos are mostly created by parsing them from a string, in
  37. * routerparse.c. We store them to disk on receiving them, and
  38. * periodically discard the ones we don't need. On restarting, we
  39. * re-read them from disk. (This also applies to extrainfo documents, if
  40. * we are configured to fetch them.)
  41. *
  42. * In order to keep our list of routerinfos up-to-date, we periodically
  43. * check whether there are any listed in the latest consensus (or in the
  44. * votes from other authorities, if we are an authority) that we don't
  45. * have. (This also applies to extrainfo documents, if we are
  46. * configured to fetch them.)
  47. *
  48. * Almost nothing in Tor should use a routerinfo_t to refer directly to
  49. * a relay; instead, almost everything should use node_t (implemented in
  50. * nodelist.c), which provides a common interface to routerinfo_t,
  51. * routerstatus_t, and microdescriptor_t.
  52. *
  53. * <br>
  54. *
  55. * This module also has some of the functions used for choosing random
  56. * nodes according to different rules and weights. Historically, they
  57. * were all in this module. Now, they are spread across this module,
  58. * nodelist.c, and networkstatus.c. (TODO: Fix that.)
  59. *
  60. * <br>
  61. *
  62. * (For historical reasons) this module also contains code for handling
  63. * the list of fallback directories, the list of directory authorities,
  64. * and the list of authority certificates.
  65. *
  66. * For the directory authorities, we have a list containing the public
  67. * identity key, and contact points, for each authority. The
  68. * authorities receive descriptors from relays, and publish consensuses,
  69. * descriptors, and microdescriptors. This list is pre-configured.
  70. *
  71. * Fallback directories are well-known, stable, but untrusted directory
  72. * caches that clients which have not yet bootstrapped can use to get
  73. * their first networkstatus consensus, in order to find out where the
  74. * Tor network really is. This list is pre-configured in
  75. * fallback_dirs.inc. Every authority also serves as a fallback.
  76. *
  77. * Both fallback directories and directory authorities are are
  78. * represented by a dir_server_t.
  79. *
  80. * Authority certificates are signed with authority identity keys; they
  81. * are used to authenticate shorter-term authority signing keys. We
  82. * fetch them when we find a consensus or a vote that has been signed
  83. * with a signing key we don't recognize. We cache them on disk and
  84. * load them on startup. Authority operators generate them with the
  85. * "tor-gencert" utility.
  86. *
  87. * TODO: Authority certificates should be a separate module.
  88. *
  89. * TODO: dir_server_t stuff should be in a separate module.
  90. **/
  91. #define ROUTERLIST_PRIVATE
  92. #include "or.h"
  93. #include "backtrace.h"
  94. #include "bridges.h"
  95. #include "crypto_ed25519.h"
  96. #include "circuitstats.h"
  97. #include "config.h"
  98. #include "connection.h"
  99. #include "control.h"
  100. #include "directory.h"
  101. #include "dirserv.h"
  102. #include "dirvote.h"
  103. #include "entrynodes.h"
  104. #include "fp_pair.h"
  105. #include "geoip.h"
  106. #include "hibernate.h"
  107. #include "main.h"
  108. #include "microdesc.h"
  109. #include "networkstatus.h"
  110. #include "nodelist.h"
  111. #include "policies.h"
  112. #include "reasons.h"
  113. #include "rendcommon.h"
  114. #include "rendservice.h"
  115. #include "rephist.h"
  116. #include "router.h"
  117. #include "routerlist.h"
  118. #include "routerparse.h"
  119. #include "routerset.h"
  120. #include "sandbox.h"
  121. #include "torcert.h"
  122. // #define DEBUG_ROUTERLIST
  123. /****************************************************************************/
  124. /* Typed wrappers for different digestmap types; used to avoid type
  125. * confusion. */
  126. DECLARE_TYPED_DIGESTMAP_FNS(sdmap_, digest_sd_map_t, signed_descriptor_t)
  127. DECLARE_TYPED_DIGESTMAP_FNS(rimap_, digest_ri_map_t, routerinfo_t)
  128. DECLARE_TYPED_DIGESTMAP_FNS(eimap_, digest_ei_map_t, extrainfo_t)
  129. DECLARE_TYPED_DIGESTMAP_FNS(dsmap_, digest_ds_map_t, download_status_t)
  130. #define SDMAP_FOREACH(map, keyvar, valvar) \
  131. DIGESTMAP_FOREACH(sdmap_to_digestmap(map), keyvar, signed_descriptor_t *, \
  132. valvar)
  133. #define RIMAP_FOREACH(map, keyvar, valvar) \
  134. DIGESTMAP_FOREACH(rimap_to_digestmap(map), keyvar, routerinfo_t *, valvar)
  135. #define EIMAP_FOREACH(map, keyvar, valvar) \
  136. DIGESTMAP_FOREACH(eimap_to_digestmap(map), keyvar, extrainfo_t *, valvar)
  137. #define DSMAP_FOREACH(map, keyvar, valvar) \
  138. DIGESTMAP_FOREACH(dsmap_to_digestmap(map), keyvar, download_status_t *, \
  139. valvar)
  140. #define eimap_free(map, fn) MAP_FREE_AND_NULL(eimap, (map), (fn))
  141. #define rimap_free(map, fn) MAP_FREE_AND_NULL(rimap, (map), (fn))
  142. #define dsmap_free(map, fn) MAP_FREE_AND_NULL(dsmap, (map), (fn))
  143. #define sdmap_free(map, fn) MAP_FREE_AND_NULL(sdmap, (map), (fn))
  144. /* Forward declaration for cert_list_t */
  145. typedef struct cert_list_t cert_list_t;
  146. /* static function prototypes */
  147. static int compute_weighted_bandwidths(const smartlist_t *sl,
  148. bandwidth_weight_rule_t rule,
  149. double **bandwidths_out,
  150. double *total_bandwidth_out);
  151. static const routerstatus_t *router_pick_trusteddirserver_impl(
  152. const smartlist_t *sourcelist, dirinfo_type_t auth,
  153. int flags, int *n_busy_out);
  154. static const routerstatus_t *router_pick_dirserver_generic(
  155. smartlist_t *sourcelist,
  156. dirinfo_type_t type, int flags);
  157. static void mark_all_dirservers_up(smartlist_t *server_list);
  158. static int signed_desc_digest_is_recognized(signed_descriptor_t *desc);
  159. static const char *signed_descriptor_get_body_impl(
  160. const signed_descriptor_t *desc,
  161. int with_annotations);
  162. static void list_pending_downloads(digestmap_t *result,
  163. digest256map_t *result256,
  164. int purpose, const char *prefix);
  165. static void list_pending_fpsk_downloads(fp_pair_map_t *result);
  166. static void launch_dummy_descriptor_download_as_needed(time_t now,
  167. const or_options_t *options);
  168. static void download_status_reset_by_sk_in_cl(cert_list_t *cl,
  169. const char *digest);
  170. static int download_status_is_ready_by_sk_in_cl(cert_list_t *cl,
  171. const char *digest,
  172. time_t now, int max_failures);
  173. /****************************************************************************/
  174. /** Global list of a dir_server_t object for each directory
  175. * authority. */
  176. static smartlist_t *trusted_dir_servers = NULL;
  177. /** Global list of dir_server_t objects for all directory authorities
  178. * and all fallback directory servers. */
  179. static smartlist_t *fallback_dir_servers = NULL;
  180. /** List of certificates for a single authority, and download status for
  181. * latest certificate.
  182. */
  183. struct cert_list_t {
  184. /*
  185. * The keys of download status map are cert->signing_key_digest for pending
  186. * downloads by (identity digest/signing key digest) pair; functions such
  187. * as authority_cert_get_by_digest() already assume these are unique.
  188. */
  189. struct digest_ds_map_t *dl_status_map;
  190. /* There is also a dlstatus for the download by identity key only */
  191. download_status_t dl_status_by_id;
  192. smartlist_t *certs;
  193. };
  194. /** Map from v3 identity key digest to cert_list_t. */
  195. static digestmap_t *trusted_dir_certs = NULL;
  196. /** True iff any key certificate in at least one member of
  197. * <b>trusted_dir_certs</b> has changed since we last flushed the
  198. * certificates to disk. */
  199. static int trusted_dir_servers_certs_changed = 0;
  200. /** Global list of all of the routers that we know about. */
  201. static routerlist_t *routerlist = NULL;
  202. /** List of strings for nicknames we've already warned about and that are
  203. * still unknown / unavailable. */
  204. static smartlist_t *warned_nicknames = NULL;
  205. /** The last time we tried to download any routerdesc, or 0 for "never". We
  206. * use this to rate-limit download attempts when the number of routerdescs to
  207. * download is low. */
  208. static time_t last_descriptor_download_attempted = 0;
  209. /** Return the number of directory authorities whose type matches some bit set
  210. * in <b>type</b> */
  211. int
  212. get_n_authorities(dirinfo_type_t type)
  213. {
  214. int n = 0;
  215. if (!trusted_dir_servers)
  216. return 0;
  217. SMARTLIST_FOREACH(trusted_dir_servers, dir_server_t *, ds,
  218. if (ds->type & type)
  219. ++n);
  220. return n;
  221. }
  222. /** Initialise schedule, want_authority, and increment on in the download
  223. * status dlstatus, then call download_status_reset() on it.
  224. * It is safe to call this function or download_status_reset() multiple times
  225. * on a new dlstatus. But it should *not* be called after a dlstatus has been
  226. * used to count download attempts or failures. */
  227. static void
  228. download_status_cert_init(download_status_t *dlstatus)
  229. {
  230. dlstatus->schedule = DL_SCHED_CONSENSUS;
  231. dlstatus->want_authority = DL_WANT_ANY_DIRSERVER;
  232. dlstatus->increment_on = DL_SCHED_INCREMENT_FAILURE;
  233. dlstatus->backoff = DL_SCHED_RANDOM_EXPONENTIAL;
  234. dlstatus->last_backoff_position = 0;
  235. dlstatus->last_delay_used = 0;
  236. /* Use the new schedule to set next_attempt_at */
  237. download_status_reset(dlstatus);
  238. }
  239. /** Reset the download status of a specified element in a dsmap */
  240. static void
  241. download_status_reset_by_sk_in_cl(cert_list_t *cl, const char *digest)
  242. {
  243. download_status_t *dlstatus = NULL;
  244. tor_assert(cl);
  245. tor_assert(digest);
  246. /* Make sure we have a dsmap */
  247. if (!(cl->dl_status_map)) {
  248. cl->dl_status_map = dsmap_new();
  249. }
  250. /* Look for a download_status_t in the map with this digest */
  251. dlstatus = dsmap_get(cl->dl_status_map, digest);
  252. /* Got one? */
  253. if (!dlstatus) {
  254. /* Insert before we reset */
  255. dlstatus = tor_malloc_zero(sizeof(*dlstatus));
  256. dsmap_set(cl->dl_status_map, digest, dlstatus);
  257. download_status_cert_init(dlstatus);
  258. }
  259. tor_assert(dlstatus);
  260. /* Go ahead and reset it */
  261. download_status_reset(dlstatus);
  262. }
  263. /**
  264. * Return true if the download for this signing key digest in cl is ready
  265. * to be re-attempted.
  266. */
  267. static int
  268. download_status_is_ready_by_sk_in_cl(cert_list_t *cl,
  269. const char *digest,
  270. time_t now, int max_failures)
  271. {
  272. int rv = 0;
  273. download_status_t *dlstatus = NULL;
  274. tor_assert(cl);
  275. tor_assert(digest);
  276. /* Make sure we have a dsmap */
  277. if (!(cl->dl_status_map)) {
  278. cl->dl_status_map = dsmap_new();
  279. }
  280. /* Look for a download_status_t in the map with this digest */
  281. dlstatus = dsmap_get(cl->dl_status_map, digest);
  282. /* Got one? */
  283. if (dlstatus) {
  284. /* Use download_status_is_ready() */
  285. rv = download_status_is_ready(dlstatus, now, max_failures);
  286. } else {
  287. /*
  288. * If we don't know anything about it, return 1, since we haven't
  289. * tried this one before. We need to create a new entry here,
  290. * too.
  291. */
  292. dlstatus = tor_malloc_zero(sizeof(*dlstatus));
  293. download_status_cert_init(dlstatus);
  294. dsmap_set(cl->dl_status_map, digest, dlstatus);
  295. rv = 1;
  296. }
  297. return rv;
  298. }
  299. /** Helper: Return the cert_list_t for an authority whose authority ID is
  300. * <b>id_digest</b>, allocating a new list if necessary. */
  301. static cert_list_t *
  302. get_cert_list(const char *id_digest)
  303. {
  304. cert_list_t *cl;
  305. if (!trusted_dir_certs)
  306. trusted_dir_certs = digestmap_new();
  307. cl = digestmap_get(trusted_dir_certs, id_digest);
  308. if (!cl) {
  309. cl = tor_malloc_zero(sizeof(cert_list_t));
  310. download_status_cert_init(&cl->dl_status_by_id);
  311. cl->certs = smartlist_new();
  312. cl->dl_status_map = dsmap_new();
  313. digestmap_set(trusted_dir_certs, id_digest, cl);
  314. }
  315. return cl;
  316. }
  317. /** Return a list of authority ID digests with potentially enumerable lists
  318. * of download_status_t objects; used by controller GETINFO queries.
  319. */
  320. MOCK_IMPL(smartlist_t *,
  321. list_authority_ids_with_downloads, (void))
  322. {
  323. smartlist_t *ids = smartlist_new();
  324. digestmap_iter_t *i;
  325. const char *digest;
  326. char *tmp;
  327. void *cl;
  328. if (trusted_dir_certs) {
  329. for (i = digestmap_iter_init(trusted_dir_certs);
  330. !(digestmap_iter_done(i));
  331. i = digestmap_iter_next(trusted_dir_certs, i)) {
  332. /*
  333. * We always have at least dl_status_by_id to query, so no need to
  334. * probe deeper than the existence of a cert_list_t.
  335. */
  336. digestmap_iter_get(i, &digest, &cl);
  337. tmp = tor_malloc(DIGEST_LEN);
  338. memcpy(tmp, digest, DIGEST_LEN);
  339. smartlist_add(ids, tmp);
  340. }
  341. }
  342. /* else definitely no downloads going since nothing even has a cert list */
  343. return ids;
  344. }
  345. /** Given an authority ID digest, return a pointer to the default download
  346. * status, or NULL if there is no such entry in trusted_dir_certs */
  347. MOCK_IMPL(download_status_t *,
  348. id_only_download_status_for_authority_id, (const char *digest))
  349. {
  350. download_status_t *dl = NULL;
  351. cert_list_t *cl;
  352. if (trusted_dir_certs) {
  353. cl = digestmap_get(trusted_dir_certs, digest);
  354. if (cl) {
  355. dl = &(cl->dl_status_by_id);
  356. }
  357. }
  358. return dl;
  359. }
  360. /** Given an authority ID digest, return a smartlist of signing key digests
  361. * for which download_status_t is potentially queryable, or NULL if no such
  362. * authority ID digest is known. */
  363. MOCK_IMPL(smartlist_t *,
  364. list_sk_digests_for_authority_id, (const char *digest))
  365. {
  366. smartlist_t *sks = NULL;
  367. cert_list_t *cl;
  368. dsmap_iter_t *i;
  369. const char *sk_digest;
  370. char *tmp;
  371. download_status_t *dl;
  372. if (trusted_dir_certs) {
  373. cl = digestmap_get(trusted_dir_certs, digest);
  374. if (cl) {
  375. sks = smartlist_new();
  376. if (cl->dl_status_map) {
  377. for (i = dsmap_iter_init(cl->dl_status_map);
  378. !(dsmap_iter_done(i));
  379. i = dsmap_iter_next(cl->dl_status_map, i)) {
  380. /* Pull the digest out and add it to the list */
  381. dsmap_iter_get(i, &sk_digest, &dl);
  382. tmp = tor_malloc(DIGEST_LEN);
  383. memcpy(tmp, sk_digest, DIGEST_LEN);
  384. smartlist_add(sks, tmp);
  385. }
  386. }
  387. }
  388. }
  389. return sks;
  390. }
  391. /** Given an authority ID digest and a signing key digest, return the
  392. * download_status_t or NULL if none exists. */
  393. MOCK_IMPL(download_status_t *,
  394. download_status_for_authority_id_and_sk,(const char *id_digest,
  395. const char *sk_digest))
  396. {
  397. download_status_t *dl = NULL;
  398. cert_list_t *cl = NULL;
  399. if (trusted_dir_certs) {
  400. cl = digestmap_get(trusted_dir_certs, id_digest);
  401. if (cl && cl->dl_status_map) {
  402. dl = dsmap_get(cl->dl_status_map, sk_digest);
  403. }
  404. }
  405. return dl;
  406. }
  407. #define cert_list_free(val) \
  408. FREE_AND_NULL(cert_list_t, cert_list_free_, (val))
  409. /** Release all space held by a cert_list_t */
  410. static void
  411. cert_list_free_(cert_list_t *cl)
  412. {
  413. if (!cl)
  414. return;
  415. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  416. authority_cert_free(cert));
  417. smartlist_free(cl->certs);
  418. dsmap_free(cl->dl_status_map, tor_free_);
  419. tor_free(cl);
  420. }
  421. /** Wrapper for cert_list_free so we can pass it to digestmap_free */
  422. static void
  423. cert_list_free_void(void *cl)
  424. {
  425. cert_list_free_(cl);
  426. }
  427. /** Reload the cached v3 key certificates from the cached-certs file in
  428. * the data directory. Return 0 on success, -1 on failure. */
  429. int
  430. trusted_dirs_reload_certs(void)
  431. {
  432. char *filename;
  433. char *contents;
  434. int r;
  435. filename = get_cachedir_fname("cached-certs");
  436. contents = read_file_to_str(filename, RFTS_IGNORE_MISSING, NULL);
  437. tor_free(filename);
  438. if (!contents)
  439. return 0;
  440. r = trusted_dirs_load_certs_from_string(
  441. contents,
  442. TRUSTED_DIRS_CERTS_SRC_FROM_STORE, 1, NULL);
  443. tor_free(contents);
  444. return r;
  445. }
  446. /** Helper: return true iff we already have loaded the exact cert
  447. * <b>cert</b>. */
  448. static inline int
  449. already_have_cert(authority_cert_t *cert)
  450. {
  451. cert_list_t *cl = get_cert_list(cert->cache_info.identity_digest);
  452. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, c,
  453. {
  454. if (tor_memeq(c->cache_info.signed_descriptor_digest,
  455. cert->cache_info.signed_descriptor_digest,
  456. DIGEST_LEN))
  457. return 1;
  458. });
  459. return 0;
  460. }
  461. /** Load a bunch of new key certificates from the string <b>contents</b>. If
  462. * <b>source</b> is TRUSTED_DIRS_CERTS_SRC_FROM_STORE, the certificates are
  463. * from the cache, and we don't need to flush them to disk. If we are a
  464. * dirauth loading our own cert, source is TRUSTED_DIRS_CERTS_SRC_SELF.
  465. * Otherwise, source is download type: TRUSTED_DIRS_CERTS_SRC_DL_BY_ID_DIGEST
  466. * or TRUSTED_DIRS_CERTS_SRC_DL_BY_ID_SK_DIGEST. If <b>flush</b> is true, we
  467. * need to flush any changed certificates to disk now. Return 0 on success,
  468. * -1 if any certs fail to parse.
  469. *
  470. * If source_dir is non-NULL, it's the identity digest for a directory that
  471. * we've just successfully retrieved certificates from, so try it first to
  472. * fetch any missing certificates.
  473. */
  474. int
  475. trusted_dirs_load_certs_from_string(const char *contents, int source,
  476. int flush, const char *source_dir)
  477. {
  478. dir_server_t *ds;
  479. const char *s, *eos;
  480. int failure_code = 0;
  481. int from_store = (source == TRUSTED_DIRS_CERTS_SRC_FROM_STORE);
  482. int added_trusted_cert = 0;
  483. for (s = contents; *s; s = eos) {
  484. authority_cert_t *cert = authority_cert_parse_from_string(s, &eos);
  485. cert_list_t *cl;
  486. if (!cert) {
  487. failure_code = -1;
  488. break;
  489. }
  490. ds = trusteddirserver_get_by_v3_auth_digest(
  491. cert->cache_info.identity_digest);
  492. log_debug(LD_DIR, "Parsed certificate for %s",
  493. ds ? ds->nickname : "unknown authority");
  494. if (already_have_cert(cert)) {
  495. /* we already have this one. continue. */
  496. log_info(LD_DIR, "Skipping %s certificate for %s that we "
  497. "already have.",
  498. from_store ? "cached" : "downloaded",
  499. ds ? ds->nickname : "an old or new authority");
  500. /*
  501. * A duplicate on download should be treated as a failure, so we call
  502. * authority_cert_dl_failed() to reset the download status to make sure
  503. * we can't try again. Since we've implemented the fp-sk mechanism
  504. * to download certs by signing key, this should be much rarer than it
  505. * was and is perhaps cause for concern.
  506. */
  507. if (!from_store) {
  508. if (authdir_mode(get_options())) {
  509. log_warn(LD_DIR,
  510. "Got a certificate for %s, but we already have it. "
  511. "Maybe they haven't updated it. Waiting for a while.",
  512. ds ? ds->nickname : "an old or new authority");
  513. } else {
  514. log_info(LD_DIR,
  515. "Got a certificate for %s, but we already have it. "
  516. "Maybe they haven't updated it. Waiting for a while.",
  517. ds ? ds->nickname : "an old or new authority");
  518. }
  519. /*
  520. * This is where we care about the source; authority_cert_dl_failed()
  521. * needs to know whether the download was by fp or (fp,sk) pair to
  522. * twiddle the right bit in the download map.
  523. */
  524. if (source == TRUSTED_DIRS_CERTS_SRC_DL_BY_ID_DIGEST) {
  525. authority_cert_dl_failed(cert->cache_info.identity_digest,
  526. NULL, 404);
  527. } else if (source == TRUSTED_DIRS_CERTS_SRC_DL_BY_ID_SK_DIGEST) {
  528. authority_cert_dl_failed(cert->cache_info.identity_digest,
  529. cert->signing_key_digest, 404);
  530. }
  531. }
  532. authority_cert_free(cert);
  533. continue;
  534. }
  535. if (ds) {
  536. added_trusted_cert = 1;
  537. log_info(LD_DIR, "Adding %s certificate for directory authority %s with "
  538. "signing key %s", from_store ? "cached" : "downloaded",
  539. ds->nickname, hex_str(cert->signing_key_digest,DIGEST_LEN));
  540. } else {
  541. int adding = we_want_to_fetch_unknown_auth_certs(get_options());
  542. log_info(LD_DIR, "%s %s certificate for unrecognized directory "
  543. "authority with signing key %s",
  544. adding ? "Adding" : "Not adding",
  545. from_store ? "cached" : "downloaded",
  546. hex_str(cert->signing_key_digest,DIGEST_LEN));
  547. if (!adding) {
  548. authority_cert_free(cert);
  549. continue;
  550. }
  551. }
  552. cl = get_cert_list(cert->cache_info.identity_digest);
  553. smartlist_add(cl->certs, cert);
  554. if (ds && cert->cache_info.published_on > ds->addr_current_at) {
  555. /* Check to see whether we should update our view of the authority's
  556. * address. */
  557. if (cert->addr && cert->dir_port &&
  558. (ds->addr != cert->addr ||
  559. ds->dir_port != cert->dir_port)) {
  560. char *a = tor_dup_ip(cert->addr);
  561. log_notice(LD_DIR, "Updating address for directory authority %s "
  562. "from %s:%d to %s:%d based on certificate.",
  563. ds->nickname, ds->address, (int)ds->dir_port,
  564. a, cert->dir_port);
  565. tor_free(a);
  566. ds->addr = cert->addr;
  567. ds->dir_port = cert->dir_port;
  568. }
  569. ds->addr_current_at = cert->cache_info.published_on;
  570. }
  571. if (!from_store)
  572. trusted_dir_servers_certs_changed = 1;
  573. }
  574. if (flush)
  575. trusted_dirs_flush_certs_to_disk();
  576. /* call this even if failure_code is <0, since some certs might have
  577. * succeeded, but only pass source_dir if there were no failures,
  578. * and at least one more authority certificate was added to the store.
  579. * This avoids retrying a directory that's serving bad or entirely duplicate
  580. * certificates. */
  581. if (failure_code == 0 && added_trusted_cert) {
  582. networkstatus_note_certs_arrived(source_dir);
  583. } else {
  584. networkstatus_note_certs_arrived(NULL);
  585. }
  586. return failure_code;
  587. }
  588. /** Save all v3 key certificates to the cached-certs file. */
  589. void
  590. trusted_dirs_flush_certs_to_disk(void)
  591. {
  592. char *filename;
  593. smartlist_t *chunks;
  594. if (!trusted_dir_servers_certs_changed || !trusted_dir_certs)
  595. return;
  596. chunks = smartlist_new();
  597. DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  598. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  599. {
  600. sized_chunk_t *c = tor_malloc(sizeof(sized_chunk_t));
  601. c->bytes = cert->cache_info.signed_descriptor_body;
  602. c->len = cert->cache_info.signed_descriptor_len;
  603. smartlist_add(chunks, c);
  604. });
  605. } DIGESTMAP_FOREACH_END;
  606. filename = get_cachedir_fname("cached-certs");
  607. if (write_chunks_to_file(filename, chunks, 0, 0)) {
  608. log_warn(LD_FS, "Error writing certificates to disk.");
  609. }
  610. tor_free(filename);
  611. SMARTLIST_FOREACH(chunks, sized_chunk_t *, c, tor_free(c));
  612. smartlist_free(chunks);
  613. trusted_dir_servers_certs_changed = 0;
  614. }
  615. static int
  616. compare_certs_by_pubdates(const void **_a, const void **_b)
  617. {
  618. const authority_cert_t *cert1 = *_a, *cert2=*_b;
  619. if (cert1->cache_info.published_on < cert2->cache_info.published_on)
  620. return -1;
  621. else if (cert1->cache_info.published_on > cert2->cache_info.published_on)
  622. return 1;
  623. else
  624. return 0;
  625. }
  626. /** Remove all expired v3 authority certificates that have been superseded for
  627. * more than 48 hours or, if not expired, that were published more than 7 days
  628. * before being superseded. (If the most recent cert was published more than 48
  629. * hours ago, then we aren't going to get any consensuses signed with older
  630. * keys.) */
  631. static void
  632. trusted_dirs_remove_old_certs(void)
  633. {
  634. time_t now = time(NULL);
  635. #define DEAD_CERT_LIFETIME (2*24*60*60)
  636. #define SUPERSEDED_CERT_LIFETIME (2*24*60*60)
  637. if (!trusted_dir_certs)
  638. return;
  639. DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  640. /* Sort the list from first-published to last-published */
  641. smartlist_sort(cl->certs, compare_certs_by_pubdates);
  642. SMARTLIST_FOREACH_BEGIN(cl->certs, authority_cert_t *, cert) {
  643. if (cert_sl_idx == smartlist_len(cl->certs) - 1) {
  644. /* This is the most recently published cert. Keep it. */
  645. continue;
  646. }
  647. authority_cert_t *next_cert = smartlist_get(cl->certs, cert_sl_idx+1);
  648. const time_t next_cert_published = next_cert->cache_info.published_on;
  649. if (next_cert_published > now) {
  650. /* All later certs are published in the future. Keep everything
  651. * we didn't discard. */
  652. break;
  653. }
  654. int should_remove = 0;
  655. if (cert->expires + DEAD_CERT_LIFETIME < now) {
  656. /* Certificate has been expired for at least DEAD_CERT_LIFETIME.
  657. * Remove it. */
  658. should_remove = 1;
  659. } else if (next_cert_published + SUPERSEDED_CERT_LIFETIME < now) {
  660. /* Certificate has been superseded for OLD_CERT_LIFETIME.
  661. * Remove it.
  662. */
  663. should_remove = 1;
  664. }
  665. if (should_remove) {
  666. SMARTLIST_DEL_CURRENT_KEEPORDER(cl->certs, cert);
  667. authority_cert_free(cert);
  668. trusted_dir_servers_certs_changed = 1;
  669. }
  670. } SMARTLIST_FOREACH_END(cert);
  671. } DIGESTMAP_FOREACH_END;
  672. #undef DEAD_CERT_LIFETIME
  673. #undef OLD_CERT_LIFETIME
  674. trusted_dirs_flush_certs_to_disk();
  675. }
  676. /** Return the newest v3 authority certificate whose v3 authority identity key
  677. * has digest <b>id_digest</b>. Return NULL if no such authority is known,
  678. * or it has no certificate. */
  679. authority_cert_t *
  680. authority_cert_get_newest_by_id(const char *id_digest)
  681. {
  682. cert_list_t *cl;
  683. authority_cert_t *best = NULL;
  684. if (!trusted_dir_certs ||
  685. !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  686. return NULL;
  687. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  688. {
  689. if (!best || cert->cache_info.published_on > best->cache_info.published_on)
  690. best = cert;
  691. });
  692. return best;
  693. }
  694. /** Return the newest v3 authority certificate whose directory signing key has
  695. * digest <b>sk_digest</b>. Return NULL if no such certificate is known.
  696. */
  697. authority_cert_t *
  698. authority_cert_get_by_sk_digest(const char *sk_digest)
  699. {
  700. authority_cert_t *c;
  701. if (!trusted_dir_certs)
  702. return NULL;
  703. if ((c = get_my_v3_authority_cert()) &&
  704. tor_memeq(c->signing_key_digest, sk_digest, DIGEST_LEN))
  705. return c;
  706. if ((c = get_my_v3_legacy_cert()) &&
  707. tor_memeq(c->signing_key_digest, sk_digest, DIGEST_LEN))
  708. return c;
  709. DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  710. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  711. {
  712. if (tor_memeq(cert->signing_key_digest, sk_digest, DIGEST_LEN))
  713. return cert;
  714. });
  715. } DIGESTMAP_FOREACH_END;
  716. return NULL;
  717. }
  718. /** Return the v3 authority certificate with signing key matching
  719. * <b>sk_digest</b>, for the authority with identity digest <b>id_digest</b>.
  720. * Return NULL if no such authority is known. */
  721. authority_cert_t *
  722. authority_cert_get_by_digests(const char *id_digest,
  723. const char *sk_digest)
  724. {
  725. cert_list_t *cl;
  726. if (!trusted_dir_certs ||
  727. !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  728. return NULL;
  729. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, cert,
  730. if (tor_memeq(cert->signing_key_digest, sk_digest, DIGEST_LEN))
  731. return cert; );
  732. return NULL;
  733. }
  734. /** Add every known authority_cert_t to <b>certs_out</b>. */
  735. void
  736. authority_cert_get_all(smartlist_t *certs_out)
  737. {
  738. tor_assert(certs_out);
  739. if (!trusted_dir_certs)
  740. return;
  741. DIGESTMAP_FOREACH(trusted_dir_certs, key, cert_list_t *, cl) {
  742. SMARTLIST_FOREACH(cl->certs, authority_cert_t *, c,
  743. smartlist_add(certs_out, c));
  744. } DIGESTMAP_FOREACH_END;
  745. }
  746. /** Called when an attempt to download a certificate with the authority with
  747. * ID <b>id_digest</b> and, if not NULL, signed with key signing_key_digest
  748. * fails with HTTP response code <b>status</b>: remember the failure, so we
  749. * don't try again immediately. */
  750. void
  751. authority_cert_dl_failed(const char *id_digest,
  752. const char *signing_key_digest, int status)
  753. {
  754. cert_list_t *cl;
  755. download_status_t *dlstatus = NULL;
  756. char id_digest_str[2*DIGEST_LEN+1];
  757. char sk_digest_str[2*DIGEST_LEN+1];
  758. if (!trusted_dir_certs ||
  759. !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  760. return;
  761. /*
  762. * Are we noting a failed download of the latest cert for the id digest,
  763. * or of a download by (id, signing key) digest pair?
  764. */
  765. if (!signing_key_digest) {
  766. /* Just by id digest */
  767. download_status_failed(&cl->dl_status_by_id, status);
  768. } else {
  769. /* Reset by (id, signing key) digest pair
  770. *
  771. * Look for a download_status_t in the map with this digest
  772. */
  773. dlstatus = dsmap_get(cl->dl_status_map, signing_key_digest);
  774. /* Got one? */
  775. if (dlstatus) {
  776. download_status_failed(dlstatus, status);
  777. } else {
  778. /*
  779. * Do this rather than hex_str(), since hex_str clobbers
  780. * old results and we call twice in the param list.
  781. */
  782. base16_encode(id_digest_str, sizeof(id_digest_str),
  783. id_digest, DIGEST_LEN);
  784. base16_encode(sk_digest_str, sizeof(sk_digest_str),
  785. signing_key_digest, DIGEST_LEN);
  786. log_warn(LD_BUG,
  787. "Got failure for cert fetch with (fp,sk) = (%s,%s), with "
  788. "status %d, but knew nothing about the download.",
  789. id_digest_str, sk_digest_str, status);
  790. }
  791. }
  792. }
  793. static const char *BAD_SIGNING_KEYS[] = {
  794. "09CD84F751FD6E955E0F8ADB497D5401470D697E", // Expires 2015-01-11 16:26:31
  795. "0E7E9C07F0969D0468AD741E172A6109DC289F3C", // Expires 2014-08-12 10:18:26
  796. "57B85409891D3FB32137F642FDEDF8B7F8CDFDCD", // Expires 2015-02-11 17:19:09
  797. "87326329007AF781F587AF5B594E540B2B6C7630", // Expires 2014-07-17 11:10:09
  798. "98CC82342DE8D298CF99D3F1A396475901E0D38E", // Expires 2014-11-10 13:18:56
  799. "9904B52336713A5ADCB13E4FB14DC919E0D45571", // Expires 2014-04-20 20:01:01
  800. "9DCD8E3F1DD1597E2AD476BBA28A1A89F3095227", // Expires 2015-01-16 03:52:30
  801. "A61682F34B9BB9694AC98491FE1ABBFE61923941", // Expires 2014-06-11 09:25:09
  802. "B59F6E99C575113650C99F1C425BA7B20A8C071D", // Expires 2014-07-31 13:22:10
  803. "D27178388FA75B96D37FA36E0B015227DDDBDA51", // Expires 2014-08-04 04:01:57
  804. NULL,
  805. };
  806. /** Return true iff <b>cert</b> authenticates some atuhority signing key
  807. * which, because of the old openssl heartbleed vulnerability, should
  808. * never be trusted. */
  809. int
  810. authority_cert_is_blacklisted(const authority_cert_t *cert)
  811. {
  812. char hex_digest[HEX_DIGEST_LEN+1];
  813. int i;
  814. base16_encode(hex_digest, sizeof(hex_digest),
  815. cert->signing_key_digest, sizeof(cert->signing_key_digest));
  816. for (i = 0; BAD_SIGNING_KEYS[i]; ++i) {
  817. if (!strcasecmp(hex_digest, BAD_SIGNING_KEYS[i])) {
  818. return 1;
  819. }
  820. }
  821. return 0;
  822. }
  823. /** Return true iff when we've been getting enough failures when trying to
  824. * download the certificate with ID digest <b>id_digest</b> that we're willing
  825. * to start bugging the user about it. */
  826. int
  827. authority_cert_dl_looks_uncertain(const char *id_digest)
  828. {
  829. #define N_AUTH_CERT_DL_FAILURES_TO_BUG_USER 2
  830. cert_list_t *cl;
  831. int n_failures;
  832. if (!trusted_dir_certs ||
  833. !(cl = digestmap_get(trusted_dir_certs, id_digest)))
  834. return 0;
  835. n_failures = download_status_get_n_failures(&cl->dl_status_by_id);
  836. return n_failures >= N_AUTH_CERT_DL_FAILURES_TO_BUG_USER;
  837. }
  838. /* Fetch the authority certificates specified in resource.
  839. * If we are a bridge client, and node is a configured bridge, fetch from node
  840. * using dir_hint as the fingerprint. Otherwise, if rs is not NULL, fetch from
  841. * rs. Otherwise, fetch from a random directory mirror. */
  842. static void
  843. authority_certs_fetch_resource_impl(const char *resource,
  844. const char *dir_hint,
  845. const node_t *node,
  846. const routerstatus_t *rs)
  847. {
  848. const or_options_t *options = get_options();
  849. int get_via_tor = purpose_needs_anonymity(DIR_PURPOSE_FETCH_CERTIFICATE, 0,
  850. resource);
  851. /* Make sure bridge clients never connect to anything but a bridge */
  852. if (options->UseBridges) {
  853. if (node && !node_is_a_configured_bridge(node)) {
  854. /* If we're using bridges, and node is not a bridge, use a 3-hop path. */
  855. get_via_tor = 1;
  856. } else if (!node) {
  857. /* If we're using bridges, and there's no node, use a 3-hop path. */
  858. get_via_tor = 1;
  859. }
  860. }
  861. const dir_indirection_t indirection = get_via_tor ? DIRIND_ANONYMOUS
  862. : DIRIND_ONEHOP;
  863. directory_request_t *req = NULL;
  864. /* If we've just downloaded a consensus from a bridge, re-use that
  865. * bridge */
  866. if (options->UseBridges && node && node->ri && !get_via_tor) {
  867. /* clients always make OR connections to bridges */
  868. tor_addr_port_t or_ap;
  869. /* we are willing to use a non-preferred address if we need to */
  870. fascist_firewall_choose_address_node(node, FIREWALL_OR_CONNECTION, 0,
  871. &or_ap);
  872. req = directory_request_new(DIR_PURPOSE_FETCH_CERTIFICATE);
  873. directory_request_set_or_addr_port(req, &or_ap);
  874. if (dir_hint)
  875. directory_request_set_directory_id_digest(req, dir_hint);
  876. } else if (rs) {
  877. /* And if we've just downloaded a consensus from a directory, re-use that
  878. * directory */
  879. req = directory_request_new(DIR_PURPOSE_FETCH_CERTIFICATE);
  880. directory_request_set_routerstatus(req, rs);
  881. }
  882. if (req) {
  883. /* We've set up a request object -- fill in the other request fields, and
  884. * send the request. */
  885. directory_request_set_indirection(req, indirection);
  886. directory_request_set_resource(req, resource);
  887. directory_initiate_request(req);
  888. directory_request_free(req);
  889. return;
  890. }
  891. /* Otherwise, we want certs from a random fallback or directory
  892. * mirror, because they will almost always succeed. */
  893. directory_get_from_dirserver(DIR_PURPOSE_FETCH_CERTIFICATE, 0,
  894. resource, PDS_RETRY_IF_NO_SERVERS,
  895. DL_WANT_ANY_DIRSERVER);
  896. }
  897. /** Try to download any v3 authority certificates that we may be missing. If
  898. * <b>status</b> is provided, try to get all the ones that were used to sign
  899. * <b>status</b>. Additionally, try to have a non-expired certificate for
  900. * every V3 authority in trusted_dir_servers. Don't fetch certificates we
  901. * already have.
  902. *
  903. * If dir_hint is non-NULL, it's the identity digest for a directory that
  904. * we've just successfully retrieved a consensus or certificates from, so try
  905. * it first to fetch any missing certificates.
  906. **/
  907. void
  908. authority_certs_fetch_missing(networkstatus_t *status, time_t now,
  909. const char *dir_hint)
  910. {
  911. /*
  912. * The pending_id digestmap tracks pending certificate downloads by
  913. * identity digest; the pending_cert digestmap tracks pending downloads
  914. * by (identity digest, signing key digest) pairs.
  915. */
  916. digestmap_t *pending_id;
  917. fp_pair_map_t *pending_cert;
  918. /*
  919. * The missing_id_digests smartlist will hold a list of id digests
  920. * we want to fetch the newest cert for; the missing_cert_digests
  921. * smartlist will hold a list of fp_pair_t with an identity and
  922. * signing key digest.
  923. */
  924. smartlist_t *missing_cert_digests, *missing_id_digests;
  925. char *resource = NULL;
  926. cert_list_t *cl;
  927. const or_options_t *options = get_options();
  928. const int keep_unknown = we_want_to_fetch_unknown_auth_certs(options);
  929. fp_pair_t *fp_tmp = NULL;
  930. char id_digest_str[2*DIGEST_LEN+1];
  931. char sk_digest_str[2*DIGEST_LEN+1];
  932. if (should_delay_dir_fetches(options, NULL))
  933. return;
  934. pending_cert = fp_pair_map_new();
  935. pending_id = digestmap_new();
  936. missing_cert_digests = smartlist_new();
  937. missing_id_digests = smartlist_new();
  938. /*
  939. * First, we get the lists of already pending downloads so we don't
  940. * duplicate effort.
  941. */
  942. list_pending_downloads(pending_id, NULL,
  943. DIR_PURPOSE_FETCH_CERTIFICATE, "fp/");
  944. list_pending_fpsk_downloads(pending_cert);
  945. /*
  946. * Now, we download any trusted authority certs we don't have by
  947. * identity digest only. This gets the latest cert for that authority.
  948. */
  949. SMARTLIST_FOREACH_BEGIN(trusted_dir_servers, dir_server_t *, ds) {
  950. int found = 0;
  951. if (!(ds->type & V3_DIRINFO))
  952. continue;
  953. if (smartlist_contains_digest(missing_id_digests,
  954. ds->v3_identity_digest))
  955. continue;
  956. cl = get_cert_list(ds->v3_identity_digest);
  957. SMARTLIST_FOREACH_BEGIN(cl->certs, authority_cert_t *, cert) {
  958. if (now < cert->expires) {
  959. /* It's not expired, and we weren't looking for something to
  960. * verify a consensus with. Call it done. */
  961. download_status_reset(&(cl->dl_status_by_id));
  962. /* No sense trying to download it specifically by signing key hash */
  963. download_status_reset_by_sk_in_cl(cl, cert->signing_key_digest);
  964. found = 1;
  965. break;
  966. }
  967. } SMARTLIST_FOREACH_END(cert);
  968. if (!found &&
  969. download_status_is_ready(&(cl->dl_status_by_id), now,
  970. options->TestingCertMaxDownloadTries) &&
  971. !digestmap_get(pending_id, ds->v3_identity_digest)) {
  972. log_info(LD_DIR,
  973. "No current certificate known for authority %s "
  974. "(ID digest %s); launching request.",
  975. ds->nickname, hex_str(ds->v3_identity_digest, DIGEST_LEN));
  976. smartlist_add(missing_id_digests, ds->v3_identity_digest);
  977. }
  978. } SMARTLIST_FOREACH_END(ds);
  979. /*
  980. * Next, if we have a consensus, scan through it and look for anything
  981. * signed with a key from a cert we don't have. Those get downloaded
  982. * by (fp,sk) pair, but if we don't know any certs at all for the fp
  983. * (identity digest), and it's one of the trusted dir server certs
  984. * we started off above or a pending download in pending_id, don't
  985. * try to get it yet. Most likely, the one we'll get for that will
  986. * have the right signing key too, and we'd just be downloading
  987. * redundantly.
  988. */
  989. if (status) {
  990. SMARTLIST_FOREACH_BEGIN(status->voters, networkstatus_voter_info_t *,
  991. voter) {
  992. if (!smartlist_len(voter->sigs))
  993. continue; /* This authority never signed this consensus, so don't
  994. * go looking for a cert with key digest 0000000000. */
  995. if (!keep_unknown &&
  996. !trusteddirserver_get_by_v3_auth_digest(voter->identity_digest))
  997. continue; /* We don't want unknown certs, and we don't know this
  998. * authority.*/
  999. /*
  1000. * If we don't know *any* cert for this authority, and a download by ID
  1001. * is pending or we added it to missing_id_digests above, skip this
  1002. * one for now to avoid duplicate downloads.
  1003. */
  1004. cl = get_cert_list(voter->identity_digest);
  1005. if (smartlist_len(cl->certs) == 0) {
  1006. /* We have no certs at all for this one */
  1007. /* Do we have a download of one pending? */
  1008. if (digestmap_get(pending_id, voter->identity_digest))
  1009. continue;
  1010. /*
  1011. * Are we about to launch a download of one due to the trusted
  1012. * dir server check above?
  1013. */
  1014. if (smartlist_contains_digest(missing_id_digests,
  1015. voter->identity_digest))
  1016. continue;
  1017. }
  1018. SMARTLIST_FOREACH_BEGIN(voter->sigs, document_signature_t *, sig) {
  1019. authority_cert_t *cert =
  1020. authority_cert_get_by_digests(voter->identity_digest,
  1021. sig->signing_key_digest);
  1022. if (cert) {
  1023. if (now < cert->expires)
  1024. download_status_reset_by_sk_in_cl(cl, sig->signing_key_digest);
  1025. continue;
  1026. }
  1027. if (download_status_is_ready_by_sk_in_cl(
  1028. cl, sig->signing_key_digest,
  1029. now, options->TestingCertMaxDownloadTries) &&
  1030. !fp_pair_map_get_by_digests(pending_cert,
  1031. voter->identity_digest,
  1032. sig->signing_key_digest)) {
  1033. /*
  1034. * Do this rather than hex_str(), since hex_str clobbers
  1035. * old results and we call twice in the param list.
  1036. */
  1037. base16_encode(id_digest_str, sizeof(id_digest_str),
  1038. voter->identity_digest, DIGEST_LEN);
  1039. base16_encode(sk_digest_str, sizeof(sk_digest_str),
  1040. sig->signing_key_digest, DIGEST_LEN);
  1041. if (voter->nickname) {
  1042. log_info(LD_DIR,
  1043. "We're missing a certificate from authority %s "
  1044. "(ID digest %s) with signing key %s: "
  1045. "launching request.",
  1046. voter->nickname, id_digest_str, sk_digest_str);
  1047. } else {
  1048. log_info(LD_DIR,
  1049. "We're missing a certificate from authority ID digest "
  1050. "%s with signing key %s: launching request.",
  1051. id_digest_str, sk_digest_str);
  1052. }
  1053. /* Allocate a new fp_pair_t to append */
  1054. fp_tmp = tor_malloc(sizeof(*fp_tmp));
  1055. memcpy(fp_tmp->first, voter->identity_digest, sizeof(fp_tmp->first));
  1056. memcpy(fp_tmp->second, sig->signing_key_digest,
  1057. sizeof(fp_tmp->second));
  1058. smartlist_add(missing_cert_digests, fp_tmp);
  1059. }
  1060. } SMARTLIST_FOREACH_END(sig);
  1061. } SMARTLIST_FOREACH_END(voter);
  1062. }
  1063. /* Bridge clients look up the node for the dir_hint */
  1064. const node_t *node = NULL;
  1065. /* All clients, including bridge clients, look up the routerstatus for the
  1066. * dir_hint */
  1067. const routerstatus_t *rs = NULL;
  1068. /* If we still need certificates, try the directory that just successfully
  1069. * served us a consensus or certificates.
  1070. * As soon as the directory fails to provide additional certificates, we try
  1071. * another, randomly selected directory. This avoids continual retries.
  1072. * (We only ever have one outstanding request per certificate.)
  1073. */
  1074. if (dir_hint) {
  1075. if (options->UseBridges) {
  1076. /* Bridge clients try the nodelist. If the dir_hint is from an authority,
  1077. * or something else fetched over tor, we won't find the node here, but
  1078. * we will find the rs. */
  1079. node = node_get_by_id(dir_hint);
  1080. }
  1081. /* All clients try the consensus routerstatus, then the fallback
  1082. * routerstatus */
  1083. rs = router_get_consensus_status_by_id(dir_hint);
  1084. if (!rs) {
  1085. /* This will also find authorities */
  1086. const dir_server_t *ds = router_get_fallback_dirserver_by_digest(
  1087. dir_hint);
  1088. if (ds) {
  1089. rs = &ds->fake_status;
  1090. }
  1091. }
  1092. if (!node && !rs) {
  1093. log_warn(LD_BUG, "Directory %s delivered a consensus, but %s"
  1094. "no routerstatus could be found for it.",
  1095. options->UseBridges ? "no node and " : "",
  1096. hex_str(dir_hint, DIGEST_LEN));
  1097. }
  1098. }
  1099. /* Do downloads by identity digest */
  1100. if (smartlist_len(missing_id_digests) > 0) {
  1101. int need_plus = 0;
  1102. smartlist_t *fps = smartlist_new();
  1103. smartlist_add_strdup(fps, "fp/");
  1104. SMARTLIST_FOREACH_BEGIN(missing_id_digests, const char *, d) {
  1105. char *fp = NULL;
  1106. if (digestmap_get(pending_id, d))
  1107. continue;
  1108. base16_encode(id_digest_str, sizeof(id_digest_str),
  1109. d, DIGEST_LEN);
  1110. if (need_plus) {
  1111. tor_asprintf(&fp, "+%s", id_digest_str);
  1112. } else {
  1113. /* No need for tor_asprintf() in this case; first one gets no '+' */
  1114. fp = tor_strdup(id_digest_str);
  1115. need_plus = 1;
  1116. }
  1117. smartlist_add(fps, fp);
  1118. } SMARTLIST_FOREACH_END(d);
  1119. if (smartlist_len(fps) > 1) {
  1120. resource = smartlist_join_strings(fps, "", 0, NULL);
  1121. /* node and rs are directories that just gave us a consensus or
  1122. * certificates */
  1123. authority_certs_fetch_resource_impl(resource, dir_hint, node, rs);
  1124. tor_free(resource);
  1125. }
  1126. /* else we didn't add any: they were all pending */
  1127. SMARTLIST_FOREACH(fps, char *, cp, tor_free(cp));
  1128. smartlist_free(fps);
  1129. }
  1130. /* Do downloads by identity digest/signing key pair */
  1131. if (smartlist_len(missing_cert_digests) > 0) {
  1132. int need_plus = 0;
  1133. smartlist_t *fp_pairs = smartlist_new();
  1134. smartlist_add_strdup(fp_pairs, "fp-sk/");
  1135. SMARTLIST_FOREACH_BEGIN(missing_cert_digests, const fp_pair_t *, d) {
  1136. char *fp_pair = NULL;
  1137. if (fp_pair_map_get(pending_cert, d))
  1138. continue;
  1139. /* Construct string encodings of the digests */
  1140. base16_encode(id_digest_str, sizeof(id_digest_str),
  1141. d->first, DIGEST_LEN);
  1142. base16_encode(sk_digest_str, sizeof(sk_digest_str),
  1143. d->second, DIGEST_LEN);
  1144. /* Now tor_asprintf() */
  1145. if (need_plus) {
  1146. tor_asprintf(&fp_pair, "+%s-%s", id_digest_str, sk_digest_str);
  1147. } else {
  1148. /* First one in the list doesn't get a '+' */
  1149. tor_asprintf(&fp_pair, "%s-%s", id_digest_str, sk_digest_str);
  1150. need_plus = 1;
  1151. }
  1152. /* Add it to the list of pairs to request */
  1153. smartlist_add(fp_pairs, fp_pair);
  1154. } SMARTLIST_FOREACH_END(d);
  1155. if (smartlist_len(fp_pairs) > 1) {
  1156. resource = smartlist_join_strings(fp_pairs, "", 0, NULL);
  1157. /* node and rs are directories that just gave us a consensus or
  1158. * certificates */
  1159. authority_certs_fetch_resource_impl(resource, dir_hint, node, rs);
  1160. tor_free(resource);
  1161. }
  1162. /* else they were all pending */
  1163. SMARTLIST_FOREACH(fp_pairs, char *, p, tor_free(p));
  1164. smartlist_free(fp_pairs);
  1165. }
  1166. smartlist_free(missing_id_digests);
  1167. SMARTLIST_FOREACH(missing_cert_digests, fp_pair_t *, p, tor_free(p));
  1168. smartlist_free(missing_cert_digests);
  1169. digestmap_free(pending_id, NULL);
  1170. fp_pair_map_free(pending_cert, NULL);
  1171. }
  1172. /* Router descriptor storage.
  1173. *
  1174. * Routerdescs are stored in a big file, named "cached-descriptors". As new
  1175. * routerdescs arrive, we append them to a journal file named
  1176. * "cached-descriptors.new".
  1177. *
  1178. * From time to time, we replace "cached-descriptors" with a new file
  1179. * containing only the live, non-superseded descriptors, and clear
  1180. * cached-routers.new.
  1181. *
  1182. * On startup, we read both files.
  1183. */
  1184. /** Helper: return 1 iff the router log is so big we want to rebuild the
  1185. * store. */
  1186. static int
  1187. router_should_rebuild_store(desc_store_t *store)
  1188. {
  1189. if (store->store_len > (1<<16))
  1190. return (store->journal_len > store->store_len / 2 ||
  1191. store->bytes_dropped > store->store_len / 2);
  1192. else
  1193. return store->journal_len > (1<<15);
  1194. }
  1195. /** Return the desc_store_t in <b>rl</b> that should be used to store
  1196. * <b>sd</b>. */
  1197. static inline desc_store_t *
  1198. desc_get_store(routerlist_t *rl, const signed_descriptor_t *sd)
  1199. {
  1200. if (sd->is_extrainfo)
  1201. return &rl->extrainfo_store;
  1202. else
  1203. return &rl->desc_store;
  1204. }
  1205. /** Add the signed_descriptor_t in <b>desc</b> to the router
  1206. * journal; change its saved_location to SAVED_IN_JOURNAL and set its
  1207. * offset appropriately. */
  1208. static int
  1209. signed_desc_append_to_journal(signed_descriptor_t *desc,
  1210. desc_store_t *store)
  1211. {
  1212. char *fname = get_cachedir_fname_suffix(store->fname_base, ".new");
  1213. const char *body = signed_descriptor_get_body_impl(desc,1);
  1214. size_t len = desc->signed_descriptor_len + desc->annotations_len;
  1215. if (append_bytes_to_file(fname, body, len, 1)) {
  1216. log_warn(LD_FS, "Unable to store router descriptor");
  1217. tor_free(fname);
  1218. return -1;
  1219. }
  1220. desc->saved_location = SAVED_IN_JOURNAL;
  1221. tor_free(fname);
  1222. desc->saved_offset = store->journal_len;
  1223. store->journal_len += len;
  1224. return 0;
  1225. }
  1226. /** Sorting helper: return &lt;0, 0, or &gt;0 depending on whether the
  1227. * signed_descriptor_t* in *<b>a</b> is older, the same age as, or newer than
  1228. * the signed_descriptor_t* in *<b>b</b>. */
  1229. static int
  1230. compare_signed_descriptors_by_age_(const void **_a, const void **_b)
  1231. {
  1232. const signed_descriptor_t *r1 = *_a, *r2 = *_b;
  1233. return (int)(r1->published_on - r2->published_on);
  1234. }
  1235. #define RRS_FORCE 1
  1236. #define RRS_DONT_REMOVE_OLD 2
  1237. /** If the journal of <b>store</b> is too long, or if RRS_FORCE is set in
  1238. * <b>flags</b>, then atomically replace the saved router store with the
  1239. * routers currently in our routerlist, and clear the journal. Unless
  1240. * RRS_DONT_REMOVE_OLD is set in <b>flags</b>, delete expired routers before
  1241. * rebuilding the store. Return 0 on success, -1 on failure.
  1242. */
  1243. static int
  1244. router_rebuild_store(int flags, desc_store_t *store)
  1245. {
  1246. smartlist_t *chunk_list = NULL;
  1247. char *fname = NULL, *fname_tmp = NULL;
  1248. int r = -1;
  1249. off_t offset = 0;
  1250. smartlist_t *signed_descriptors = NULL;
  1251. int nocache=0;
  1252. size_t total_expected_len = 0;
  1253. int had_any;
  1254. int force = flags & RRS_FORCE;
  1255. if (!force && !router_should_rebuild_store(store)) {
  1256. r = 0;
  1257. goto done;
  1258. }
  1259. if (!routerlist) {
  1260. r = 0;
  1261. goto done;
  1262. }
  1263. if (store->type == EXTRAINFO_STORE)
  1264. had_any = !eimap_isempty(routerlist->extra_info_map);
  1265. else
  1266. had_any = (smartlist_len(routerlist->routers)+
  1267. smartlist_len(routerlist->old_routers))>0;
  1268. /* Don't save deadweight. */
  1269. if (!(flags & RRS_DONT_REMOVE_OLD))
  1270. routerlist_remove_old_routers();
  1271. log_info(LD_DIR, "Rebuilding %s cache", store->description);
  1272. fname = get_cachedir_fname(store->fname_base);
  1273. fname_tmp = get_cachedir_fname_suffix(store->fname_base, ".tmp");
  1274. chunk_list = smartlist_new();
  1275. /* We sort the routers by age to enhance locality on disk. */
  1276. signed_descriptors = smartlist_new();
  1277. if (store->type == EXTRAINFO_STORE) {
  1278. eimap_iter_t *iter;
  1279. for (iter = eimap_iter_init(routerlist->extra_info_map);
  1280. !eimap_iter_done(iter);
  1281. iter = eimap_iter_next(routerlist->extra_info_map, iter)) {
  1282. const char *key;
  1283. extrainfo_t *ei;
  1284. eimap_iter_get(iter, &key, &ei);
  1285. smartlist_add(signed_descriptors, &ei->cache_info);
  1286. }
  1287. } else {
  1288. SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd,
  1289. smartlist_add(signed_descriptors, sd));
  1290. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,
  1291. smartlist_add(signed_descriptors, &ri->cache_info));
  1292. }
  1293. smartlist_sort(signed_descriptors, compare_signed_descriptors_by_age_);
  1294. /* Now, add the appropriate members to chunk_list */
  1295. SMARTLIST_FOREACH_BEGIN(signed_descriptors, signed_descriptor_t *, sd) {
  1296. sized_chunk_t *c;
  1297. const char *body = signed_descriptor_get_body_impl(sd, 1);
  1298. if (!body) {
  1299. log_warn(LD_BUG, "No descriptor available for router.");
  1300. goto done;
  1301. }
  1302. if (sd->do_not_cache) {
  1303. ++nocache;
  1304. continue;
  1305. }
  1306. c = tor_malloc(sizeof(sized_chunk_t));
  1307. c->bytes = body;
  1308. c->len = sd->signed_descriptor_len + sd->annotations_len;
  1309. total_expected_len += c->len;
  1310. smartlist_add(chunk_list, c);
  1311. } SMARTLIST_FOREACH_END(sd);
  1312. if (write_chunks_to_file(fname_tmp, chunk_list, 1, 1)<0) {
  1313. log_warn(LD_FS, "Error writing router store to disk.");
  1314. goto done;
  1315. }
  1316. /* Our mmap is now invalid. */
  1317. if (store->mmap) {
  1318. int res = tor_munmap_file(store->mmap);
  1319. store->mmap = NULL;
  1320. if (res != 0) {
  1321. log_warn(LD_FS, "Unable to munmap route store in %s", fname);
  1322. }
  1323. }
  1324. if (replace_file(fname_tmp, fname)<0) {
  1325. log_warn(LD_FS, "Error replacing old router store: %s", strerror(errno));
  1326. goto done;
  1327. }
  1328. errno = 0;
  1329. store->mmap = tor_mmap_file(fname);
  1330. if (! store->mmap) {
  1331. if (errno == ERANGE) {
  1332. /* empty store.*/
  1333. if (total_expected_len) {
  1334. log_warn(LD_FS, "We wrote some bytes to a new descriptor file at '%s',"
  1335. " but when we went to mmap it, it was empty!", fname);
  1336. } else if (had_any) {
  1337. log_info(LD_FS, "We just removed every descriptor in '%s'. This is "
  1338. "okay if we're just starting up after a long time. "
  1339. "Otherwise, it's a bug.", fname);
  1340. }
  1341. } else {
  1342. log_warn(LD_FS, "Unable to mmap new descriptor file at '%s'.",fname);
  1343. }
  1344. }
  1345. log_info(LD_DIR, "Reconstructing pointers into cache");
  1346. offset = 0;
  1347. SMARTLIST_FOREACH_BEGIN(signed_descriptors, signed_descriptor_t *, sd) {
  1348. if (sd->do_not_cache)
  1349. continue;
  1350. sd->saved_location = SAVED_IN_CACHE;
  1351. if (store->mmap) {
  1352. tor_free(sd->signed_descriptor_body); // sets it to null
  1353. sd->saved_offset = offset;
  1354. }
  1355. offset += sd->signed_descriptor_len + sd->annotations_len;
  1356. signed_descriptor_get_body(sd); /* reconstruct and assert */
  1357. } SMARTLIST_FOREACH_END(sd);
  1358. tor_free(fname);
  1359. fname = get_cachedir_fname_suffix(store->fname_base, ".new");
  1360. write_str_to_file(fname, "", 1);
  1361. r = 0;
  1362. store->store_len = (size_t) offset;
  1363. store->journal_len = 0;
  1364. store->bytes_dropped = 0;
  1365. done:
  1366. smartlist_free(signed_descriptors);
  1367. tor_free(fname);
  1368. tor_free(fname_tmp);
  1369. if (chunk_list) {
  1370. SMARTLIST_FOREACH(chunk_list, sized_chunk_t *, c, tor_free(c));
  1371. smartlist_free(chunk_list);
  1372. }
  1373. return r;
  1374. }
  1375. /** Helper: Reload a cache file and its associated journal, setting metadata
  1376. * appropriately. If <b>extrainfo</b> is true, reload the extrainfo store;
  1377. * else reload the router descriptor store. */
  1378. static int
  1379. router_reload_router_list_impl(desc_store_t *store)
  1380. {
  1381. char *fname = NULL, *contents = NULL;
  1382. struct stat st;
  1383. int extrainfo = (store->type == EXTRAINFO_STORE);
  1384. store->journal_len = store->store_len = 0;
  1385. fname = get_cachedir_fname(store->fname_base);
  1386. if (store->mmap) {
  1387. /* get rid of it first */
  1388. int res = tor_munmap_file(store->mmap);
  1389. store->mmap = NULL;
  1390. if (res != 0) {
  1391. log_warn(LD_FS, "Failed to munmap %s", fname);
  1392. tor_free(fname);
  1393. return -1;
  1394. }
  1395. }
  1396. store->mmap = tor_mmap_file(fname);
  1397. if (store->mmap) {
  1398. store->store_len = store->mmap->size;
  1399. if (extrainfo)
  1400. router_load_extrainfo_from_string(store->mmap->data,
  1401. store->mmap->data+store->mmap->size,
  1402. SAVED_IN_CACHE, NULL, 0);
  1403. else
  1404. router_load_routers_from_string(store->mmap->data,
  1405. store->mmap->data+store->mmap->size,
  1406. SAVED_IN_CACHE, NULL, 0, NULL);
  1407. }
  1408. tor_free(fname);
  1409. fname = get_cachedir_fname_suffix(store->fname_base, ".new");
  1410. /* don't load empty files - we wouldn't get any data, even if we tried */
  1411. if (file_status(fname) == FN_FILE)
  1412. contents = read_file_to_str(fname, RFTS_BIN|RFTS_IGNORE_MISSING, &st);
  1413. if (contents) {
  1414. if (extrainfo)
  1415. router_load_extrainfo_from_string(contents, NULL,SAVED_IN_JOURNAL,
  1416. NULL, 0);
  1417. else
  1418. router_load_routers_from_string(contents, NULL, SAVED_IN_JOURNAL,
  1419. NULL, 0, NULL);
  1420. store->journal_len = (size_t) st.st_size;
  1421. tor_free(contents);
  1422. }
  1423. tor_free(fname);
  1424. if (store->journal_len) {
  1425. /* Always clear the journal on startup.*/
  1426. router_rebuild_store(RRS_FORCE, store);
  1427. } else if (!extrainfo) {
  1428. /* Don't cache expired routers. (This is in an else because
  1429. * router_rebuild_store() also calls remove_old_routers().) */
  1430. routerlist_remove_old_routers();
  1431. }
  1432. return 0;
  1433. }
  1434. /** Load all cached router descriptors and extra-info documents from the
  1435. * store. Return 0 on success and -1 on failure.
  1436. */
  1437. int
  1438. router_reload_router_list(void)
  1439. {
  1440. routerlist_t *rl = router_get_routerlist();
  1441. if (router_reload_router_list_impl(&rl->desc_store))
  1442. return -1;
  1443. if (router_reload_router_list_impl(&rl->extrainfo_store))
  1444. return -1;
  1445. return 0;
  1446. }
  1447. /** Return a smartlist containing a list of dir_server_t * for all
  1448. * known trusted dirservers. Callers must not modify the list or its
  1449. * contents.
  1450. */
  1451. const smartlist_t *
  1452. router_get_trusted_dir_servers(void)
  1453. {
  1454. if (!trusted_dir_servers)
  1455. trusted_dir_servers = smartlist_new();
  1456. return trusted_dir_servers;
  1457. }
  1458. const smartlist_t *
  1459. router_get_fallback_dir_servers(void)
  1460. {
  1461. if (!fallback_dir_servers)
  1462. fallback_dir_servers = smartlist_new();
  1463. return fallback_dir_servers;
  1464. }
  1465. /** Try to find a running dirserver that supports operations of <b>type</b>.
  1466. *
  1467. * If there are no running dirservers in our routerlist and the
  1468. * <b>PDS_RETRY_IF_NO_SERVERS</b> flag is set, set all the fallback ones
  1469. * (including authorities) as running again, and pick one.
  1470. *
  1471. * If the <b>PDS_IGNORE_FASCISTFIREWALL</b> flag is set, then include
  1472. * dirservers that we can't reach.
  1473. *
  1474. * If the <b>PDS_ALLOW_SELF</b> flag is not set, then don't include ourself
  1475. * (if we're a dirserver).
  1476. *
  1477. * Don't pick a fallback directory mirror if any non-fallback is viable;
  1478. * (the fallback directory mirrors include the authorities)
  1479. * try to avoid using servers that have returned 503 recently.
  1480. */
  1481. const routerstatus_t *
  1482. router_pick_directory_server(dirinfo_type_t type, int flags)
  1483. {
  1484. int busy = 0;
  1485. const routerstatus_t *choice;
  1486. if (!routerlist)
  1487. return NULL;
  1488. choice = router_pick_directory_server_impl(type, flags, &busy);
  1489. if (choice || !(flags & PDS_RETRY_IF_NO_SERVERS))
  1490. return choice;
  1491. if (busy) {
  1492. /* If the reason that we got no server is that servers are "busy",
  1493. * we must be excluding good servers because we already have serverdesc
  1494. * fetches with them. Do not mark down servers up because of this. */
  1495. tor_assert((flags & (PDS_NO_EXISTING_SERVERDESC_FETCH|
  1496. PDS_NO_EXISTING_MICRODESC_FETCH)));
  1497. return NULL;
  1498. }
  1499. log_info(LD_DIR,
  1500. "No reachable router entries for dirservers. "
  1501. "Trying them all again.");
  1502. /* mark all fallback directory mirrors as up again */
  1503. mark_all_dirservers_up(fallback_dir_servers);
  1504. /* try again */
  1505. choice = router_pick_directory_server_impl(type, flags, NULL);
  1506. return choice;
  1507. }
  1508. /** Return the dir_server_t for the directory authority whose identity
  1509. * key hashes to <b>digest</b>, or NULL if no such authority is known.
  1510. */
  1511. dir_server_t *
  1512. router_get_trusteddirserver_by_digest(const char *digest)
  1513. {
  1514. if (!trusted_dir_servers)
  1515. return NULL;
  1516. SMARTLIST_FOREACH(trusted_dir_servers, dir_server_t *, ds,
  1517. {
  1518. if (tor_memeq(ds->digest, digest, DIGEST_LEN))
  1519. return ds;
  1520. });
  1521. return NULL;
  1522. }
  1523. /** Return the dir_server_t for the fallback dirserver whose identity
  1524. * key hashes to <b>digest</b>, or NULL if no such fallback is in the list of
  1525. * fallback_dir_servers. (fallback_dir_servers is affected by the FallbackDir
  1526. * and UseDefaultFallbackDirs torrc options.)
  1527. * The list of fallback directories includes the list of authorities.
  1528. */
  1529. dir_server_t *
  1530. router_get_fallback_dirserver_by_digest(const char *digest)
  1531. {
  1532. if (!fallback_dir_servers)
  1533. return NULL;
  1534. if (!digest)
  1535. return NULL;
  1536. SMARTLIST_FOREACH(fallback_dir_servers, dir_server_t *, ds,
  1537. {
  1538. if (tor_memeq(ds->digest, digest, DIGEST_LEN))
  1539. return ds;
  1540. });
  1541. return NULL;
  1542. }
  1543. /** Return 1 if any fallback dirserver's identity key hashes to <b>digest</b>,
  1544. * or 0 if no such fallback is in the list of fallback_dir_servers.
  1545. * (fallback_dir_servers is affected by the FallbackDir and
  1546. * UseDefaultFallbackDirs torrc options.)
  1547. * The list of fallback directories includes the list of authorities.
  1548. */
  1549. int
  1550. router_digest_is_fallback_dir(const char *digest)
  1551. {
  1552. return (router_get_fallback_dirserver_by_digest(digest) != NULL);
  1553. }
  1554. /** Return the dir_server_t for the directory authority whose
  1555. * v3 identity key hashes to <b>digest</b>, or NULL if no such authority
  1556. * is known.
  1557. */
  1558. MOCK_IMPL(dir_server_t *,
  1559. trusteddirserver_get_by_v3_auth_digest, (const char *digest))
  1560. {
  1561. if (!trusted_dir_servers)
  1562. return NULL;
  1563. SMARTLIST_FOREACH(trusted_dir_servers, dir_server_t *, ds,
  1564. {
  1565. if (tor_memeq(ds->v3_identity_digest, digest, DIGEST_LEN) &&
  1566. (ds->type & V3_DIRINFO))
  1567. return ds;
  1568. });
  1569. return NULL;
  1570. }
  1571. /** Try to find a running directory authority. Flags are as for
  1572. * router_pick_directory_server.
  1573. */
  1574. const routerstatus_t *
  1575. router_pick_trusteddirserver(dirinfo_type_t type, int flags)
  1576. {
  1577. return router_pick_dirserver_generic(trusted_dir_servers, type, flags);
  1578. }
  1579. /** Try to find a running fallback directory. Flags are as for
  1580. * router_pick_directory_server.
  1581. */
  1582. const routerstatus_t *
  1583. router_pick_fallback_dirserver(dirinfo_type_t type, int flags)
  1584. {
  1585. return router_pick_dirserver_generic(fallback_dir_servers, type, flags);
  1586. }
  1587. /** Try to find a running fallback directory. Flags are as for
  1588. * router_pick_directory_server.
  1589. */
  1590. static const routerstatus_t *
  1591. router_pick_dirserver_generic(smartlist_t *sourcelist,
  1592. dirinfo_type_t type, int flags)
  1593. {
  1594. const routerstatus_t *choice;
  1595. int busy = 0;
  1596. choice = router_pick_trusteddirserver_impl(sourcelist, type, flags, &busy);
  1597. if (choice || !(flags & PDS_RETRY_IF_NO_SERVERS))
  1598. return choice;
  1599. if (busy) {
  1600. /* If the reason that we got no server is that servers are "busy",
  1601. * we must be excluding good servers because we already have serverdesc
  1602. * fetches with them. Do not mark down servers up because of this. */
  1603. tor_assert((flags & (PDS_NO_EXISTING_SERVERDESC_FETCH|
  1604. PDS_NO_EXISTING_MICRODESC_FETCH)));
  1605. return NULL;
  1606. }
  1607. log_info(LD_DIR,
  1608. "No dirservers are reachable. Trying them all again.");
  1609. mark_all_dirservers_up(sourcelist);
  1610. return router_pick_trusteddirserver_impl(sourcelist, type, flags, NULL);
  1611. }
  1612. /* Check if we already have a directory fetch from ap, for serverdesc
  1613. * (including extrainfo) or microdesc documents.
  1614. * If so, return 1, if not, return 0.
  1615. * Also returns 0 if addr is NULL, tor_addr_is_null(addr), or dir_port is 0.
  1616. */
  1617. STATIC int
  1618. router_is_already_dir_fetching(const tor_addr_port_t *ap, int serverdesc,
  1619. int microdesc)
  1620. {
  1621. if (!ap || tor_addr_is_null(&ap->addr) || !ap->port) {
  1622. return 0;
  1623. }
  1624. /* XX/teor - we're not checking tunnel connections here, see #17848
  1625. */
  1626. if (serverdesc && (
  1627. connection_get_by_type_addr_port_purpose(
  1628. CONN_TYPE_DIR, &ap->addr, ap->port, DIR_PURPOSE_FETCH_SERVERDESC)
  1629. || connection_get_by_type_addr_port_purpose(
  1630. CONN_TYPE_DIR, &ap->addr, ap->port, DIR_PURPOSE_FETCH_EXTRAINFO))) {
  1631. return 1;
  1632. }
  1633. if (microdesc && (
  1634. connection_get_by_type_addr_port_purpose(
  1635. CONN_TYPE_DIR, &ap->addr, ap->port, DIR_PURPOSE_FETCH_MICRODESC))) {
  1636. return 1;
  1637. }
  1638. return 0;
  1639. }
  1640. /* Check if we already have a directory fetch from the ipv4 or ipv6
  1641. * router, for serverdesc (including extrainfo) or microdesc documents.
  1642. * If so, return 1, if not, return 0.
  1643. */
  1644. static int
  1645. router_is_already_dir_fetching_(uint32_t ipv4_addr,
  1646. const tor_addr_t *ipv6_addr,
  1647. uint16_t dir_port,
  1648. int serverdesc,
  1649. int microdesc)
  1650. {
  1651. tor_addr_port_t ipv4_dir_ap, ipv6_dir_ap;
  1652. /* Assume IPv6 DirPort is the same as IPv4 DirPort */
  1653. tor_addr_from_ipv4h(&ipv4_dir_ap.addr, ipv4_addr);
  1654. ipv4_dir_ap.port = dir_port;
  1655. tor_addr_copy(&ipv6_dir_ap.addr, ipv6_addr);
  1656. ipv6_dir_ap.port = dir_port;
  1657. return (router_is_already_dir_fetching(&ipv4_dir_ap, serverdesc, microdesc)
  1658. || router_is_already_dir_fetching(&ipv6_dir_ap, serverdesc, microdesc));
  1659. }
  1660. #ifndef LOG_FALSE_POSITIVES_DURING_BOOTSTRAP
  1661. #define LOG_FALSE_POSITIVES_DURING_BOOTSTRAP 0
  1662. #endif
  1663. /* Log a message if rs is not found or not a preferred address */
  1664. static void
  1665. router_picked_poor_directory_log(const routerstatus_t *rs)
  1666. {
  1667. const networkstatus_t *usable_consensus;
  1668. usable_consensus = networkstatus_get_reasonably_live_consensus(time(NULL),
  1669. usable_consensus_flavor());
  1670. #if !LOG_FALSE_POSITIVES_DURING_BOOTSTRAP
  1671. /* Don't log early in the bootstrap process, it's normal to pick from a
  1672. * small pool of nodes. Of course, this won't help if we're trying to
  1673. * diagnose bootstrap issues. */
  1674. if (!smartlist_len(nodelist_get_list()) || !usable_consensus
  1675. || !router_have_minimum_dir_info()) {
  1676. return;
  1677. }
  1678. #endif /* !LOG_FALSE_POSITIVES_DURING_BOOTSTRAP */
  1679. /* We couldn't find a node, or the one we have doesn't fit our preferences.
  1680. * Sometimes this is normal, sometimes it can be a reachability issue. */
  1681. if (!rs) {
  1682. /* This happens a lot, so it's at debug level */
  1683. log_debug(LD_DIR, "Wanted to make an outgoing directory connection, but "
  1684. "we couldn't find a directory that fit our criteria. "
  1685. "Perhaps we will succeed next time with less strict criteria.");
  1686. } else if (!fascist_firewall_allows_rs(rs, FIREWALL_OR_CONNECTION, 1)
  1687. && !fascist_firewall_allows_rs(rs, FIREWALL_DIR_CONNECTION, 1)
  1688. ) {
  1689. /* This is rare, and might be interesting to users trying to diagnose
  1690. * connection issues on dual-stack machines. */
  1691. log_info(LD_DIR, "Selected a directory %s with non-preferred OR and Dir "
  1692. "addresses for launching an outgoing connection: "
  1693. "IPv4 %s OR %d Dir %d IPv6 %s OR %d Dir %d",
  1694. routerstatus_describe(rs),
  1695. fmt_addr32(rs->addr), rs->or_port,
  1696. rs->dir_port, fmt_addr(&rs->ipv6_addr),
  1697. rs->ipv6_orport, rs->dir_port);
  1698. }
  1699. }
  1700. #undef LOG_FALSE_POSITIVES_DURING_BOOTSTRAP
  1701. /** How long do we avoid using a directory server after it's given us a 503? */
  1702. #define DIR_503_TIMEOUT (60*60)
  1703. /* Common retry code for router_pick_directory_server_impl and
  1704. * router_pick_trusteddirserver_impl. Retry with the non-preferred IP version.
  1705. * Must be called before RETRY_WITHOUT_EXCLUDE().
  1706. *
  1707. * If we got no result, and we are applying IP preferences, and we are a
  1708. * client that could use an alternate IP version, try again with the
  1709. * opposite preferences. */
  1710. #define RETRY_ALTERNATE_IP_VERSION(retry_label) \
  1711. STMT_BEGIN \
  1712. if (result == NULL && try_ip_pref && options->ClientUseIPv4 \
  1713. && fascist_firewall_use_ipv6(options) && !server_mode(options) \
  1714. && !n_busy) { \
  1715. n_excluded = 0; \
  1716. n_busy = 0; \
  1717. try_ip_pref = 0; \
  1718. goto retry_label; \
  1719. } \
  1720. STMT_END \
  1721. /* Common retry code for router_pick_directory_server_impl and
  1722. * router_pick_trusteddirserver_impl. Retry without excluding nodes, but with
  1723. * the preferred IP version. Must be called after RETRY_ALTERNATE_IP_VERSION().
  1724. *
  1725. * If we got no result, and we are excluding nodes, and StrictNodes is
  1726. * not set, try again without excluding nodes. */
  1727. #define RETRY_WITHOUT_EXCLUDE(retry_label) \
  1728. STMT_BEGIN \
  1729. if (result == NULL && try_excluding && !options->StrictNodes \
  1730. && n_excluded && !n_busy) { \
  1731. try_excluding = 0; \
  1732. n_excluded = 0; \
  1733. n_busy = 0; \
  1734. try_ip_pref = 1; \
  1735. goto retry_label; \
  1736. } \
  1737. STMT_END
  1738. /* Common code used in the loop within router_pick_directory_server_impl and
  1739. * router_pick_trusteddirserver_impl.
  1740. *
  1741. * Check if the given <b>identity</b> supports extrainfo. If not, skip further
  1742. * checks.
  1743. */
  1744. #define SKIP_MISSING_TRUSTED_EXTRAINFO(type, identity) \
  1745. STMT_BEGIN \
  1746. int is_trusted_extrainfo = router_digest_is_trusted_dir_type( \
  1747. (identity), EXTRAINFO_DIRINFO); \
  1748. if (((type) & EXTRAINFO_DIRINFO) && \
  1749. !router_supports_extrainfo((identity), is_trusted_extrainfo)) \
  1750. continue; \
  1751. STMT_END
  1752. /* When iterating through the routerlist, can OR address/port preference
  1753. * and reachability checks be skipped?
  1754. */
  1755. int
  1756. router_skip_or_reachability(const or_options_t *options, int try_ip_pref)
  1757. {
  1758. /* Servers always have and prefer IPv4.
  1759. * And if clients are checking against the firewall for reachability only,
  1760. * but there's no firewall, don't bother checking */
  1761. return server_mode(options) || (!try_ip_pref && !firewall_is_fascist_or());
  1762. }
  1763. /* When iterating through the routerlist, can Dir address/port preference
  1764. * and reachability checks be skipped?
  1765. */
  1766. static int
  1767. router_skip_dir_reachability(const or_options_t *options, int try_ip_pref)
  1768. {
  1769. /* Servers always have and prefer IPv4.
  1770. * And if clients are checking against the firewall for reachability only,
  1771. * but there's no firewall, don't bother checking */
  1772. return server_mode(options) || (!try_ip_pref && !firewall_is_fascist_dir());
  1773. }
  1774. /** Pick a random running valid directory server/mirror from our
  1775. * routerlist. Arguments are as for router_pick_directory_server(), except:
  1776. *
  1777. * If <b>n_busy_out</b> is provided, set *<b>n_busy_out</b> to the number of
  1778. * directories that we excluded for no other reason than
  1779. * PDS_NO_EXISTING_SERVERDESC_FETCH or PDS_NO_EXISTING_MICRODESC_FETCH.
  1780. */
  1781. STATIC const routerstatus_t *
  1782. router_pick_directory_server_impl(dirinfo_type_t type, int flags,
  1783. int *n_busy_out)
  1784. {
  1785. const or_options_t *options = get_options();
  1786. const node_t *result;
  1787. smartlist_t *direct, *tunnel;
  1788. smartlist_t *trusted_direct, *trusted_tunnel;
  1789. smartlist_t *overloaded_direct, *overloaded_tunnel;
  1790. time_t now = time(NULL);
  1791. const networkstatus_t *consensus = networkstatus_get_latest_consensus();
  1792. const int requireother = ! (flags & PDS_ALLOW_SELF);
  1793. const int fascistfirewall = ! (flags & PDS_IGNORE_FASCISTFIREWALL);
  1794. const int no_serverdesc_fetching =(flags & PDS_NO_EXISTING_SERVERDESC_FETCH);
  1795. const int no_microdesc_fetching = (flags & PDS_NO_EXISTING_MICRODESC_FETCH);
  1796. int try_excluding = 1, n_excluded = 0, n_busy = 0;
  1797. int try_ip_pref = 1;
  1798. if (!consensus)
  1799. return NULL;
  1800. retry_search:
  1801. direct = smartlist_new();
  1802. tunnel = smartlist_new();
  1803. trusted_direct = smartlist_new();
  1804. trusted_tunnel = smartlist_new();
  1805. overloaded_direct = smartlist_new();
  1806. overloaded_tunnel = smartlist_new();
  1807. const int skip_or_fw = router_skip_or_reachability(options, try_ip_pref);
  1808. const int skip_dir_fw = router_skip_dir_reachability(options, try_ip_pref);
  1809. const int must_have_or = directory_must_use_begindir(options);
  1810. /* Find all the running dirservers we know about. */
  1811. SMARTLIST_FOREACH_BEGIN(nodelist_get_list(), const node_t *, node) {
  1812. int is_trusted;
  1813. int is_overloaded;
  1814. const routerstatus_t *status = node->rs;
  1815. const country_t country = node->country;
  1816. if (!status)
  1817. continue;
  1818. if (!node->is_running || !node_is_dir(node) || !node->is_valid)
  1819. continue;
  1820. if (requireother && router_digest_is_me(node->identity))
  1821. continue;
  1822. SKIP_MISSING_TRUSTED_EXTRAINFO(type, node->identity);
  1823. if (try_excluding &&
  1824. routerset_contains_routerstatus(options->ExcludeNodes, status,
  1825. country)) {
  1826. ++n_excluded;
  1827. continue;
  1828. }
  1829. if (router_is_already_dir_fetching_(status->addr,
  1830. &status->ipv6_addr,
  1831. status->dir_port,
  1832. no_serverdesc_fetching,
  1833. no_microdesc_fetching)) {
  1834. ++n_busy;
  1835. continue;
  1836. }
  1837. is_overloaded = status->last_dir_503_at + DIR_503_TIMEOUT > now;
  1838. is_trusted = router_digest_is_trusted_dir(node->identity);
  1839. /* Clients use IPv6 addresses if the server has one and the client
  1840. * prefers IPv6.
  1841. * Add the router if its preferred address and port are reachable.
  1842. * If we don't get any routers, we'll try again with the non-preferred
  1843. * address for each router (if any). (To ensure correct load-balancing
  1844. * we try routers that only have one address both times.)
  1845. */
  1846. if (!fascistfirewall || skip_or_fw ||
  1847. fascist_firewall_allows_node(node, FIREWALL_OR_CONNECTION,
  1848. try_ip_pref))
  1849. smartlist_add(is_trusted ? trusted_tunnel :
  1850. is_overloaded ? overloaded_tunnel : tunnel, (void*)node);
  1851. else if (!must_have_or && (skip_dir_fw ||
  1852. fascist_firewall_allows_node(node, FIREWALL_DIR_CONNECTION,
  1853. try_ip_pref)))
  1854. smartlist_add(is_trusted ? trusted_direct :
  1855. is_overloaded ? overloaded_direct : direct, (void*)node);
  1856. } SMARTLIST_FOREACH_END(node);
  1857. if (smartlist_len(tunnel)) {
  1858. result = node_sl_choose_by_bandwidth(tunnel, WEIGHT_FOR_DIR);
  1859. } else if (smartlist_len(overloaded_tunnel)) {
  1860. result = node_sl_choose_by_bandwidth(overloaded_tunnel,
  1861. WEIGHT_FOR_DIR);
  1862. } else if (smartlist_len(trusted_tunnel)) {
  1863. /* FFFF We don't distinguish between trusteds and overloaded trusteds
  1864. * yet. Maybe one day we should. */
  1865. /* FFFF We also don't load balance over authorities yet. I think this
  1866. * is a feature, but it could easily be a bug. -RD */
  1867. result = smartlist_choose(trusted_tunnel);
  1868. } else if (smartlist_len(direct)) {
  1869. result = node_sl_choose_by_bandwidth(direct, WEIGHT_FOR_DIR);
  1870. } else if (smartlist_len(overloaded_direct)) {
  1871. result = node_sl_choose_by_bandwidth(overloaded_direct,
  1872. WEIGHT_FOR_DIR);
  1873. } else {
  1874. result = smartlist_choose(trusted_direct);
  1875. }
  1876. smartlist_free(direct);
  1877. smartlist_free(tunnel);
  1878. smartlist_free(trusted_direct);
  1879. smartlist_free(trusted_tunnel);
  1880. smartlist_free(overloaded_direct);
  1881. smartlist_free(overloaded_tunnel);
  1882. RETRY_ALTERNATE_IP_VERSION(retry_search);
  1883. RETRY_WITHOUT_EXCLUDE(retry_search);
  1884. if (n_busy_out)
  1885. *n_busy_out = n_busy;
  1886. router_picked_poor_directory_log(result ? result->rs : NULL);
  1887. return result ? result->rs : NULL;
  1888. }
  1889. /** Pick a random element from a list of dir_server_t, weighting by their
  1890. * <b>weight</b> field. */
  1891. static const dir_server_t *
  1892. dirserver_choose_by_weight(const smartlist_t *servers, double authority_weight)
  1893. {
  1894. int n = smartlist_len(servers);
  1895. int i;
  1896. double *weights_dbl;
  1897. uint64_t *weights_u64;
  1898. const dir_server_t *ds;
  1899. weights_dbl = tor_calloc(n, sizeof(double));
  1900. weights_u64 = tor_calloc(n, sizeof(uint64_t));
  1901. for (i = 0; i < n; ++i) {
  1902. ds = smartlist_get(servers, i);
  1903. weights_dbl[i] = ds->weight;
  1904. if (ds->is_authority)
  1905. weights_dbl[i] *= authority_weight;
  1906. }
  1907. scale_array_elements_to_u64(weights_u64, weights_dbl, n, NULL);
  1908. i = choose_array_element_by_weight(weights_u64, n);
  1909. tor_free(weights_dbl);
  1910. tor_free(weights_u64);
  1911. return (i < 0) ? NULL : smartlist_get(servers, i);
  1912. }
  1913. /** Choose randomly from among the dir_server_ts in sourcelist that
  1914. * are up. Flags are as for router_pick_directory_server_impl().
  1915. */
  1916. static const routerstatus_t *
  1917. router_pick_trusteddirserver_impl(const smartlist_t *sourcelist,
  1918. dirinfo_type_t type, int flags,
  1919. int *n_busy_out)
  1920. {
  1921. const or_options_t *options = get_options();
  1922. smartlist_t *direct, *tunnel;
  1923. smartlist_t *overloaded_direct, *overloaded_tunnel;
  1924. const routerinfo_t *me = router_get_my_routerinfo();
  1925. const routerstatus_t *result = NULL;
  1926. time_t now = time(NULL);
  1927. const int requireother = ! (flags & PDS_ALLOW_SELF);
  1928. const int fascistfirewall = ! (flags & PDS_IGNORE_FASCISTFIREWALL);
  1929. const int no_serverdesc_fetching =(flags & PDS_NO_EXISTING_SERVERDESC_FETCH);
  1930. const int no_microdesc_fetching =(flags & PDS_NO_EXISTING_MICRODESC_FETCH);
  1931. const double auth_weight = (sourcelist == fallback_dir_servers) ?
  1932. options->DirAuthorityFallbackRate : 1.0;
  1933. smartlist_t *pick_from;
  1934. int n_busy = 0;
  1935. int try_excluding = 1, n_excluded = 0;
  1936. int try_ip_pref = 1;
  1937. if (!sourcelist)
  1938. return NULL;
  1939. retry_search:
  1940. direct = smartlist_new();
  1941. tunnel = smartlist_new();
  1942. overloaded_direct = smartlist_new();
  1943. overloaded_tunnel = smartlist_new();
  1944. const int skip_or_fw = router_skip_or_reachability(options, try_ip_pref);
  1945. const int skip_dir_fw = router_skip_dir_reachability(options, try_ip_pref);
  1946. const int must_have_or = directory_must_use_begindir(options);
  1947. SMARTLIST_FOREACH_BEGIN(sourcelist, const dir_server_t *, d)
  1948. {
  1949. int is_overloaded =
  1950. d->fake_status.last_dir_503_at + DIR_503_TIMEOUT > now;
  1951. if (!d->is_running) continue;
  1952. if ((type & d->type) == 0)
  1953. continue;
  1954. SKIP_MISSING_TRUSTED_EXTRAINFO(type, d->digest);
  1955. if (requireother && me && router_digest_is_me(d->digest))
  1956. continue;
  1957. if (try_excluding &&
  1958. routerset_contains_routerstatus(options->ExcludeNodes,
  1959. &d->fake_status, -1)) {
  1960. ++n_excluded;
  1961. continue;
  1962. }
  1963. if (router_is_already_dir_fetching_(d->addr,
  1964. &d->ipv6_addr,
  1965. d->dir_port,
  1966. no_serverdesc_fetching,
  1967. no_microdesc_fetching)) {
  1968. ++n_busy;
  1969. continue;
  1970. }
  1971. /* Clients use IPv6 addresses if the server has one and the client
  1972. * prefers IPv6.
  1973. * Add the router if its preferred address and port are reachable.
  1974. * If we don't get any routers, we'll try again with the non-preferred
  1975. * address for each router (if any). (To ensure correct load-balancing
  1976. * we try routers that only have one address both times.)
  1977. */
  1978. if (!fascistfirewall || skip_or_fw ||
  1979. fascist_firewall_allows_dir_server(d, FIREWALL_OR_CONNECTION,
  1980. try_ip_pref))
  1981. smartlist_add(is_overloaded ? overloaded_tunnel : tunnel, (void*)d);
  1982. else if (!must_have_or && (skip_dir_fw ||
  1983. fascist_firewall_allows_dir_server(d, FIREWALL_DIR_CONNECTION,
  1984. try_ip_pref)))
  1985. smartlist_add(is_overloaded ? overloaded_direct : direct, (void*)d);
  1986. }
  1987. SMARTLIST_FOREACH_END(d);
  1988. if (smartlist_len(tunnel)) {
  1989. pick_from = tunnel;
  1990. } else if (smartlist_len(overloaded_tunnel)) {
  1991. pick_from = overloaded_tunnel;
  1992. } else if (smartlist_len(direct)) {
  1993. pick_from = direct;
  1994. } else {
  1995. pick_from = overloaded_direct;
  1996. }
  1997. {
  1998. const dir_server_t *selection =
  1999. dirserver_choose_by_weight(pick_from, auth_weight);
  2000. if (selection)
  2001. result = &selection->fake_status;
  2002. }
  2003. smartlist_free(direct);
  2004. smartlist_free(tunnel);
  2005. smartlist_free(overloaded_direct);
  2006. smartlist_free(overloaded_tunnel);
  2007. RETRY_ALTERNATE_IP_VERSION(retry_search);
  2008. RETRY_WITHOUT_EXCLUDE(retry_search);
  2009. router_picked_poor_directory_log(result);
  2010. if (n_busy_out)
  2011. *n_busy_out = n_busy;
  2012. return result;
  2013. }
  2014. /** Mark as running every dir_server_t in <b>server_list</b>. */
  2015. static void
  2016. mark_all_dirservers_up(smartlist_t *server_list)
  2017. {
  2018. if (server_list) {
  2019. SMARTLIST_FOREACH_BEGIN(server_list, dir_server_t *, dir) {
  2020. routerstatus_t *rs;
  2021. node_t *node;
  2022. dir->is_running = 1;
  2023. node = node_get_mutable_by_id(dir->digest);
  2024. if (node)
  2025. node->is_running = 1;
  2026. rs = router_get_mutable_consensus_status_by_id(dir->digest);
  2027. if (rs) {
  2028. rs->last_dir_503_at = 0;
  2029. control_event_networkstatus_changed_single(rs);
  2030. }
  2031. } SMARTLIST_FOREACH_END(dir);
  2032. }
  2033. router_dir_info_changed();
  2034. }
  2035. /** Return true iff r1 and r2 have the same address and OR port. */
  2036. int
  2037. routers_have_same_or_addrs(const routerinfo_t *r1, const routerinfo_t *r2)
  2038. {
  2039. return r1->addr == r2->addr && r1->or_port == r2->or_port &&
  2040. tor_addr_eq(&r1->ipv6_addr, &r2->ipv6_addr) &&
  2041. r1->ipv6_orport == r2->ipv6_orport;
  2042. }
  2043. /** Reset all internal variables used to count failed downloads of network
  2044. * status objects. */
  2045. void
  2046. router_reset_status_download_failures(void)
  2047. {
  2048. mark_all_dirservers_up(fallback_dir_servers);
  2049. }
  2050. /** Given a <b>router</b>, add every node_t in its family (including the
  2051. * node itself!) to <b>sl</b>.
  2052. *
  2053. * Note the type mismatch: This function takes a routerinfo, but adds nodes
  2054. * to the smartlist!
  2055. */
  2056. static void
  2057. routerlist_add_node_and_family(smartlist_t *sl, const routerinfo_t *router)
  2058. {
  2059. /* XXXX MOVE ? */
  2060. node_t fake_node;
  2061. const node_t *node = node_get_by_id(router->cache_info.identity_digest);
  2062. if (node == NULL) {
  2063. memset(&fake_node, 0, sizeof(fake_node));
  2064. fake_node.ri = (routerinfo_t *)router;
  2065. memcpy(fake_node.identity, router->cache_info.identity_digest, DIGEST_LEN);
  2066. node = &fake_node;
  2067. }
  2068. nodelist_add_node_and_family(sl, node);
  2069. }
  2070. /** Add every suitable node from our nodelist to <b>sl</b>, so that
  2071. * we can pick a node for a circuit.
  2072. */
  2073. void
  2074. router_add_running_nodes_to_smartlist(smartlist_t *sl, int need_uptime,
  2075. int need_capacity, int need_guard,
  2076. int need_desc, int pref_addr,
  2077. int direct_conn)
  2078. {
  2079. const int check_reach = !router_skip_or_reachability(get_options(),
  2080. pref_addr);
  2081. /* XXXX MOVE */
  2082. SMARTLIST_FOREACH_BEGIN(nodelist_get_list(), const node_t *, node) {
  2083. if (!node->is_running || !node->is_valid)
  2084. continue;
  2085. if (need_desc && !(node->ri || (node->rs && node->md)))
  2086. continue;
  2087. if (node->ri && node->ri->purpose != ROUTER_PURPOSE_GENERAL)
  2088. continue;
  2089. if (node_is_unreliable(node, need_uptime, need_capacity, need_guard))
  2090. continue;
  2091. /* Don't choose nodes if we are certain they can't do EXTEND2 cells */
  2092. if (node->rs && !routerstatus_version_supports_extend2_cells(node->rs, 1))
  2093. continue;
  2094. /* Don't choose nodes if we are certain they can't do ntor. */
  2095. if ((node->ri || node->md) && !node_has_curve25519_onion_key(node))
  2096. continue;
  2097. /* Choose a node with an OR address that matches the firewall rules */
  2098. if (direct_conn && check_reach &&
  2099. !fascist_firewall_allows_node(node,
  2100. FIREWALL_OR_CONNECTION,
  2101. pref_addr))
  2102. continue;
  2103. smartlist_add(sl, (void *)node);
  2104. } SMARTLIST_FOREACH_END(node);
  2105. }
  2106. /** Look through the routerlist until we find a router that has my key.
  2107. Return it. */
  2108. const routerinfo_t *
  2109. routerlist_find_my_routerinfo(void)
  2110. {
  2111. if (!routerlist)
  2112. return NULL;
  2113. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, router,
  2114. {
  2115. if (router_is_me(router))
  2116. return router;
  2117. });
  2118. return NULL;
  2119. }
  2120. /** Return the smaller of the router's configured BandwidthRate
  2121. * and its advertised capacity. */
  2122. uint32_t
  2123. router_get_advertised_bandwidth(const routerinfo_t *router)
  2124. {
  2125. if (router->bandwidthcapacity < router->bandwidthrate)
  2126. return router->bandwidthcapacity;
  2127. return router->bandwidthrate;
  2128. }
  2129. /** Do not weight any declared bandwidth more than this much when picking
  2130. * routers by bandwidth. */
  2131. #define DEFAULT_MAX_BELIEVABLE_BANDWIDTH 10000000 /* 10 MB/sec */
  2132. /** Return the smaller of the router's configured BandwidthRate
  2133. * and its advertised capacity, capped by max-believe-bw. */
  2134. uint32_t
  2135. router_get_advertised_bandwidth_capped(const routerinfo_t *router)
  2136. {
  2137. uint32_t result = router->bandwidthcapacity;
  2138. if (result > router->bandwidthrate)
  2139. result = router->bandwidthrate;
  2140. if (result > DEFAULT_MAX_BELIEVABLE_BANDWIDTH)
  2141. result = DEFAULT_MAX_BELIEVABLE_BANDWIDTH;
  2142. return result;
  2143. }
  2144. /** Given an array of double/uint64_t unions that are currently being used as
  2145. * doubles, convert them to uint64_t, and try to scale them linearly so as to
  2146. * much of the range of uint64_t. If <b>total_out</b> is provided, set it to
  2147. * the sum of all elements in the array _before_ scaling. */
  2148. STATIC void
  2149. scale_array_elements_to_u64(uint64_t *entries_out, const double *entries_in,
  2150. int n_entries,
  2151. uint64_t *total_out)
  2152. {
  2153. double total = 0.0;
  2154. double scale_factor = 0.0;
  2155. int i;
  2156. for (i = 0; i < n_entries; ++i)
  2157. total += entries_in[i];
  2158. if (total > 0.0) {
  2159. scale_factor = ((double)INT64_MAX) / total;
  2160. scale_factor /= 4.0; /* make sure we're very far away from overflowing */
  2161. }
  2162. for (i = 0; i < n_entries; ++i)
  2163. entries_out[i] = tor_llround(entries_in[i] * scale_factor);
  2164. if (total_out)
  2165. *total_out = (uint64_t) total;
  2166. }
  2167. /** Pick a random element of <b>n_entries</b>-element array <b>entries</b>,
  2168. * choosing each element with a probability proportional to its (uint64_t)
  2169. * value, and return the index of that element. If all elements are 0, choose
  2170. * an index at random. Return -1 on error.
  2171. */
  2172. STATIC int
  2173. choose_array_element_by_weight(const uint64_t *entries, int n_entries)
  2174. {
  2175. int i;
  2176. uint64_t rand_val;
  2177. uint64_t total = 0;
  2178. for (i = 0; i < n_entries; ++i)
  2179. total += entries[i];
  2180. if (n_entries < 1)
  2181. return -1;
  2182. if (total == 0)
  2183. return crypto_rand_int(n_entries);
  2184. tor_assert(total < INT64_MAX);
  2185. rand_val = crypto_rand_uint64(total);
  2186. return select_array_member_cumulative_timei(
  2187. entries, n_entries, total, rand_val);
  2188. }
  2189. /** When weighting bridges, enforce these values as lower and upper
  2190. * bound for believable bandwidth, because there is no way for us
  2191. * to verify a bridge's bandwidth currently. */
  2192. #define BRIDGE_MIN_BELIEVABLE_BANDWIDTH 20000 /* 20 kB/sec */
  2193. #define BRIDGE_MAX_BELIEVABLE_BANDWIDTH 100000 /* 100 kB/sec */
  2194. /** Return the smaller of the router's configured BandwidthRate
  2195. * and its advertised capacity, making sure to stay within the
  2196. * interval between bridge-min-believe-bw and
  2197. * bridge-max-believe-bw. */
  2198. static uint32_t
  2199. bridge_get_advertised_bandwidth_bounded(routerinfo_t *router)
  2200. {
  2201. uint32_t result = router->bandwidthcapacity;
  2202. if (result > router->bandwidthrate)
  2203. result = router->bandwidthrate;
  2204. if (result > BRIDGE_MAX_BELIEVABLE_BANDWIDTH)
  2205. result = BRIDGE_MAX_BELIEVABLE_BANDWIDTH;
  2206. else if (result < BRIDGE_MIN_BELIEVABLE_BANDWIDTH)
  2207. result = BRIDGE_MIN_BELIEVABLE_BANDWIDTH;
  2208. return result;
  2209. }
  2210. /** Return bw*1000, unless bw*1000 would overflow, in which case return
  2211. * INT32_MAX. */
  2212. static inline int32_t
  2213. kb_to_bytes(uint32_t bw)
  2214. {
  2215. return (bw > (INT32_MAX/1000)) ? INT32_MAX : bw*1000;
  2216. }
  2217. /** Helper function:
  2218. * choose a random element of smartlist <b>sl</b> of nodes, weighted by
  2219. * the advertised bandwidth of each element using the consensus
  2220. * bandwidth weights.
  2221. *
  2222. * If <b>rule</b>==WEIGHT_FOR_EXIT. we're picking an exit node: consider all
  2223. * nodes' bandwidth equally regardless of their Exit status, since there may
  2224. * be some in the list because they exit to obscure ports. If
  2225. * <b>rule</b>==NO_WEIGHTING, we're picking a non-exit node: weight
  2226. * exit-node's bandwidth less depending on the smallness of the fraction of
  2227. * Exit-to-total bandwidth. If <b>rule</b>==WEIGHT_FOR_GUARD, we're picking a
  2228. * guard node: consider all guard's bandwidth equally. Otherwise, weight
  2229. * guards proportionally less.
  2230. */
  2231. static const node_t *
  2232. smartlist_choose_node_by_bandwidth_weights(const smartlist_t *sl,
  2233. bandwidth_weight_rule_t rule)
  2234. {
  2235. double *bandwidths_dbl=NULL;
  2236. uint64_t *bandwidths_u64=NULL;
  2237. if (compute_weighted_bandwidths(sl, rule, &bandwidths_dbl, NULL) < 0)
  2238. return NULL;
  2239. bandwidths_u64 = tor_calloc(smartlist_len(sl), sizeof(uint64_t));
  2240. scale_array_elements_to_u64(bandwidths_u64, bandwidths_dbl,
  2241. smartlist_len(sl), NULL);
  2242. {
  2243. int idx = choose_array_element_by_weight(bandwidths_u64,
  2244. smartlist_len(sl));
  2245. tor_free(bandwidths_dbl);
  2246. tor_free(bandwidths_u64);
  2247. return idx < 0 ? NULL : smartlist_get(sl, idx);
  2248. }
  2249. }
  2250. /** Given a list of routers and a weighting rule as in
  2251. * smartlist_choose_node_by_bandwidth_weights, compute weighted bandwidth
  2252. * values for each node and store them in a freshly allocated
  2253. * *<b>bandwidths_out</b> of the same length as <b>sl</b>, and holding results
  2254. * as doubles. If <b>total_bandwidth_out</b> is non-NULL, set it to the total
  2255. * of all the bandwidths.
  2256. * Return 0 on success, -1 on failure. */
  2257. static int
  2258. compute_weighted_bandwidths(const smartlist_t *sl,
  2259. bandwidth_weight_rule_t rule,
  2260. double **bandwidths_out,
  2261. double *total_bandwidth_out)
  2262. {
  2263. int64_t weight_scale;
  2264. double Wg = -1, Wm = -1, We = -1, Wd = -1;
  2265. double Wgb = -1, Wmb = -1, Web = -1, Wdb = -1;
  2266. guardfraction_bandwidth_t guardfraction_bw;
  2267. double *bandwidths = NULL;
  2268. double total_bandwidth = 0.0;
  2269. tor_assert(sl);
  2270. tor_assert(bandwidths_out);
  2271. /* Can't choose exit and guard at same time */
  2272. tor_assert(rule == NO_WEIGHTING ||
  2273. rule == WEIGHT_FOR_EXIT ||
  2274. rule == WEIGHT_FOR_GUARD ||
  2275. rule == WEIGHT_FOR_MID ||
  2276. rule == WEIGHT_FOR_DIR);
  2277. *bandwidths_out = NULL;
  2278. if (total_bandwidth_out) {
  2279. *total_bandwidth_out = 0.0;
  2280. }
  2281. if (smartlist_len(sl) == 0) {
  2282. log_info(LD_CIRC,
  2283. "Empty routerlist passed in to consensus weight node "
  2284. "selection for rule %s",
  2285. bandwidth_weight_rule_to_string(rule));
  2286. return -1;
  2287. }
  2288. weight_scale = networkstatus_get_weight_scale_param(NULL);
  2289. if (rule == WEIGHT_FOR_GUARD) {
  2290. Wg = networkstatus_get_bw_weight(NULL, "Wgg", -1);
  2291. Wm = networkstatus_get_bw_weight(NULL, "Wgm", -1); /* Bridges */
  2292. We = 0;
  2293. Wd = networkstatus_get_bw_weight(NULL, "Wgd", -1);
  2294. Wgb = networkstatus_get_bw_weight(NULL, "Wgb", -1);
  2295. Wmb = networkstatus_get_bw_weight(NULL, "Wmb", -1);
  2296. Web = networkstatus_get_bw_weight(NULL, "Web", -1);
  2297. Wdb = networkstatus_get_bw_weight(NULL, "Wdb", -1);
  2298. } else if (rule == WEIGHT_FOR_MID) {
  2299. Wg = networkstatus_get_bw_weight(NULL, "Wmg", -1);
  2300. Wm = networkstatus_get_bw_weight(NULL, "Wmm", -1);
  2301. We = networkstatus_get_bw_weight(NULL, "Wme", -1);
  2302. Wd = networkstatus_get_bw_weight(NULL, "Wmd", -1);
  2303. Wgb = networkstatus_get_bw_weight(NULL, "Wgb", -1);
  2304. Wmb = networkstatus_get_bw_weight(NULL, "Wmb", -1);
  2305. Web = networkstatus_get_bw_weight(NULL, "Web", -1);
  2306. Wdb = networkstatus_get_bw_weight(NULL, "Wdb", -1);
  2307. } else if (rule == WEIGHT_FOR_EXIT) {
  2308. // Guards CAN be exits if they have weird exit policies
  2309. // They are d then I guess...
  2310. We = networkstatus_get_bw_weight(NULL, "Wee", -1);
  2311. Wm = networkstatus_get_bw_weight(NULL, "Wem", -1); /* Odd exit policies */
  2312. Wd = networkstatus_get_bw_weight(NULL, "Wed", -1);
  2313. Wg = networkstatus_get_bw_weight(NULL, "Weg", -1); /* Odd exit policies */
  2314. Wgb = networkstatus_get_bw_weight(NULL, "Wgb", -1);
  2315. Wmb = networkstatus_get_bw_weight(NULL, "Wmb", -1);
  2316. Web = networkstatus_get_bw_weight(NULL, "Web", -1);
  2317. Wdb = networkstatus_get_bw_weight(NULL, "Wdb", -1);
  2318. } else if (rule == WEIGHT_FOR_DIR) {
  2319. We = networkstatus_get_bw_weight(NULL, "Wbe", -1);
  2320. Wm = networkstatus_get_bw_weight(NULL, "Wbm", -1);
  2321. Wd = networkstatus_get_bw_weight(NULL, "Wbd", -1);
  2322. Wg = networkstatus_get_bw_weight(NULL, "Wbg", -1);
  2323. Wgb = Wmb = Web = Wdb = weight_scale;
  2324. } else if (rule == NO_WEIGHTING) {
  2325. Wg = Wm = We = Wd = weight_scale;
  2326. Wgb = Wmb = Web = Wdb = weight_scale;
  2327. }
  2328. if (Wg < 0 || Wm < 0 || We < 0 || Wd < 0 || Wgb < 0 || Wmb < 0 || Wdb < 0
  2329. || Web < 0) {
  2330. log_debug(LD_CIRC,
  2331. "Got negative bandwidth weights. Defaulting to naive selection"
  2332. " algorithm.");
  2333. Wg = Wm = We = Wd = weight_scale;
  2334. Wgb = Wmb = Web = Wdb = weight_scale;
  2335. }
  2336. Wg /= weight_scale;
  2337. Wm /= weight_scale;
  2338. We /= weight_scale;
  2339. Wd /= weight_scale;
  2340. Wgb /= weight_scale;
  2341. Wmb /= weight_scale;
  2342. Web /= weight_scale;
  2343. Wdb /= weight_scale;
  2344. bandwidths = tor_calloc(smartlist_len(sl), sizeof(double));
  2345. // Cycle through smartlist and total the bandwidth.
  2346. static int warned_missing_bw = 0;
  2347. SMARTLIST_FOREACH_BEGIN(sl, const node_t *, node) {
  2348. int is_exit = 0, is_guard = 0, is_dir = 0, this_bw = 0;
  2349. double weight = 1;
  2350. double weight_without_guard_flag = 0; /* Used for guardfraction */
  2351. double final_weight = 0;
  2352. is_exit = node->is_exit && ! node->is_bad_exit;
  2353. is_guard = node->is_possible_guard;
  2354. is_dir = node_is_dir(node);
  2355. if (node->rs) {
  2356. if (!node->rs->has_bandwidth) {
  2357. /* This should never happen, unless all the authorities downgrade
  2358. * to 0.2.0 or rogue routerstatuses get inserted into our consensus. */
  2359. if (! warned_missing_bw) {
  2360. log_warn(LD_BUG,
  2361. "Consensus is missing some bandwidths. Using a naive "
  2362. "router selection algorithm");
  2363. warned_missing_bw = 1;
  2364. }
  2365. this_bw = 30000; /* Chosen arbitrarily */
  2366. } else {
  2367. this_bw = kb_to_bytes(node->rs->bandwidth_kb);
  2368. }
  2369. } else if (node->ri) {
  2370. /* bridge or other descriptor not in our consensus */
  2371. this_bw = bridge_get_advertised_bandwidth_bounded(node->ri);
  2372. } else {
  2373. /* We can't use this one. */
  2374. continue;
  2375. }
  2376. if (is_guard && is_exit) {
  2377. weight = (is_dir ? Wdb*Wd : Wd);
  2378. weight_without_guard_flag = (is_dir ? Web*We : We);
  2379. } else if (is_guard) {
  2380. weight = (is_dir ? Wgb*Wg : Wg);
  2381. weight_without_guard_flag = (is_dir ? Wmb*Wm : Wm);
  2382. } else if (is_exit) {
  2383. weight = (is_dir ? Web*We : We);
  2384. } else { // middle
  2385. weight = (is_dir ? Wmb*Wm : Wm);
  2386. }
  2387. /* These should be impossible; but overflows here would be bad, so let's
  2388. * make sure. */
  2389. if (this_bw < 0)
  2390. this_bw = 0;
  2391. if (weight < 0.0)
  2392. weight = 0.0;
  2393. if (weight_without_guard_flag < 0.0)
  2394. weight_without_guard_flag = 0.0;
  2395. /* If guardfraction information is available in the consensus, we
  2396. * want to calculate this router's bandwidth according to its
  2397. * guardfraction. Quoting from proposal236:
  2398. *
  2399. * Let Wpf denote the weight from the 'bandwidth-weights' line a
  2400. * client would apply to N for position p if it had the guard
  2401. * flag, Wpn the weight if it did not have the guard flag, and B the
  2402. * measured bandwidth of N in the consensus. Then instead of choosing
  2403. * N for position p proportionally to Wpf*B or Wpn*B, clients should
  2404. * choose N proportionally to F*Wpf*B + (1-F)*Wpn*B.
  2405. */
  2406. if (node->rs && node->rs->has_guardfraction && rule != WEIGHT_FOR_GUARD) {
  2407. /* XXX The assert should actually check for is_guard. However,
  2408. * that crashes dirauths because of #13297. This should be
  2409. * equivalent: */
  2410. tor_assert(node->rs->is_possible_guard);
  2411. guard_get_guardfraction_bandwidth(&guardfraction_bw,
  2412. this_bw,
  2413. node->rs->guardfraction_percentage);
  2414. /* Calculate final_weight = F*Wpf*B + (1-F)*Wpn*B */
  2415. final_weight =
  2416. guardfraction_bw.guard_bw * weight +
  2417. guardfraction_bw.non_guard_bw * weight_without_guard_flag;
  2418. log_debug(LD_GENERAL, "%s: Guardfraction weight %f instead of %f (%s)",
  2419. node->rs->nickname, final_weight, weight*this_bw,
  2420. bandwidth_weight_rule_to_string(rule));
  2421. } else { /* no guardfraction information. calculate the weight normally. */
  2422. final_weight = weight*this_bw;
  2423. }
  2424. bandwidths[node_sl_idx] = final_weight;
  2425. total_bandwidth += final_weight;
  2426. } SMARTLIST_FOREACH_END(node);
  2427. log_debug(LD_CIRC, "Generated weighted bandwidths for rule %s based "
  2428. "on weights "
  2429. "Wg=%f Wm=%f We=%f Wd=%f with total bw %f",
  2430. bandwidth_weight_rule_to_string(rule),
  2431. Wg, Wm, We, Wd, total_bandwidth);
  2432. *bandwidths_out = bandwidths;
  2433. if (total_bandwidth_out) {
  2434. *total_bandwidth_out = total_bandwidth;
  2435. }
  2436. return 0;
  2437. }
  2438. /** For all nodes in <b>sl</b>, return the fraction of those nodes, weighted
  2439. * by their weighted bandwidths with rule <b>rule</b>, for which we have
  2440. * descriptors. */
  2441. double
  2442. frac_nodes_with_descriptors(const smartlist_t *sl,
  2443. bandwidth_weight_rule_t rule)
  2444. {
  2445. double *bandwidths = NULL;
  2446. double total, present;
  2447. if (smartlist_len(sl) == 0)
  2448. return 0.0;
  2449. if (compute_weighted_bandwidths(sl, rule, &bandwidths, &total) < 0 ||
  2450. total <= 0.0) {
  2451. int n_with_descs = 0;
  2452. SMARTLIST_FOREACH(sl, const node_t *, node, {
  2453. if (node_has_descriptor(node))
  2454. n_with_descs++;
  2455. });
  2456. return ((double)n_with_descs) / (double)smartlist_len(sl);
  2457. }
  2458. present = 0.0;
  2459. SMARTLIST_FOREACH_BEGIN(sl, const node_t *, node) {
  2460. if (node_has_descriptor(node))
  2461. present += bandwidths[node_sl_idx];
  2462. } SMARTLIST_FOREACH_END(node);
  2463. tor_free(bandwidths);
  2464. return present / total;
  2465. }
  2466. /** Choose a random element of status list <b>sl</b>, weighted by
  2467. * the advertised bandwidth of each node */
  2468. const node_t *
  2469. node_sl_choose_by_bandwidth(const smartlist_t *sl,
  2470. bandwidth_weight_rule_t rule)
  2471. { /*XXXX MOVE */
  2472. return smartlist_choose_node_by_bandwidth_weights(sl, rule);
  2473. }
  2474. /** Return a random running node from the nodelist. Never
  2475. * pick a node that is in
  2476. * <b>excludedsmartlist</b>, or which matches <b>excludedset</b>,
  2477. * even if they are the only nodes available.
  2478. * If <b>CRN_NEED_UPTIME</b> is set in flags and any router has more than
  2479. * a minimum uptime, return one of those.
  2480. * If <b>CRN_NEED_CAPACITY</b> is set in flags, weight your choice by the
  2481. * advertised capacity of each router.
  2482. * If <b>CRN_NEED_GUARD</b> is set in flags, consider only Guard routers.
  2483. * If <b>CRN_WEIGHT_AS_EXIT</b> is set in flags, we weight bandwidths as if
  2484. * picking an exit node, otherwise we weight bandwidths for picking a relay
  2485. * node (that is, possibly discounting exit nodes).
  2486. * If <b>CRN_NEED_DESC</b> is set in flags, we only consider nodes that
  2487. * have a routerinfo or microdescriptor -- that is, enough info to be
  2488. * used to build a circuit.
  2489. * If <b>CRN_PREF_ADDR</b> is set in flags, we only consider nodes that
  2490. * have an address that is preferred by the ClientPreferIPv6ORPort setting
  2491. * (regardless of this flag, we exclude nodes that aren't allowed by the
  2492. * firewall, including ClientUseIPv4 0 and fascist_firewall_use_ipv6() == 0).
  2493. */
  2494. const node_t *
  2495. router_choose_random_node(smartlist_t *excludedsmartlist,
  2496. routerset_t *excludedset,
  2497. router_crn_flags_t flags)
  2498. { /* XXXX MOVE */
  2499. const int need_uptime = (flags & CRN_NEED_UPTIME) != 0;
  2500. const int need_capacity = (flags & CRN_NEED_CAPACITY) != 0;
  2501. const int need_guard = (flags & CRN_NEED_GUARD) != 0;
  2502. const int weight_for_exit = (flags & CRN_WEIGHT_AS_EXIT) != 0;
  2503. const int need_desc = (flags & CRN_NEED_DESC) != 0;
  2504. const int pref_addr = (flags & CRN_PREF_ADDR) != 0;
  2505. const int direct_conn = (flags & CRN_DIRECT_CONN) != 0;
  2506. const int rendezvous_v3 = (flags & CRN_RENDEZVOUS_V3) != 0;
  2507. smartlist_t *sl=smartlist_new(),
  2508. *excludednodes=smartlist_new();
  2509. const node_t *choice = NULL;
  2510. const routerinfo_t *r;
  2511. bandwidth_weight_rule_t rule;
  2512. tor_assert(!(weight_for_exit && need_guard));
  2513. rule = weight_for_exit ? WEIGHT_FOR_EXIT :
  2514. (need_guard ? WEIGHT_FOR_GUARD : WEIGHT_FOR_MID);
  2515. SMARTLIST_FOREACH_BEGIN(nodelist_get_list(), node_t *, node) {
  2516. if (node_allows_single_hop_exits(node)) {
  2517. /* Exclude relays that allow single hop exit circuits. This is an
  2518. * obsolete option since 0.2.9.2-alpha and done by default in
  2519. * 0.3.1.0-alpha. */
  2520. smartlist_add(excludednodes, node);
  2521. } else if (rendezvous_v3 &&
  2522. !node_supports_v3_rendezvous_point(node)) {
  2523. /* Exclude relays that do not support to rendezvous for a hidden service
  2524. * version 3. */
  2525. smartlist_add(excludednodes, node);
  2526. }
  2527. } SMARTLIST_FOREACH_END(node);
  2528. /* If the node_t is not found we won't be to exclude ourself but we
  2529. * won't be able to pick ourself in router_choose_random_node() so
  2530. * this is fine to at least try with our routerinfo_t object. */
  2531. if ((r = router_get_my_routerinfo()))
  2532. routerlist_add_node_and_family(excludednodes, r);
  2533. router_add_running_nodes_to_smartlist(sl, need_uptime, need_capacity,
  2534. need_guard, need_desc, pref_addr,
  2535. direct_conn);
  2536. log_debug(LD_CIRC,
  2537. "We found %d running nodes.",
  2538. smartlist_len(sl));
  2539. smartlist_subtract(sl,excludednodes);
  2540. log_debug(LD_CIRC,
  2541. "We removed %d excludednodes, leaving %d nodes.",
  2542. smartlist_len(excludednodes),
  2543. smartlist_len(sl));
  2544. if (excludedsmartlist) {
  2545. smartlist_subtract(sl,excludedsmartlist);
  2546. log_debug(LD_CIRC,
  2547. "We removed %d excludedsmartlist, leaving %d nodes.",
  2548. smartlist_len(excludedsmartlist),
  2549. smartlist_len(sl));
  2550. }
  2551. if (excludedset) {
  2552. routerset_subtract_nodes(sl,excludedset);
  2553. log_debug(LD_CIRC,
  2554. "We removed excludedset, leaving %d nodes.",
  2555. smartlist_len(sl));
  2556. }
  2557. // Always weight by bandwidth
  2558. choice = node_sl_choose_by_bandwidth(sl, rule);
  2559. smartlist_free(sl);
  2560. if (!choice && (need_uptime || need_capacity || need_guard || pref_addr)) {
  2561. /* try once more -- recurse but with fewer restrictions. */
  2562. log_info(LD_CIRC,
  2563. "We couldn't find any live%s%s%s routers; falling back "
  2564. "to list of all routers.",
  2565. need_capacity?", fast":"",
  2566. need_uptime?", stable":"",
  2567. need_guard?", guard":"");
  2568. flags &= ~ (CRN_NEED_UPTIME|CRN_NEED_CAPACITY|CRN_NEED_GUARD|
  2569. CRN_PREF_ADDR);
  2570. choice = router_choose_random_node(
  2571. excludedsmartlist, excludedset, flags);
  2572. }
  2573. smartlist_free(excludednodes);
  2574. if (!choice) {
  2575. log_warn(LD_CIRC,
  2576. "No available nodes when trying to choose node. Failing.");
  2577. }
  2578. return choice;
  2579. }
  2580. /** Helper: given an extended nickname in <b>hexdigest</b> try to decode it.
  2581. * Return 0 on success, -1 on failure. Store the result into the
  2582. * DIGEST_LEN-byte buffer at <b>digest_out</b>, the single character at
  2583. * <b>nickname_qualifier_char_out</b>, and the MAXNICKNAME_LEN+1-byte buffer
  2584. * at <b>nickname_out</b>.
  2585. *
  2586. * The recognized format is:
  2587. * HexName = Dollar? HexDigest NamePart?
  2588. * Dollar = '?'
  2589. * HexDigest = HexChar*20
  2590. * HexChar = 'a'..'f' | 'A'..'F' | '0'..'9'
  2591. * NamePart = QualChar Name
  2592. * QualChar = '=' | '~'
  2593. * Name = NameChar*(1..MAX_NICKNAME_LEN)
  2594. * NameChar = Any ASCII alphanumeric character
  2595. */
  2596. int
  2597. hex_digest_nickname_decode(const char *hexdigest,
  2598. char *digest_out,
  2599. char *nickname_qualifier_char_out,
  2600. char *nickname_out)
  2601. {
  2602. size_t len;
  2603. tor_assert(hexdigest);
  2604. if (hexdigest[0] == '$')
  2605. ++hexdigest;
  2606. len = strlen(hexdigest);
  2607. if (len < HEX_DIGEST_LEN) {
  2608. return -1;
  2609. } else if (len > HEX_DIGEST_LEN && (hexdigest[HEX_DIGEST_LEN] == '=' ||
  2610. hexdigest[HEX_DIGEST_LEN] == '~') &&
  2611. len <= HEX_DIGEST_LEN+1+MAX_NICKNAME_LEN) {
  2612. *nickname_qualifier_char_out = hexdigest[HEX_DIGEST_LEN];
  2613. strlcpy(nickname_out, hexdigest+HEX_DIGEST_LEN+1 , MAX_NICKNAME_LEN+1);
  2614. } else if (len == HEX_DIGEST_LEN) {
  2615. ;
  2616. } else {
  2617. return -1;
  2618. }
  2619. if (base16_decode(digest_out, DIGEST_LEN,
  2620. hexdigest, HEX_DIGEST_LEN) != DIGEST_LEN)
  2621. return -1;
  2622. return 0;
  2623. }
  2624. /** Helper: Return true iff the <b>identity_digest</b> and <b>nickname</b>
  2625. * combination of a router, encoded in hexadecimal, matches <b>hexdigest</b>
  2626. * (which is optionally prefixed with a single dollar sign). Return false if
  2627. * <b>hexdigest</b> is malformed, or it doesn't match. */
  2628. int
  2629. hex_digest_nickname_matches(const char *hexdigest, const char *identity_digest,
  2630. const char *nickname)
  2631. {
  2632. char digest[DIGEST_LEN];
  2633. char nn_char='\0';
  2634. char nn_buf[MAX_NICKNAME_LEN+1];
  2635. if (hex_digest_nickname_decode(hexdigest, digest, &nn_char, nn_buf) == -1)
  2636. return 0;
  2637. if (nn_char == '=') {
  2638. return 0;
  2639. }
  2640. if (nn_char == '~') {
  2641. if (!nickname) // XXX This seems wrong. -NM
  2642. return 0;
  2643. if (strcasecmp(nn_buf, nickname))
  2644. return 0;
  2645. }
  2646. return tor_memeq(digest, identity_digest, DIGEST_LEN);
  2647. }
  2648. /** Return true iff <b>digest</b> is the digest of the identity key of a
  2649. * trusted directory matching at least one bit of <b>type</b>. If <b>type</b>
  2650. * is zero (NO_DIRINFO), or ALL_DIRINFO, any authority is okay. */
  2651. int
  2652. router_digest_is_trusted_dir_type(const char *digest, dirinfo_type_t type)
  2653. {
  2654. if (!trusted_dir_servers)
  2655. return 0;
  2656. if (authdir_mode(get_options()) && router_digest_is_me(digest))
  2657. return 1;
  2658. SMARTLIST_FOREACH(trusted_dir_servers, dir_server_t *, ent,
  2659. if (tor_memeq(digest, ent->digest, DIGEST_LEN)) {
  2660. return (!type) || ((type & ent->type) != 0);
  2661. });
  2662. return 0;
  2663. }
  2664. /** If hexdigest is correctly formed, base16_decode it into
  2665. * digest, which must have DIGEST_LEN space in it.
  2666. * Return 0 on success, -1 on failure.
  2667. */
  2668. int
  2669. hexdigest_to_digest(const char *hexdigest, char *digest)
  2670. {
  2671. if (hexdigest[0]=='$')
  2672. ++hexdigest;
  2673. if (strlen(hexdigest) < HEX_DIGEST_LEN ||
  2674. base16_decode(digest,DIGEST_LEN,hexdigest,HEX_DIGEST_LEN) != DIGEST_LEN)
  2675. return -1;
  2676. return 0;
  2677. }
  2678. /** As router_get_by_id_digest,but return a pointer that you're allowed to
  2679. * modify */
  2680. routerinfo_t *
  2681. router_get_mutable_by_digest(const char *digest)
  2682. {
  2683. tor_assert(digest);
  2684. if (!routerlist) return NULL;
  2685. // routerlist_assert_ok(routerlist);
  2686. return rimap_get(routerlist->identity_map, digest);
  2687. }
  2688. /** Return the router in our routerlist whose 20-byte key digest
  2689. * is <b>digest</b>. Return NULL if no such router is known. */
  2690. const routerinfo_t *
  2691. router_get_by_id_digest(const char *digest)
  2692. {
  2693. return router_get_mutable_by_digest(digest);
  2694. }
  2695. /** Return the router in our routerlist whose 20-byte descriptor
  2696. * is <b>digest</b>. Return NULL if no such router is known. */
  2697. signed_descriptor_t *
  2698. router_get_by_descriptor_digest(const char *digest)
  2699. {
  2700. tor_assert(digest);
  2701. if (!routerlist) return NULL;
  2702. return sdmap_get(routerlist->desc_digest_map, digest);
  2703. }
  2704. /** Return the signed descriptor for the router in our routerlist whose
  2705. * 20-byte extra-info digest is <b>digest</b>. Return NULL if no such router
  2706. * is known. */
  2707. MOCK_IMPL(signed_descriptor_t *,
  2708. router_get_by_extrainfo_digest,(const char *digest))
  2709. {
  2710. tor_assert(digest);
  2711. if (!routerlist) return NULL;
  2712. return sdmap_get(routerlist->desc_by_eid_map, digest);
  2713. }
  2714. /** Return the signed descriptor for the extrainfo_t in our routerlist whose
  2715. * extra-info-digest is <b>digest</b>. Return NULL if no such extra-info
  2716. * document is known. */
  2717. MOCK_IMPL(signed_descriptor_t *,
  2718. extrainfo_get_by_descriptor_digest,(const char *digest))
  2719. {
  2720. extrainfo_t *ei;
  2721. tor_assert(digest);
  2722. if (!routerlist) return NULL;
  2723. ei = eimap_get(routerlist->extra_info_map, digest);
  2724. return ei ? &ei->cache_info : NULL;
  2725. }
  2726. /** Return a pointer to the signed textual representation of a descriptor.
  2727. * The returned string is not guaranteed to be NUL-terminated: the string's
  2728. * length will be in desc-\>signed_descriptor_len.
  2729. *
  2730. * If <b>with_annotations</b> is set, the returned string will include
  2731. * the annotations
  2732. * (if any) preceding the descriptor. This will increase the length of the
  2733. * string by desc-\>annotations_len.
  2734. *
  2735. * The caller must not free the string returned.
  2736. */
  2737. static const char *
  2738. signed_descriptor_get_body_impl(const signed_descriptor_t *desc,
  2739. int with_annotations)
  2740. {
  2741. const char *r = NULL;
  2742. size_t len = desc->signed_descriptor_len;
  2743. off_t offset = desc->saved_offset;
  2744. if (with_annotations)
  2745. len += desc->annotations_len;
  2746. else
  2747. offset += desc->annotations_len;
  2748. tor_assert(len > 32);
  2749. if (desc->saved_location == SAVED_IN_CACHE && routerlist) {
  2750. desc_store_t *store = desc_get_store(router_get_routerlist(), desc);
  2751. if (store && store->mmap) {
  2752. tor_assert(desc->saved_offset + len <= store->mmap->size);
  2753. r = store->mmap->data + offset;
  2754. } else if (store) {
  2755. log_err(LD_DIR, "We couldn't read a descriptor that is supposedly "
  2756. "mmaped in our cache. Is another process running in our data "
  2757. "directory? Exiting.");
  2758. exit(1); // XXXX bad exit: should recover.
  2759. }
  2760. }
  2761. if (!r) /* no mmap, or not in cache. */
  2762. r = desc->signed_descriptor_body +
  2763. (with_annotations ? 0 : desc->annotations_len);
  2764. tor_assert(r);
  2765. if (!with_annotations) {
  2766. if (fast_memcmp("router ", r, 7) && fast_memcmp("extra-info ", r, 11)) {
  2767. char *cp = tor_strndup(r, 64);
  2768. log_err(LD_DIR, "descriptor at %p begins with unexpected string %s. "
  2769. "Is another process running in our data directory? Exiting.",
  2770. desc, escaped(cp));
  2771. exit(1); // XXXX bad exit: should recover.
  2772. }
  2773. }
  2774. return r;
  2775. }
  2776. /** Return a pointer to the signed textual representation of a descriptor.
  2777. * The returned string is not guaranteed to be NUL-terminated: the string's
  2778. * length will be in desc-\>signed_descriptor_len.
  2779. *
  2780. * The caller must not free the string returned.
  2781. */
  2782. const char *
  2783. signed_descriptor_get_body(const signed_descriptor_t *desc)
  2784. {
  2785. return signed_descriptor_get_body_impl(desc, 0);
  2786. }
  2787. /** As signed_descriptor_get_body(), but points to the beginning of the
  2788. * annotations section rather than the beginning of the descriptor. */
  2789. const char *
  2790. signed_descriptor_get_annotations(const signed_descriptor_t *desc)
  2791. {
  2792. return signed_descriptor_get_body_impl(desc, 1);
  2793. }
  2794. /** Return the current list of all known routers. */
  2795. routerlist_t *
  2796. router_get_routerlist(void)
  2797. {
  2798. if (PREDICT_UNLIKELY(!routerlist)) {
  2799. routerlist = tor_malloc_zero(sizeof(routerlist_t));
  2800. routerlist->routers = smartlist_new();
  2801. routerlist->old_routers = smartlist_new();
  2802. routerlist->identity_map = rimap_new();
  2803. routerlist->desc_digest_map = sdmap_new();
  2804. routerlist->desc_by_eid_map = sdmap_new();
  2805. routerlist->extra_info_map = eimap_new();
  2806. routerlist->desc_store.fname_base = "cached-descriptors";
  2807. routerlist->extrainfo_store.fname_base = "cached-extrainfo";
  2808. routerlist->desc_store.type = ROUTER_STORE;
  2809. routerlist->extrainfo_store.type = EXTRAINFO_STORE;
  2810. routerlist->desc_store.description = "router descriptors";
  2811. routerlist->extrainfo_store.description = "extra-info documents";
  2812. }
  2813. return routerlist;
  2814. }
  2815. /** Free all storage held by <b>router</b>. */
  2816. void
  2817. routerinfo_free_(routerinfo_t *router)
  2818. {
  2819. if (!router)
  2820. return;
  2821. tor_free(router->cache_info.signed_descriptor_body);
  2822. tor_free(router->nickname);
  2823. tor_free(router->platform);
  2824. tor_free(router->protocol_list);
  2825. tor_free(router->contact_info);
  2826. if (router->onion_pkey)
  2827. crypto_pk_free(router->onion_pkey);
  2828. tor_free(router->onion_curve25519_pkey);
  2829. if (router->identity_pkey)
  2830. crypto_pk_free(router->identity_pkey);
  2831. tor_cert_free(router->cache_info.signing_key_cert);
  2832. if (router->declared_family) {
  2833. SMARTLIST_FOREACH(router->declared_family, char *, s, tor_free(s));
  2834. smartlist_free(router->declared_family);
  2835. }
  2836. addr_policy_list_free(router->exit_policy);
  2837. short_policy_free(router->ipv6_exit_policy);
  2838. memset(router, 77, sizeof(routerinfo_t));
  2839. tor_free(router);
  2840. }
  2841. /** Release all storage held by <b>extrainfo</b> */
  2842. void
  2843. extrainfo_free_(extrainfo_t *extrainfo)
  2844. {
  2845. if (!extrainfo)
  2846. return;
  2847. tor_cert_free(extrainfo->cache_info.signing_key_cert);
  2848. tor_free(extrainfo->cache_info.signed_descriptor_body);
  2849. tor_free(extrainfo->pending_sig);
  2850. memset(extrainfo, 88, sizeof(extrainfo_t)); /* debug bad memory usage */
  2851. tor_free(extrainfo);
  2852. }
  2853. #define signed_descriptor_free(val) \
  2854. FREE_AND_NULL(signed_descriptor_t, signed_descriptor_free_, (val))
  2855. /** Release storage held by <b>sd</b>. */
  2856. static void
  2857. signed_descriptor_free_(signed_descriptor_t *sd)
  2858. {
  2859. if (!sd)
  2860. return;
  2861. tor_free(sd->signed_descriptor_body);
  2862. tor_cert_free(sd->signing_key_cert);
  2863. memset(sd, 99, sizeof(signed_descriptor_t)); /* Debug bad mem usage */
  2864. tor_free(sd);
  2865. }
  2866. /** Reset the given signed descriptor <b>sd</b> by freeing the allocated
  2867. * memory inside the object and by zeroing its content. */
  2868. static void
  2869. signed_descriptor_reset(signed_descriptor_t *sd)
  2870. {
  2871. tor_assert(sd);
  2872. tor_free(sd->signed_descriptor_body);
  2873. tor_cert_free(sd->signing_key_cert);
  2874. memset(sd, 0, sizeof(*sd));
  2875. }
  2876. /** Copy src into dest, and steal all references inside src so that when
  2877. * we free src, we don't mess up dest. */
  2878. static void
  2879. signed_descriptor_move(signed_descriptor_t *dest,
  2880. signed_descriptor_t *src)
  2881. {
  2882. tor_assert(dest != src);
  2883. /* Cleanup destination object before overwriting it.*/
  2884. signed_descriptor_reset(dest);
  2885. memcpy(dest, src, sizeof(signed_descriptor_t));
  2886. src->signed_descriptor_body = NULL;
  2887. src->signing_key_cert = NULL;
  2888. dest->routerlist_index = -1;
  2889. }
  2890. /** Extract a signed_descriptor_t from a general routerinfo, and free the
  2891. * routerinfo.
  2892. */
  2893. static signed_descriptor_t *
  2894. signed_descriptor_from_routerinfo(routerinfo_t *ri)
  2895. {
  2896. signed_descriptor_t *sd;
  2897. tor_assert(ri->purpose == ROUTER_PURPOSE_GENERAL);
  2898. sd = tor_malloc_zero(sizeof(signed_descriptor_t));
  2899. signed_descriptor_move(sd, &ri->cache_info);
  2900. routerinfo_free(ri);
  2901. return sd;
  2902. }
  2903. /** Helper: free the storage held by the extrainfo_t in <b>e</b>. */
  2904. static void
  2905. extrainfo_free_void(void *e)
  2906. {
  2907. extrainfo_free_(e);
  2908. }
  2909. /** Free all storage held by a routerlist <b>rl</b>. */
  2910. void
  2911. routerlist_free_(routerlist_t *rl)
  2912. {
  2913. if (!rl)
  2914. return;
  2915. rimap_free(rl->identity_map, NULL);
  2916. sdmap_free(rl->desc_digest_map, NULL);
  2917. sdmap_free(rl->desc_by_eid_map, NULL);
  2918. eimap_free(rl->extra_info_map, extrainfo_free_void);
  2919. SMARTLIST_FOREACH(rl->routers, routerinfo_t *, r,
  2920. routerinfo_free(r));
  2921. SMARTLIST_FOREACH(rl->old_routers, signed_descriptor_t *, sd,
  2922. signed_descriptor_free(sd));
  2923. smartlist_free(rl->routers);
  2924. smartlist_free(rl->old_routers);
  2925. if (rl->desc_store.mmap) {
  2926. int res = tor_munmap_file(routerlist->desc_store.mmap);
  2927. if (res != 0) {
  2928. log_warn(LD_FS, "Failed to munmap routerlist->desc_store.mmap");
  2929. }
  2930. }
  2931. if (rl->extrainfo_store.mmap) {
  2932. int res = tor_munmap_file(routerlist->extrainfo_store.mmap);
  2933. if (res != 0) {
  2934. log_warn(LD_FS, "Failed to munmap routerlist->extrainfo_store.mmap");
  2935. }
  2936. }
  2937. tor_free(rl);
  2938. router_dir_info_changed();
  2939. }
  2940. /** Log information about how much memory is being used for routerlist,
  2941. * at log level <b>severity</b>. */
  2942. void
  2943. dump_routerlist_mem_usage(int severity)
  2944. {
  2945. uint64_t livedescs = 0;
  2946. uint64_t olddescs = 0;
  2947. if (!routerlist)
  2948. return;
  2949. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, r,
  2950. livedescs += r->cache_info.signed_descriptor_len);
  2951. SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd,
  2952. olddescs += sd->signed_descriptor_len);
  2953. tor_log(severity, LD_DIR,
  2954. "In %d live descriptors: "U64_FORMAT" bytes. "
  2955. "In %d old descriptors: "U64_FORMAT" bytes.",
  2956. smartlist_len(routerlist->routers), U64_PRINTF_ARG(livedescs),
  2957. smartlist_len(routerlist->old_routers), U64_PRINTF_ARG(olddescs));
  2958. }
  2959. /** Debugging helper: If <b>idx</b> is nonnegative, assert that <b>ri</b> is
  2960. * in <b>sl</b> at position <b>idx</b>. Otherwise, search <b>sl</b> for
  2961. * <b>ri</b>. Return the index of <b>ri</b> in <b>sl</b>, or -1 if <b>ri</b>
  2962. * is not in <b>sl</b>. */
  2963. static inline int
  2964. routerlist_find_elt_(smartlist_t *sl, void *ri, int idx)
  2965. {
  2966. if (idx < 0) {
  2967. idx = -1;
  2968. SMARTLIST_FOREACH(sl, routerinfo_t *, r,
  2969. if (r == ri) {
  2970. idx = r_sl_idx;
  2971. break;
  2972. });
  2973. } else {
  2974. tor_assert(idx < smartlist_len(sl));
  2975. tor_assert(smartlist_get(sl, idx) == ri);
  2976. };
  2977. return idx;
  2978. }
  2979. /** Insert an item <b>ri</b> into the routerlist <b>rl</b>, updating indices
  2980. * as needed. There must be no previous member of <b>rl</b> with the same
  2981. * identity digest as <b>ri</b>: If there is, call routerlist_replace
  2982. * instead.
  2983. */
  2984. static void
  2985. routerlist_insert(routerlist_t *rl, routerinfo_t *ri)
  2986. {
  2987. routerinfo_t *ri_old;
  2988. signed_descriptor_t *sd_old;
  2989. {
  2990. const routerinfo_t *ri_generated = router_get_my_routerinfo();
  2991. tor_assert(ri_generated != ri);
  2992. }
  2993. tor_assert(ri->cache_info.routerlist_index == -1);
  2994. ri_old = rimap_set(rl->identity_map, ri->cache_info.identity_digest, ri);
  2995. tor_assert(!ri_old);
  2996. sd_old = sdmap_set(rl->desc_digest_map,
  2997. ri->cache_info.signed_descriptor_digest,
  2998. &(ri->cache_info));
  2999. if (sd_old) {
  3000. int idx = sd_old->routerlist_index;
  3001. sd_old->routerlist_index = -1;
  3002. smartlist_del(rl->old_routers, idx);
  3003. if (idx < smartlist_len(rl->old_routers)) {
  3004. signed_descriptor_t *d = smartlist_get(rl->old_routers, idx);
  3005. d->routerlist_index = idx;
  3006. }
  3007. rl->desc_store.bytes_dropped += sd_old->signed_descriptor_len;
  3008. sdmap_remove(rl->desc_by_eid_map, sd_old->extra_info_digest);
  3009. signed_descriptor_free(sd_old);
  3010. }
  3011. if (!tor_digest_is_zero(ri->cache_info.extra_info_digest))
  3012. sdmap_set(rl->desc_by_eid_map, ri->cache_info.extra_info_digest,
  3013. &ri->cache_info);
  3014. smartlist_add(rl->routers, ri);
  3015. ri->cache_info.routerlist_index = smartlist_len(rl->routers) - 1;
  3016. nodelist_set_routerinfo(ri, NULL);
  3017. router_dir_info_changed();
  3018. #ifdef DEBUG_ROUTERLIST
  3019. routerlist_assert_ok(rl);
  3020. #endif
  3021. }
  3022. /** Adds the extrainfo_t <b>ei</b> to the routerlist <b>rl</b>, if there is a
  3023. * corresponding router in rl-\>routers or rl-\>old_routers. Return the status
  3024. * of inserting <b>ei</b>. Free <b>ei</b> if it isn't inserted. */
  3025. MOCK_IMPL(STATIC was_router_added_t,
  3026. extrainfo_insert,(routerlist_t *rl, extrainfo_t *ei, int warn_if_incompatible))
  3027. {
  3028. was_router_added_t r;
  3029. const char *compatibility_error_msg;
  3030. routerinfo_t *ri = rimap_get(rl->identity_map,
  3031. ei->cache_info.identity_digest);
  3032. signed_descriptor_t *sd =
  3033. sdmap_get(rl->desc_by_eid_map, ei->cache_info.signed_descriptor_digest);
  3034. extrainfo_t *ei_tmp;
  3035. const int severity = warn_if_incompatible ? LOG_WARN : LOG_INFO;
  3036. {
  3037. extrainfo_t *ei_generated = router_get_my_extrainfo();
  3038. tor_assert(ei_generated != ei);
  3039. }
  3040. if (!ri) {
  3041. /* This router is unknown; we can't even verify the signature. Give up.*/
  3042. r = ROUTER_NOT_IN_CONSENSUS;
  3043. goto done;
  3044. }
  3045. if (! sd) {
  3046. /* The extrainfo router doesn't have a known routerdesc to attach it to.
  3047. * This just won't work. */;
  3048. static ratelim_t no_sd_ratelim = RATELIM_INIT(1800);
  3049. r = ROUTER_BAD_EI;
  3050. log_fn_ratelim(&no_sd_ratelim, severity, LD_BUG,
  3051. "No entry found in extrainfo map.");
  3052. goto done;
  3053. }
  3054. if (tor_memneq(ei->cache_info.signed_descriptor_digest,
  3055. sd->extra_info_digest, DIGEST_LEN)) {
  3056. static ratelim_t digest_mismatch_ratelim = RATELIM_INIT(1800);
  3057. /* The sd we got from the map doesn't match the digest we used to look
  3058. * it up. This makes no sense. */
  3059. r = ROUTER_BAD_EI;
  3060. log_fn_ratelim(&digest_mismatch_ratelim, severity, LD_BUG,
  3061. "Mismatch in digest in extrainfo map.");
  3062. goto done;
  3063. }
  3064. if (routerinfo_incompatible_with_extrainfo(ri->identity_pkey, ei, sd,
  3065. &compatibility_error_msg)) {
  3066. char d1[HEX_DIGEST_LEN+1], d2[HEX_DIGEST_LEN+1];
  3067. r = (ri->cache_info.extrainfo_is_bogus) ?
  3068. ROUTER_BAD_EI : ROUTER_NOT_IN_CONSENSUS;
  3069. base16_encode(d1, sizeof(d1), ri->cache_info.identity_digest, DIGEST_LEN);
  3070. base16_encode(d2, sizeof(d2), ei->cache_info.identity_digest, DIGEST_LEN);
  3071. log_fn(severity,LD_DIR,
  3072. "router info incompatible with extra info (ri id: %s, ei id %s, "
  3073. "reason: %s)", d1, d2, compatibility_error_msg);
  3074. goto done;
  3075. }
  3076. /* Okay, if we make it here, we definitely have a router corresponding to
  3077. * this extrainfo. */
  3078. ei_tmp = eimap_set(rl->extra_info_map,
  3079. ei->cache_info.signed_descriptor_digest,
  3080. ei);
  3081. r = ROUTER_ADDED_SUCCESSFULLY;
  3082. if (ei_tmp) {
  3083. rl->extrainfo_store.bytes_dropped +=
  3084. ei_tmp->cache_info.signed_descriptor_len;
  3085. extrainfo_free(ei_tmp);
  3086. }
  3087. done:
  3088. if (r != ROUTER_ADDED_SUCCESSFULLY)
  3089. extrainfo_free(ei);
  3090. #ifdef DEBUG_ROUTERLIST
  3091. routerlist_assert_ok(rl);
  3092. #endif
  3093. return r;
  3094. }
  3095. #define should_cache_old_descriptors() \
  3096. directory_caches_dir_info(get_options())
  3097. /** If we're a directory cache and routerlist <b>rl</b> doesn't have
  3098. * a copy of router <b>ri</b> yet, add it to the list of old (not
  3099. * recommended but still served) descriptors. Else free it. */
  3100. static void
  3101. routerlist_insert_old(routerlist_t *rl, routerinfo_t *ri)
  3102. {
  3103. {
  3104. const routerinfo_t *ri_generated = router_get_my_routerinfo();
  3105. tor_assert(ri_generated != ri);
  3106. }
  3107. tor_assert(ri->cache_info.routerlist_index == -1);
  3108. if (should_cache_old_descriptors() &&
  3109. ri->purpose == ROUTER_PURPOSE_GENERAL &&
  3110. !sdmap_get(rl->desc_digest_map,
  3111. ri->cache_info.signed_descriptor_digest)) {
  3112. signed_descriptor_t *sd = signed_descriptor_from_routerinfo(ri);
  3113. sdmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);
  3114. smartlist_add(rl->old_routers, sd);
  3115. sd->routerlist_index = smartlist_len(rl->old_routers)-1;
  3116. if (!tor_digest_is_zero(sd->extra_info_digest))
  3117. sdmap_set(rl->desc_by_eid_map, sd->extra_info_digest, sd);
  3118. } else {
  3119. routerinfo_free(ri);
  3120. }
  3121. #ifdef DEBUG_ROUTERLIST
  3122. routerlist_assert_ok(rl);
  3123. #endif
  3124. }
  3125. /** Remove an item <b>ri</b> from the routerlist <b>rl</b>, updating indices
  3126. * as needed. If <b>idx</b> is nonnegative and smartlist_get(rl-&gt;routers,
  3127. * idx) == ri, we don't need to do a linear search over the list to decide
  3128. * which to remove. We fill the gap in rl-&gt;routers with a later element in
  3129. * the list, if any exists. <b>ri</b> is freed.
  3130. *
  3131. * If <b>make_old</b> is true, instead of deleting the router, we try adding
  3132. * it to rl-&gt;old_routers. */
  3133. void
  3134. routerlist_remove(routerlist_t *rl, routerinfo_t *ri, int make_old, time_t now)
  3135. {
  3136. routerinfo_t *ri_tmp;
  3137. extrainfo_t *ei_tmp;
  3138. int idx = ri->cache_info.routerlist_index;
  3139. tor_assert(0 <= idx && idx < smartlist_len(rl->routers));
  3140. tor_assert(smartlist_get(rl->routers, idx) == ri);
  3141. nodelist_remove_routerinfo(ri);
  3142. /* make sure the rephist module knows that it's not running */
  3143. rep_hist_note_router_unreachable(ri->cache_info.identity_digest, now);
  3144. ri->cache_info.routerlist_index = -1;
  3145. smartlist_del(rl->routers, idx);
  3146. if (idx < smartlist_len(rl->routers)) {
  3147. routerinfo_t *r = smartlist_get(rl->routers, idx);
  3148. r->cache_info.routerlist_index = idx;
  3149. }
  3150. ri_tmp = rimap_remove(rl->identity_map, ri->cache_info.identity_digest);
  3151. router_dir_info_changed();
  3152. tor_assert(ri_tmp == ri);
  3153. if (make_old && should_cache_old_descriptors() &&
  3154. ri->purpose == ROUTER_PURPOSE_GENERAL) {
  3155. signed_descriptor_t *sd;
  3156. sd = signed_descriptor_from_routerinfo(ri);
  3157. smartlist_add(rl->old_routers, sd);
  3158. sd->routerlist_index = smartlist_len(rl->old_routers)-1;
  3159. sdmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);
  3160. if (!tor_digest_is_zero(sd->extra_info_digest))
  3161. sdmap_set(rl->desc_by_eid_map, sd->extra_info_digest, sd);
  3162. } else {
  3163. signed_descriptor_t *sd_tmp;
  3164. sd_tmp = sdmap_remove(rl->desc_digest_map,
  3165. ri->cache_info.signed_descriptor_digest);
  3166. tor_assert(sd_tmp == &(ri->cache_info));
  3167. rl->desc_store.bytes_dropped += ri->cache_info.signed_descriptor_len;
  3168. ei_tmp = eimap_remove(rl->extra_info_map,
  3169. ri->cache_info.extra_info_digest);
  3170. if (ei_tmp) {
  3171. rl->extrainfo_store.bytes_dropped +=
  3172. ei_tmp->cache_info.signed_descriptor_len;
  3173. extrainfo_free(ei_tmp);
  3174. }
  3175. if (!tor_digest_is_zero(ri->cache_info.extra_info_digest))
  3176. sdmap_remove(rl->desc_by_eid_map, ri->cache_info.extra_info_digest);
  3177. routerinfo_free(ri);
  3178. }
  3179. #ifdef DEBUG_ROUTERLIST
  3180. routerlist_assert_ok(rl);
  3181. #endif
  3182. }
  3183. /** Remove a signed_descriptor_t <b>sd</b> from <b>rl</b>-\>old_routers, and
  3184. * adjust <b>rl</b> as appropriate. <b>idx</b> is -1, or the index of
  3185. * <b>sd</b>. */
  3186. static void
  3187. routerlist_remove_old(routerlist_t *rl, signed_descriptor_t *sd, int idx)
  3188. {
  3189. signed_descriptor_t *sd_tmp;
  3190. extrainfo_t *ei_tmp;
  3191. desc_store_t *store;
  3192. if (idx == -1) {
  3193. idx = sd->routerlist_index;
  3194. }
  3195. tor_assert(0 <= idx && idx < smartlist_len(rl->old_routers));
  3196. /* XXXX edmanm's bridge relay triggered the following assert while
  3197. * running 0.2.0.12-alpha. If anybody triggers this again, see if we
  3198. * can get a backtrace. */
  3199. tor_assert(smartlist_get(rl->old_routers, idx) == sd);
  3200. tor_assert(idx == sd->routerlist_index);
  3201. sd->routerlist_index = -1;
  3202. smartlist_del(rl->old_routers, idx);
  3203. if (idx < smartlist_len(rl->old_routers)) {
  3204. signed_descriptor_t *d = smartlist_get(rl->old_routers, idx);
  3205. d->routerlist_index = idx;
  3206. }
  3207. sd_tmp = sdmap_remove(rl->desc_digest_map,
  3208. sd->signed_descriptor_digest);
  3209. tor_assert(sd_tmp == sd);
  3210. store = desc_get_store(rl, sd);
  3211. if (store)
  3212. store->bytes_dropped += sd->signed_descriptor_len;
  3213. ei_tmp = eimap_remove(rl->extra_info_map,
  3214. sd->extra_info_digest);
  3215. if (ei_tmp) {
  3216. rl->extrainfo_store.bytes_dropped +=
  3217. ei_tmp->cache_info.signed_descriptor_len;
  3218. extrainfo_free(ei_tmp);
  3219. }
  3220. if (!tor_digest_is_zero(sd->extra_info_digest))
  3221. sdmap_remove(rl->desc_by_eid_map, sd->extra_info_digest);
  3222. signed_descriptor_free(sd);
  3223. #ifdef DEBUG_ROUTERLIST
  3224. routerlist_assert_ok(rl);
  3225. #endif
  3226. }
  3227. /** Remove <b>ri_old</b> from the routerlist <b>rl</b>, and replace it with
  3228. * <b>ri_new</b>, updating all index info. If <b>idx</b> is nonnegative and
  3229. * smartlist_get(rl-&gt;routers, idx) == ri, we don't need to do a linear
  3230. * search over the list to decide which to remove. We put ri_new in the same
  3231. * index as ri_old, if possible. ri is freed as appropriate.
  3232. *
  3233. * If should_cache_descriptors() is true, instead of deleting the router,
  3234. * we add it to rl-&gt;old_routers. */
  3235. static void
  3236. routerlist_replace(routerlist_t *rl, routerinfo_t *ri_old,
  3237. routerinfo_t *ri_new)
  3238. {
  3239. int idx;
  3240. int same_descriptors;
  3241. routerinfo_t *ri_tmp;
  3242. extrainfo_t *ei_tmp;
  3243. {
  3244. const routerinfo_t *ri_generated = router_get_my_routerinfo();
  3245. tor_assert(ri_generated != ri_new);
  3246. }
  3247. tor_assert(ri_old != ri_new);
  3248. tor_assert(ri_new->cache_info.routerlist_index == -1);
  3249. idx = ri_old->cache_info.routerlist_index;
  3250. tor_assert(0 <= idx && idx < smartlist_len(rl->routers));
  3251. tor_assert(smartlist_get(rl->routers, idx) == ri_old);
  3252. {
  3253. routerinfo_t *ri_old_tmp=NULL;
  3254. nodelist_set_routerinfo(ri_new, &ri_old_tmp);
  3255. tor_assert(ri_old == ri_old_tmp);
  3256. }
  3257. router_dir_info_changed();
  3258. if (idx >= 0) {
  3259. smartlist_set(rl->routers, idx, ri_new);
  3260. ri_old->cache_info.routerlist_index = -1;
  3261. ri_new->cache_info.routerlist_index = idx;
  3262. /* Check that ri_old is not in rl->routers anymore: */
  3263. tor_assert( routerlist_find_elt_(rl->routers, ri_old, -1) == -1 );
  3264. } else {
  3265. log_warn(LD_BUG, "Appending entry from routerlist_replace.");
  3266. routerlist_insert(rl, ri_new);
  3267. return;
  3268. }
  3269. if (tor_memneq(ri_old->cache_info.identity_digest,
  3270. ri_new->cache_info.identity_digest, DIGEST_LEN)) {
  3271. /* digests don't match; digestmap_set won't replace */
  3272. rimap_remove(rl->identity_map, ri_old->cache_info.identity_digest);
  3273. }
  3274. ri_tmp = rimap_set(rl->identity_map,
  3275. ri_new->cache_info.identity_digest, ri_new);
  3276. tor_assert(!ri_tmp || ri_tmp == ri_old);
  3277. sdmap_set(rl->desc_digest_map,
  3278. ri_new->cache_info.signed_descriptor_digest,
  3279. &(ri_new->cache_info));
  3280. if (!tor_digest_is_zero(ri_new->cache_info.extra_info_digest)) {
  3281. sdmap_set(rl->desc_by_eid_map, ri_new->cache_info.extra_info_digest,
  3282. &ri_new->cache_info);
  3283. }
  3284. same_descriptors = tor_memeq(ri_old->cache_info.signed_descriptor_digest,
  3285. ri_new->cache_info.signed_descriptor_digest,
  3286. DIGEST_LEN);
  3287. if (should_cache_old_descriptors() &&
  3288. ri_old->purpose == ROUTER_PURPOSE_GENERAL &&
  3289. !same_descriptors) {
  3290. /* ri_old is going to become a signed_descriptor_t and go into
  3291. * old_routers */
  3292. signed_descriptor_t *sd = signed_descriptor_from_routerinfo(ri_old);
  3293. smartlist_add(rl->old_routers, sd);
  3294. sd->routerlist_index = smartlist_len(rl->old_routers)-1;
  3295. sdmap_set(rl->desc_digest_map, sd->signed_descriptor_digest, sd);
  3296. if (!tor_digest_is_zero(sd->extra_info_digest))
  3297. sdmap_set(rl->desc_by_eid_map, sd->extra_info_digest, sd);
  3298. } else {
  3299. /* We're dropping ri_old. */
  3300. if (!same_descriptors) {
  3301. /* digests don't match; The sdmap_set above didn't replace */
  3302. sdmap_remove(rl->desc_digest_map,
  3303. ri_old->cache_info.signed_descriptor_digest);
  3304. if (tor_memneq(ri_old->cache_info.extra_info_digest,
  3305. ri_new->cache_info.extra_info_digest, DIGEST_LEN)) {
  3306. ei_tmp = eimap_remove(rl->extra_info_map,
  3307. ri_old->cache_info.extra_info_digest);
  3308. if (ei_tmp) {
  3309. rl->extrainfo_store.bytes_dropped +=
  3310. ei_tmp->cache_info.signed_descriptor_len;
  3311. extrainfo_free(ei_tmp);
  3312. }
  3313. }
  3314. if (!tor_digest_is_zero(ri_old->cache_info.extra_info_digest)) {
  3315. sdmap_remove(rl->desc_by_eid_map,
  3316. ri_old->cache_info.extra_info_digest);
  3317. }
  3318. }
  3319. rl->desc_store.bytes_dropped += ri_old->cache_info.signed_descriptor_len;
  3320. routerinfo_free(ri_old);
  3321. }
  3322. #ifdef DEBUG_ROUTERLIST
  3323. routerlist_assert_ok(rl);
  3324. #endif
  3325. }
  3326. /** Extract the descriptor <b>sd</b> from old_routerlist, and re-parse
  3327. * it as a fresh routerinfo_t. */
  3328. static routerinfo_t *
  3329. routerlist_reparse_old(routerlist_t *rl, signed_descriptor_t *sd)
  3330. {
  3331. routerinfo_t *ri;
  3332. const char *body;
  3333. body = signed_descriptor_get_annotations(sd);
  3334. ri = router_parse_entry_from_string(body,
  3335. body+sd->signed_descriptor_len+sd->annotations_len,
  3336. 0, 1, NULL, NULL);
  3337. if (!ri)
  3338. return NULL;
  3339. signed_descriptor_move(&ri->cache_info, sd);
  3340. routerlist_remove_old(rl, sd, -1);
  3341. return ri;
  3342. }
  3343. /** Free all memory held by the routerlist module.
  3344. * Note: Calling routerlist_free_all() should always be paired with
  3345. * a call to nodelist_free_all(). These should only be called during
  3346. * cleanup.
  3347. */
  3348. void
  3349. routerlist_free_all(void)
  3350. {
  3351. routerlist_free(routerlist);
  3352. routerlist = NULL;
  3353. if (warned_nicknames) {
  3354. SMARTLIST_FOREACH(warned_nicknames, char *, cp, tor_free(cp));
  3355. smartlist_free(warned_nicknames);
  3356. warned_nicknames = NULL;
  3357. }
  3358. clear_dir_servers();
  3359. smartlist_free(trusted_dir_servers);
  3360. smartlist_free(fallback_dir_servers);
  3361. trusted_dir_servers = fallback_dir_servers = NULL;
  3362. if (trusted_dir_certs) {
  3363. digestmap_free(trusted_dir_certs, cert_list_free_void);
  3364. trusted_dir_certs = NULL;
  3365. }
  3366. }
  3367. /** Forget that we have issued any router-related warnings, so that we'll
  3368. * warn again if we see the same errors. */
  3369. void
  3370. routerlist_reset_warnings(void)
  3371. {
  3372. if (!warned_nicknames)
  3373. warned_nicknames = smartlist_new();
  3374. SMARTLIST_FOREACH(warned_nicknames, char *, cp, tor_free(cp));
  3375. smartlist_clear(warned_nicknames); /* now the list is empty. */
  3376. networkstatus_reset_warnings();
  3377. }
  3378. /** Return 1 if the signed descriptor of this router is older than
  3379. * <b>seconds</b> seconds. Otherwise return 0. */
  3380. MOCK_IMPL(int,
  3381. router_descriptor_is_older_than,(const routerinfo_t *router, int seconds))
  3382. {
  3383. return router->cache_info.published_on < approx_time() - seconds;
  3384. }
  3385. /** Add <b>router</b> to the routerlist, if we don't already have it. Replace
  3386. * older entries (if any) with the same key. Note: Callers should not hold
  3387. * their pointers to <b>router</b> if this function fails; <b>router</b>
  3388. * will either be inserted into the routerlist or freed. Similarly, even
  3389. * if this call succeeds, they should not hold their pointers to
  3390. * <b>router</b> after subsequent calls with other routerinfo's -- they
  3391. * might cause the original routerinfo to get freed.
  3392. *
  3393. * Returns the status for the operation. Might set *<b>msg</b> if it wants
  3394. * the poster of the router to know something.
  3395. *
  3396. * If <b>from_cache</b>, this descriptor came from our disk cache. If
  3397. * <b>from_fetch</b>, we received it in response to a request we made.
  3398. * (If both are false, that means it was uploaded to us as an auth dir
  3399. * server or via the controller.)
  3400. *
  3401. * This function should be called *after*
  3402. * routers_update_status_from_consensus_networkstatus; subsequently, you
  3403. * should call router_rebuild_store and routerlist_descriptors_added.
  3404. */
  3405. was_router_added_t
  3406. router_add_to_routerlist(routerinfo_t *router, const char **msg,
  3407. int from_cache, int from_fetch)
  3408. {
  3409. const char *id_digest;
  3410. const or_options_t *options = get_options();
  3411. int authdir = authdir_mode_handles_descs(options, router->purpose);
  3412. int authdir_believes_valid = 0;
  3413. routerinfo_t *old_router;
  3414. networkstatus_t *consensus =
  3415. networkstatus_get_latest_consensus_by_flavor(FLAV_NS);
  3416. int in_consensus = 0;
  3417. tor_assert(msg);
  3418. if (!routerlist)
  3419. router_get_routerlist();
  3420. id_digest = router->cache_info.identity_digest;
  3421. old_router = router_get_mutable_by_digest(id_digest);
  3422. /* Make sure that it isn't expired. */
  3423. if (router->cert_expiration_time < approx_time()) {
  3424. routerinfo_free(router);
  3425. *msg = "Some certs on this router are expired.";
  3426. return ROUTER_CERTS_EXPIRED;
  3427. }
  3428. /* Make sure that we haven't already got this exact descriptor. */
  3429. if (sdmap_get(routerlist->desc_digest_map,
  3430. router->cache_info.signed_descriptor_digest)) {
  3431. /* If we have this descriptor already and the new descriptor is a bridge
  3432. * descriptor, replace it. If we had a bridge descriptor before and the
  3433. * new one is not a bridge descriptor, don't replace it. */
  3434. /* Only members of routerlist->identity_map can be bridges; we don't
  3435. * put bridges in old_routers. */
  3436. const int was_bridge = old_router &&
  3437. old_router->purpose == ROUTER_PURPOSE_BRIDGE;
  3438. if (routerinfo_is_a_configured_bridge(router) &&
  3439. router->purpose == ROUTER_PURPOSE_BRIDGE &&
  3440. !was_bridge) {
  3441. log_info(LD_DIR, "Replacing non-bridge descriptor with bridge "
  3442. "descriptor for router %s",
  3443. router_describe(router));
  3444. } else {
  3445. log_info(LD_DIR,
  3446. "Dropping descriptor that we already have for router %s",
  3447. router_describe(router));
  3448. *msg = "Router descriptor was not new.";
  3449. routerinfo_free(router);
  3450. return ROUTER_IS_ALREADY_KNOWN;
  3451. }
  3452. }
  3453. if (authdir) {
  3454. if (authdir_wants_to_reject_router(router, msg,
  3455. !from_cache && !from_fetch,
  3456. &authdir_believes_valid)) {
  3457. tor_assert(*msg);
  3458. routerinfo_free(router);
  3459. return ROUTER_AUTHDIR_REJECTS;
  3460. }
  3461. } else if (from_fetch) {
  3462. /* Only check the descriptor digest against the network statuses when
  3463. * we are receiving in response to a fetch. */
  3464. if (!signed_desc_digest_is_recognized(&router->cache_info) &&
  3465. !routerinfo_is_a_configured_bridge(router)) {
  3466. /* We asked for it, so some networkstatus must have listed it when we
  3467. * did. Save it if we're a cache in case somebody else asks for it. */
  3468. log_info(LD_DIR,
  3469. "Received a no-longer-recognized descriptor for router %s",
  3470. router_describe(router));
  3471. *msg = "Router descriptor is not referenced by any network-status.";
  3472. /* Only journal this desc if we want to keep old descriptors */
  3473. if (!from_cache && should_cache_old_descriptors())
  3474. signed_desc_append_to_journal(&router->cache_info,
  3475. &routerlist->desc_store);
  3476. routerlist_insert_old(routerlist, router);
  3477. return ROUTER_NOT_IN_CONSENSUS_OR_NETWORKSTATUS;
  3478. }
  3479. }
  3480. /* We no longer need a router with this descriptor digest. */
  3481. if (consensus) {
  3482. routerstatus_t *rs = networkstatus_vote_find_mutable_entry(
  3483. consensus, id_digest);
  3484. if (rs && tor_memeq(rs->descriptor_digest,
  3485. router->cache_info.signed_descriptor_digest,
  3486. DIGEST_LEN)) {
  3487. in_consensus = 1;
  3488. }
  3489. }
  3490. if (router->purpose == ROUTER_PURPOSE_GENERAL &&
  3491. consensus && !in_consensus && !authdir) {
  3492. /* If it's a general router not listed in the consensus, then don't
  3493. * consider replacing the latest router with it. */
  3494. if (!from_cache && should_cache_old_descriptors())
  3495. signed_desc_append_to_journal(&router->cache_info,
  3496. &routerlist->desc_store);
  3497. routerlist_insert_old(routerlist, router);
  3498. *msg = "Skipping router descriptor: not in consensus.";
  3499. return ROUTER_NOT_IN_CONSENSUS;
  3500. }
  3501. /* If we're reading a bridge descriptor from our cache, and we don't
  3502. * recognize it as one of our currently configured bridges, drop the
  3503. * descriptor. Otherwise we could end up using it as one of our entry
  3504. * guards even if it isn't in our Bridge config lines. */
  3505. if (router->purpose == ROUTER_PURPOSE_BRIDGE && from_cache &&
  3506. !authdir_mode_bridge(options) &&
  3507. !routerinfo_is_a_configured_bridge(router)) {
  3508. log_info(LD_DIR, "Dropping bridge descriptor for %s because we have "
  3509. "no bridge configured at that address.",
  3510. safe_str_client(router_describe(router)));
  3511. *msg = "Router descriptor was not a configured bridge.";
  3512. routerinfo_free(router);
  3513. return ROUTER_WAS_NOT_WANTED;
  3514. }
  3515. /* If we have a router with the same identity key, choose the newer one. */
  3516. if (old_router) {
  3517. if (!in_consensus && (router->cache_info.published_on <=
  3518. old_router->cache_info.published_on)) {
  3519. /* Same key, but old. This one is not listed in the consensus. */
  3520. log_debug(LD_DIR, "Not-new descriptor for router %s",
  3521. router_describe(router));
  3522. /* Only journal this desc if we'll be serving it. */
  3523. if (!from_cache && should_cache_old_descriptors())
  3524. signed_desc_append_to_journal(&router->cache_info,
  3525. &routerlist->desc_store);
  3526. routerlist_insert_old(routerlist, router);
  3527. *msg = "Router descriptor was not new.";
  3528. return ROUTER_IS_ALREADY_KNOWN;
  3529. } else {
  3530. /* Same key, and either new, or listed in the consensus. */
  3531. log_debug(LD_DIR, "Replacing entry for router %s",
  3532. router_describe(router));
  3533. routerlist_replace(routerlist, old_router, router);
  3534. if (!from_cache) {
  3535. signed_desc_append_to_journal(&router->cache_info,
  3536. &routerlist->desc_store);
  3537. }
  3538. *msg = authdir_believes_valid ? "Valid server updated" :
  3539. ("Invalid server updated. (This dirserver is marking your "
  3540. "server as unapproved.)");
  3541. return ROUTER_ADDED_SUCCESSFULLY;
  3542. }
  3543. }
  3544. if (!in_consensus && from_cache &&
  3545. router_descriptor_is_older_than(router, OLD_ROUTER_DESC_MAX_AGE)) {
  3546. *msg = "Router descriptor was really old.";
  3547. routerinfo_free(router);
  3548. return ROUTER_WAS_TOO_OLD;
  3549. }
  3550. /* We haven't seen a router with this identity before. Add it to the end of
  3551. * the list. */
  3552. routerlist_insert(routerlist, router);
  3553. if (!from_cache) {
  3554. signed_desc_append_to_journal(&router->cache_info,
  3555. &routerlist->desc_store);
  3556. }
  3557. return ROUTER_ADDED_SUCCESSFULLY;
  3558. }
  3559. /** Insert <b>ei</b> into the routerlist, or free it. Other arguments are
  3560. * as for router_add_to_routerlist(). Return ROUTER_ADDED_SUCCESSFULLY iff
  3561. * we actually inserted it, ROUTER_BAD_EI otherwise.
  3562. */
  3563. was_router_added_t
  3564. router_add_extrainfo_to_routerlist(extrainfo_t *ei, const char **msg,
  3565. int from_cache, int from_fetch)
  3566. {
  3567. was_router_added_t inserted;
  3568. (void)from_fetch;
  3569. if (msg) *msg = NULL;
  3570. /*XXXX Do something with msg */
  3571. inserted = extrainfo_insert(router_get_routerlist(), ei, !from_cache);
  3572. if (WRA_WAS_ADDED(inserted) && !from_cache)
  3573. signed_desc_append_to_journal(&ei->cache_info,
  3574. &routerlist->extrainfo_store);
  3575. return inserted;
  3576. }
  3577. /** Sorting helper: return &lt;0, 0, or &gt;0 depending on whether the
  3578. * signed_descriptor_t* in *<b>a</b> has an identity digest preceding, equal
  3579. * to, or later than that of *<b>b</b>. */
  3580. static int
  3581. compare_old_routers_by_identity_(const void **_a, const void **_b)
  3582. {
  3583. int i;
  3584. const signed_descriptor_t *r1 = *_a, *r2 = *_b;
  3585. if ((i = fast_memcmp(r1->identity_digest, r2->identity_digest, DIGEST_LEN)))
  3586. return i;
  3587. return (int)(r1->published_on - r2->published_on);
  3588. }
  3589. /** Internal type used to represent how long an old descriptor was valid,
  3590. * where it appeared in the list of old descriptors, and whether it's extra
  3591. * old. Used only by routerlist_remove_old_cached_routers_with_id(). */
  3592. struct duration_idx_t {
  3593. int duration;
  3594. int idx;
  3595. int old;
  3596. };
  3597. /** Sorting helper: compare two duration_idx_t by their duration. */
  3598. static int
  3599. compare_duration_idx_(const void *_d1, const void *_d2)
  3600. {
  3601. const struct duration_idx_t *d1 = _d1;
  3602. const struct duration_idx_t *d2 = _d2;
  3603. return d1->duration - d2->duration;
  3604. }
  3605. /** The range <b>lo</b> through <b>hi</b> inclusive of routerlist->old_routers
  3606. * must contain routerinfo_t with the same identity and with publication time
  3607. * in ascending order. Remove members from this range until there are no more
  3608. * than max_descriptors_per_router() remaining. Start by removing the oldest
  3609. * members from before <b>cutoff</b>, then remove members which were current
  3610. * for the lowest amount of time. The order of members of old_routers at
  3611. * indices <b>lo</b> or higher may be changed.
  3612. */
  3613. static void
  3614. routerlist_remove_old_cached_routers_with_id(time_t now,
  3615. time_t cutoff, int lo, int hi,
  3616. digestset_t *retain)
  3617. {
  3618. int i, n = hi-lo+1;
  3619. unsigned n_extra, n_rmv = 0;
  3620. struct duration_idx_t *lifespans;
  3621. uint8_t *rmv, *must_keep;
  3622. smartlist_t *lst = routerlist->old_routers;
  3623. #if 1
  3624. const char *ident;
  3625. tor_assert(hi < smartlist_len(lst));
  3626. tor_assert(lo <= hi);
  3627. ident = ((signed_descriptor_t*)smartlist_get(lst, lo))->identity_digest;
  3628. for (i = lo+1; i <= hi; ++i) {
  3629. signed_descriptor_t *r = smartlist_get(lst, i);
  3630. tor_assert(tor_memeq(ident, r->identity_digest, DIGEST_LEN));
  3631. }
  3632. #endif /* 1 */
  3633. /* Check whether we need to do anything at all. */
  3634. {
  3635. int mdpr = directory_caches_dir_info(get_options()) ? 2 : 1;
  3636. if (n <= mdpr)
  3637. return;
  3638. n_extra = n - mdpr;
  3639. }
  3640. lifespans = tor_calloc(n, sizeof(struct duration_idx_t));
  3641. rmv = tor_calloc(n, sizeof(uint8_t));
  3642. must_keep = tor_calloc(n, sizeof(uint8_t));
  3643. /* Set lifespans to contain the lifespan and index of each server. */
  3644. /* Set rmv[i-lo]=1 if we're going to remove a server for being too old. */
  3645. for (i = lo; i <= hi; ++i) {
  3646. signed_descriptor_t *r = smartlist_get(lst, i);
  3647. signed_descriptor_t *r_next;
  3648. lifespans[i-lo].idx = i;
  3649. if (r->last_listed_as_valid_until >= now ||
  3650. (retain && digestset_contains(retain, r->signed_descriptor_digest))) {
  3651. must_keep[i-lo] = 1;
  3652. }
  3653. if (i < hi) {
  3654. r_next = smartlist_get(lst, i+1);
  3655. tor_assert(r->published_on <= r_next->published_on);
  3656. lifespans[i-lo].duration = (int)(r_next->published_on - r->published_on);
  3657. } else {
  3658. r_next = NULL;
  3659. lifespans[i-lo].duration = INT_MAX;
  3660. }
  3661. if (!must_keep[i-lo] && r->published_on < cutoff && n_rmv < n_extra) {
  3662. ++n_rmv;
  3663. lifespans[i-lo].old = 1;
  3664. rmv[i-lo] = 1;
  3665. }
  3666. }
  3667. if (n_rmv < n_extra) {
  3668. /**
  3669. * We aren't removing enough servers for being old. Sort lifespans by
  3670. * the duration of liveness, and remove the ones we're not already going to
  3671. * remove based on how long they were alive.
  3672. **/
  3673. qsort(lifespans, n, sizeof(struct duration_idx_t), compare_duration_idx_);
  3674. for (i = 0; i < n && n_rmv < n_extra; ++i) {
  3675. if (!must_keep[lifespans[i].idx-lo] && !lifespans[i].old) {
  3676. rmv[lifespans[i].idx-lo] = 1;
  3677. ++n_rmv;
  3678. }
  3679. }
  3680. }
  3681. i = hi;
  3682. do {
  3683. if (rmv[i-lo])
  3684. routerlist_remove_old(routerlist, smartlist_get(lst, i), i);
  3685. } while (--i >= lo);
  3686. tor_free(must_keep);
  3687. tor_free(rmv);
  3688. tor_free(lifespans);
  3689. }
  3690. /** Deactivate any routers from the routerlist that are more than
  3691. * ROUTER_MAX_AGE seconds old and not recommended by any networkstatuses;
  3692. * remove old routers from the list of cached routers if we have too many.
  3693. */
  3694. void
  3695. routerlist_remove_old_routers(void)
  3696. {
  3697. int i, hi=-1;
  3698. const char *cur_id = NULL;
  3699. time_t now = time(NULL);
  3700. time_t cutoff;
  3701. routerinfo_t *router;
  3702. signed_descriptor_t *sd;
  3703. digestset_t *retain;
  3704. const networkstatus_t *consensus = networkstatus_get_latest_consensus();
  3705. trusted_dirs_remove_old_certs();
  3706. if (!routerlist || !consensus)
  3707. return;
  3708. // routerlist_assert_ok(routerlist);
  3709. /* We need to guess how many router descriptors we will wind up wanting to
  3710. retain, so that we can be sure to allocate a large enough Bloom filter
  3711. to hold the digest set. Overestimating is fine; underestimating is bad.
  3712. */
  3713. {
  3714. /* We'll probably retain everything in the consensus. */
  3715. int n_max_retain = smartlist_len(consensus->routerstatus_list);
  3716. retain = digestset_new(n_max_retain);
  3717. }
  3718. cutoff = now - OLD_ROUTER_DESC_MAX_AGE;
  3719. /* Retain anything listed in the consensus. */
  3720. if (consensus) {
  3721. SMARTLIST_FOREACH(consensus->routerstatus_list, routerstatus_t *, rs,
  3722. if (rs->published_on >= cutoff)
  3723. digestset_add(retain, rs->descriptor_digest));
  3724. }
  3725. /* If we have a consensus, we should consider pruning current routers that
  3726. * are too old and that nobody recommends. (If we don't have a consensus,
  3727. * then we should get one before we decide to kill routers.) */
  3728. if (consensus) {
  3729. cutoff = now - ROUTER_MAX_AGE;
  3730. /* Remove too-old unrecommended members of routerlist->routers. */
  3731. for (i = 0; i < smartlist_len(routerlist->routers); ++i) {
  3732. router = smartlist_get(routerlist->routers, i);
  3733. if (router->cache_info.published_on <= cutoff &&
  3734. router->cache_info.last_listed_as_valid_until < now &&
  3735. !digestset_contains(retain,
  3736. router->cache_info.signed_descriptor_digest)) {
  3737. /* Too old: remove it. (If we're a cache, just move it into
  3738. * old_routers.) */
  3739. log_info(LD_DIR,
  3740. "Forgetting obsolete (too old) routerinfo for router %s",
  3741. router_describe(router));
  3742. routerlist_remove(routerlist, router, 1, now);
  3743. i--;
  3744. }
  3745. }
  3746. }
  3747. //routerlist_assert_ok(routerlist);
  3748. /* Remove far-too-old members of routerlist->old_routers. */
  3749. cutoff = now - OLD_ROUTER_DESC_MAX_AGE;
  3750. for (i = 0; i < smartlist_len(routerlist->old_routers); ++i) {
  3751. sd = smartlist_get(routerlist->old_routers, i);
  3752. if (sd->published_on <= cutoff &&
  3753. sd->last_listed_as_valid_until < now &&
  3754. !digestset_contains(retain, sd->signed_descriptor_digest)) {
  3755. /* Too old. Remove it. */
  3756. routerlist_remove_old(routerlist, sd, i--);
  3757. }
  3758. }
  3759. //routerlist_assert_ok(routerlist);
  3760. log_info(LD_DIR, "We have %d live routers and %d old router descriptors.",
  3761. smartlist_len(routerlist->routers),
  3762. smartlist_len(routerlist->old_routers));
  3763. /* Now we might have to look at routerlist->old_routers for extraneous
  3764. * members. (We'd keep all the members if we could, but we need to save
  3765. * space.) First, check whether we have too many router descriptors, total.
  3766. * We're okay with having too many for some given router, so long as the
  3767. * total number doesn't approach max_descriptors_per_router()*len(router).
  3768. */
  3769. if (smartlist_len(routerlist->old_routers) <
  3770. smartlist_len(routerlist->routers))
  3771. goto done;
  3772. /* Sort by identity, then fix indices. */
  3773. smartlist_sort(routerlist->old_routers, compare_old_routers_by_identity_);
  3774. /* Fix indices. */
  3775. for (i = 0; i < smartlist_len(routerlist->old_routers); ++i) {
  3776. signed_descriptor_t *r = smartlist_get(routerlist->old_routers, i);
  3777. r->routerlist_index = i;
  3778. }
  3779. /* Iterate through the list from back to front, so when we remove descriptors
  3780. * we don't mess up groups we haven't gotten to. */
  3781. for (i = smartlist_len(routerlist->old_routers)-1; i >= 0; --i) {
  3782. signed_descriptor_t *r = smartlist_get(routerlist->old_routers, i);
  3783. if (!cur_id) {
  3784. cur_id = r->identity_digest;
  3785. hi = i;
  3786. }
  3787. if (tor_memneq(cur_id, r->identity_digest, DIGEST_LEN)) {
  3788. routerlist_remove_old_cached_routers_with_id(now,
  3789. cutoff, i+1, hi, retain);
  3790. cur_id = r->identity_digest;
  3791. hi = i;
  3792. }
  3793. }
  3794. if (hi>=0)
  3795. routerlist_remove_old_cached_routers_with_id(now, cutoff, 0, hi, retain);
  3796. //routerlist_assert_ok(routerlist);
  3797. done:
  3798. digestset_free(retain);
  3799. router_rebuild_store(RRS_DONT_REMOVE_OLD, &routerlist->desc_store);
  3800. router_rebuild_store(RRS_DONT_REMOVE_OLD,&routerlist->extrainfo_store);
  3801. }
  3802. /** We just added a new set of descriptors. Take whatever extra steps
  3803. * we need. */
  3804. void
  3805. routerlist_descriptors_added(smartlist_t *sl, int from_cache)
  3806. {
  3807. tor_assert(sl);
  3808. control_event_descriptors_changed(sl);
  3809. SMARTLIST_FOREACH_BEGIN(sl, routerinfo_t *, ri) {
  3810. if (ri->purpose == ROUTER_PURPOSE_BRIDGE)
  3811. learned_bridge_descriptor(ri, from_cache);
  3812. if (ri->needs_retest_if_added) {
  3813. ri->needs_retest_if_added = 0;
  3814. dirserv_single_reachability_test(approx_time(), ri);
  3815. }
  3816. } SMARTLIST_FOREACH_END(ri);
  3817. }
  3818. /**
  3819. * Code to parse a single router descriptor and insert it into the
  3820. * routerlist. Return -1 if the descriptor was ill-formed; 0 if the
  3821. * descriptor was well-formed but could not be added; and 1 if the
  3822. * descriptor was added.
  3823. *
  3824. * If we don't add it and <b>msg</b> is not NULL, then assign to
  3825. * *<b>msg</b> a static string describing the reason for refusing the
  3826. * descriptor.
  3827. *
  3828. * This is used only by the controller.
  3829. */
  3830. int
  3831. router_load_single_router(const char *s, uint8_t purpose, int cache,
  3832. const char **msg)
  3833. {
  3834. routerinfo_t *ri;
  3835. was_router_added_t r;
  3836. smartlist_t *lst;
  3837. char annotation_buf[ROUTER_ANNOTATION_BUF_LEN];
  3838. tor_assert(msg);
  3839. *msg = NULL;
  3840. tor_snprintf(annotation_buf, sizeof(annotation_buf),
  3841. "@source controller\n"
  3842. "@purpose %s\n", router_purpose_to_string(purpose));
  3843. if (!(ri = router_parse_entry_from_string(s, NULL, 1, 0,
  3844. annotation_buf, NULL))) {
  3845. log_warn(LD_DIR, "Error parsing router descriptor; dropping.");
  3846. *msg = "Couldn't parse router descriptor.";
  3847. return -1;
  3848. }
  3849. tor_assert(ri->purpose == purpose);
  3850. if (router_is_me(ri)) {
  3851. log_warn(LD_DIR, "Router's identity key matches mine; dropping.");
  3852. *msg = "Router's identity key matches mine.";
  3853. routerinfo_free(ri);
  3854. return 0;
  3855. }
  3856. if (!cache) /* obey the preference of the controller */
  3857. ri->cache_info.do_not_cache = 1;
  3858. lst = smartlist_new();
  3859. smartlist_add(lst, ri);
  3860. routers_update_status_from_consensus_networkstatus(lst, 0);
  3861. r = router_add_to_routerlist(ri, msg, 0, 0);
  3862. if (!WRA_WAS_ADDED(r)) {
  3863. /* we've already assigned to *msg now, and ri is already freed */
  3864. tor_assert(*msg);
  3865. if (r == ROUTER_AUTHDIR_REJECTS)
  3866. log_warn(LD_DIR, "Couldn't add router to list: %s Dropping.", *msg);
  3867. smartlist_free(lst);
  3868. return 0;
  3869. } else {
  3870. routerlist_descriptors_added(lst, 0);
  3871. smartlist_free(lst);
  3872. log_debug(LD_DIR, "Added router to list");
  3873. return 1;
  3874. }
  3875. }
  3876. /** Given a string <b>s</b> containing some routerdescs, parse it and put the
  3877. * routers into our directory. If saved_location is SAVED_NOWHERE, the routers
  3878. * are in response to a query to the network: cache them by adding them to
  3879. * the journal.
  3880. *
  3881. * Return the number of routers actually added.
  3882. *
  3883. * If <b>requested_fingerprints</b> is provided, it must contain a list of
  3884. * uppercased fingerprints. Do not update any router whose
  3885. * fingerprint is not on the list; after updating a router, remove its
  3886. * fingerprint from the list.
  3887. *
  3888. * If <b>descriptor_digests</b> is non-zero, then the requested_fingerprints
  3889. * are descriptor digests. Otherwise they are identity digests.
  3890. */
  3891. int
  3892. router_load_routers_from_string(const char *s, const char *eos,
  3893. saved_location_t saved_location,
  3894. smartlist_t *requested_fingerprints,
  3895. int descriptor_digests,
  3896. const char *prepend_annotations)
  3897. {
  3898. smartlist_t *routers = smartlist_new(), *changed = smartlist_new();
  3899. char fp[HEX_DIGEST_LEN+1];
  3900. const char *msg;
  3901. int from_cache = (saved_location != SAVED_NOWHERE);
  3902. int allow_annotations = (saved_location != SAVED_NOWHERE);
  3903. int any_changed = 0;
  3904. smartlist_t *invalid_digests = smartlist_new();
  3905. router_parse_list_from_string(&s, eos, routers, saved_location, 0,
  3906. allow_annotations, prepend_annotations,
  3907. invalid_digests);
  3908. routers_update_status_from_consensus_networkstatus(routers, !from_cache);
  3909. log_info(LD_DIR, "%d elements to add", smartlist_len(routers));
  3910. SMARTLIST_FOREACH_BEGIN(routers, routerinfo_t *, ri) {
  3911. was_router_added_t r;
  3912. char d[DIGEST_LEN];
  3913. if (requested_fingerprints) {
  3914. base16_encode(fp, sizeof(fp), descriptor_digests ?
  3915. ri->cache_info.signed_descriptor_digest :
  3916. ri->cache_info.identity_digest,
  3917. DIGEST_LEN);
  3918. if (smartlist_contains_string(requested_fingerprints, fp)) {
  3919. smartlist_string_remove(requested_fingerprints, fp);
  3920. } else {
  3921. char *requested =
  3922. smartlist_join_strings(requested_fingerprints," ",0,NULL);
  3923. log_warn(LD_DIR,
  3924. "We received a router descriptor with a fingerprint (%s) "
  3925. "that we never requested. (We asked for: %s.) Dropping.",
  3926. fp, requested);
  3927. tor_free(requested);
  3928. routerinfo_free(ri);
  3929. continue;
  3930. }
  3931. }
  3932. memcpy(d, ri->cache_info.signed_descriptor_digest, DIGEST_LEN);
  3933. r = router_add_to_routerlist(ri, &msg, from_cache, !from_cache);
  3934. if (WRA_WAS_ADDED(r)) {
  3935. any_changed++;
  3936. smartlist_add(changed, ri);
  3937. routerlist_descriptors_added(changed, from_cache);
  3938. smartlist_clear(changed);
  3939. } else if (WRA_NEVER_DOWNLOADABLE(r)) {
  3940. download_status_t *dl_status;
  3941. dl_status = router_get_dl_status_by_descriptor_digest(d);
  3942. if (dl_status) {
  3943. log_info(LD_GENERAL, "Marking router %s as never downloadable",
  3944. hex_str(d, DIGEST_LEN));
  3945. download_status_mark_impossible(dl_status);
  3946. }
  3947. }
  3948. } SMARTLIST_FOREACH_END(ri);
  3949. SMARTLIST_FOREACH_BEGIN(invalid_digests, const uint8_t *, bad_digest) {
  3950. /* This digest is never going to be parseable. */
  3951. base16_encode(fp, sizeof(fp), (char*)bad_digest, DIGEST_LEN);
  3952. if (requested_fingerprints && descriptor_digests) {
  3953. if (! smartlist_contains_string(requested_fingerprints, fp)) {
  3954. /* But we didn't ask for it, so we should assume shennanegans. */
  3955. continue;
  3956. }
  3957. smartlist_string_remove(requested_fingerprints, fp);
  3958. }
  3959. download_status_t *dls;
  3960. dls = router_get_dl_status_by_descriptor_digest((char*)bad_digest);
  3961. if (dls) {
  3962. log_info(LD_GENERAL, "Marking router with descriptor %s as unparseable, "
  3963. "and therefore undownloadable", fp);
  3964. download_status_mark_impossible(dls);
  3965. }
  3966. } SMARTLIST_FOREACH_END(bad_digest);
  3967. SMARTLIST_FOREACH(invalid_digests, uint8_t *, d, tor_free(d));
  3968. smartlist_free(invalid_digests);
  3969. routerlist_assert_ok(routerlist);
  3970. if (any_changed)
  3971. router_rebuild_store(0, &routerlist->desc_store);
  3972. smartlist_free(routers);
  3973. smartlist_free(changed);
  3974. return any_changed;
  3975. }
  3976. /** Parse one or more extrainfos from <b>s</b> (ending immediately before
  3977. * <b>eos</b> if <b>eos</b> is present). Other arguments are as for
  3978. * router_load_routers_from_string(). */
  3979. void
  3980. router_load_extrainfo_from_string(const char *s, const char *eos,
  3981. saved_location_t saved_location,
  3982. smartlist_t *requested_fingerprints,
  3983. int descriptor_digests)
  3984. {
  3985. smartlist_t *extrainfo_list = smartlist_new();
  3986. const char *msg;
  3987. int from_cache = (saved_location != SAVED_NOWHERE);
  3988. smartlist_t *invalid_digests = smartlist_new();
  3989. router_parse_list_from_string(&s, eos, extrainfo_list, saved_location, 1, 0,
  3990. NULL, invalid_digests);
  3991. log_info(LD_DIR, "%d elements to add", smartlist_len(extrainfo_list));
  3992. SMARTLIST_FOREACH_BEGIN(extrainfo_list, extrainfo_t *, ei) {
  3993. uint8_t d[DIGEST_LEN];
  3994. memcpy(d, ei->cache_info.signed_descriptor_digest, DIGEST_LEN);
  3995. was_router_added_t added =
  3996. router_add_extrainfo_to_routerlist(ei, &msg, from_cache, !from_cache);
  3997. if (WRA_WAS_ADDED(added) && requested_fingerprints) {
  3998. char fp[HEX_DIGEST_LEN+1];
  3999. base16_encode(fp, sizeof(fp), descriptor_digests ?
  4000. ei->cache_info.signed_descriptor_digest :
  4001. ei->cache_info.identity_digest,
  4002. DIGEST_LEN);
  4003. smartlist_string_remove(requested_fingerprints, fp);
  4004. /* We silently let relays stuff us with extrainfos we didn't ask for,
  4005. * so long as we would have wanted them anyway. Since we always fetch
  4006. * all the extrainfos we want, and we never actually act on them
  4007. * inside Tor, this should be harmless. */
  4008. } else if (WRA_NEVER_DOWNLOADABLE(added)) {
  4009. signed_descriptor_t *sd = router_get_by_extrainfo_digest((char*)d);
  4010. if (sd) {
  4011. log_info(LD_GENERAL, "Marking extrainfo with descriptor %s as "
  4012. "unparseable, and therefore undownloadable",
  4013. hex_str((char*)d,DIGEST_LEN));
  4014. download_status_mark_impossible(&sd->ei_dl_status);
  4015. }
  4016. }
  4017. } SMARTLIST_FOREACH_END(ei);
  4018. SMARTLIST_FOREACH_BEGIN(invalid_digests, const uint8_t *, bad_digest) {
  4019. /* This digest is never going to be parseable. */
  4020. char fp[HEX_DIGEST_LEN+1];
  4021. base16_encode(fp, sizeof(fp), (char*)bad_digest, DIGEST_LEN);
  4022. if (requested_fingerprints) {
  4023. if (! smartlist_contains_string(requested_fingerprints, fp)) {
  4024. /* But we didn't ask for it, so we should assume shennanegans. */
  4025. continue;
  4026. }
  4027. smartlist_string_remove(requested_fingerprints, fp);
  4028. }
  4029. signed_descriptor_t *sd =
  4030. router_get_by_extrainfo_digest((char*)bad_digest);
  4031. if (sd) {
  4032. log_info(LD_GENERAL, "Marking extrainfo with descriptor %s as "
  4033. "unparseable, and therefore undownloadable", fp);
  4034. download_status_mark_impossible(&sd->ei_dl_status);
  4035. }
  4036. } SMARTLIST_FOREACH_END(bad_digest);
  4037. SMARTLIST_FOREACH(invalid_digests, uint8_t *, d, tor_free(d));
  4038. smartlist_free(invalid_digests);
  4039. routerlist_assert_ok(routerlist);
  4040. router_rebuild_store(0, &router_get_routerlist()->extrainfo_store);
  4041. smartlist_free(extrainfo_list);
  4042. }
  4043. /** Return true iff the latest ns-flavored consensus includes a descriptor
  4044. * whose digest is that of <b>desc</b>. */
  4045. static int
  4046. signed_desc_digest_is_recognized(signed_descriptor_t *desc)
  4047. {
  4048. const routerstatus_t *rs;
  4049. networkstatus_t *consensus = networkstatus_get_latest_consensus_by_flavor(
  4050. FLAV_NS);
  4051. if (consensus) {
  4052. rs = networkstatus_vote_find_entry(consensus, desc->identity_digest);
  4053. if (rs && tor_memeq(rs->descriptor_digest,
  4054. desc->signed_descriptor_digest, DIGEST_LEN))
  4055. return 1;
  4056. }
  4057. return 0;
  4058. }
  4059. /** Update downloads for router descriptors and/or microdescriptors as
  4060. * appropriate. */
  4061. void
  4062. update_all_descriptor_downloads(time_t now)
  4063. {
  4064. if (should_delay_dir_fetches(get_options(), NULL))
  4065. return;
  4066. update_router_descriptor_downloads(now);
  4067. update_microdesc_downloads(now);
  4068. launch_dummy_descriptor_download_as_needed(now, get_options());
  4069. }
  4070. /** Clear all our timeouts for fetching v3 directory stuff, and then
  4071. * give it all a try again. */
  4072. void
  4073. routerlist_retry_directory_downloads(time_t now)
  4074. {
  4075. (void)now;
  4076. log_debug(LD_GENERAL,
  4077. "In routerlist_retry_directory_downloads()");
  4078. router_reset_status_download_failures();
  4079. router_reset_descriptor_download_failures();
  4080. reschedule_directory_downloads();
  4081. }
  4082. /** Return true iff <b>router</b> does not permit exit streams.
  4083. */
  4084. int
  4085. router_exit_policy_rejects_all(const routerinfo_t *router)
  4086. {
  4087. return router->policy_is_reject_star;
  4088. }
  4089. /** Create a directory server at <b>address</b>:<b>port</b>, with OR identity
  4090. * key <b>digest</b> which has DIGEST_LEN bytes. If <b>address</b> is NULL,
  4091. * add ourself. If <b>is_authority</b>, this is a directory authority. Return
  4092. * the new directory server entry on success or NULL on failure. */
  4093. static dir_server_t *
  4094. dir_server_new(int is_authority,
  4095. const char *nickname,
  4096. const tor_addr_t *addr,
  4097. const char *hostname,
  4098. uint16_t dir_port, uint16_t or_port,
  4099. const tor_addr_port_t *addrport_ipv6,
  4100. const char *digest, const char *v3_auth_digest,
  4101. dirinfo_type_t type,
  4102. double weight)
  4103. {
  4104. dir_server_t *ent;
  4105. uint32_t a;
  4106. char *hostname_ = NULL;
  4107. tor_assert(digest);
  4108. if (weight < 0)
  4109. return NULL;
  4110. if (tor_addr_family(addr) == AF_INET)
  4111. a = tor_addr_to_ipv4h(addr);
  4112. else
  4113. return NULL;
  4114. if (!hostname)
  4115. hostname_ = tor_addr_to_str_dup(addr);
  4116. else
  4117. hostname_ = tor_strdup(hostname);
  4118. ent = tor_malloc_zero(sizeof(dir_server_t));
  4119. ent->nickname = nickname ? tor_strdup(nickname) : NULL;
  4120. ent->address = hostname_;
  4121. ent->addr = a;
  4122. ent->dir_port = dir_port;
  4123. ent->or_port = or_port;
  4124. ent->is_running = 1;
  4125. ent->is_authority = is_authority;
  4126. ent->type = type;
  4127. ent->weight = weight;
  4128. if (addrport_ipv6) {
  4129. if (tor_addr_family(&addrport_ipv6->addr) != AF_INET6) {
  4130. log_warn(LD_BUG, "Hey, I got a non-ipv6 addr as addrport_ipv6.");
  4131. tor_addr_make_unspec(&ent->ipv6_addr);
  4132. } else {
  4133. tor_addr_copy(&ent->ipv6_addr, &addrport_ipv6->addr);
  4134. ent->ipv6_orport = addrport_ipv6->port;
  4135. }
  4136. } else {
  4137. tor_addr_make_unspec(&ent->ipv6_addr);
  4138. }
  4139. memcpy(ent->digest, digest, DIGEST_LEN);
  4140. if (v3_auth_digest && (type & V3_DIRINFO))
  4141. memcpy(ent->v3_identity_digest, v3_auth_digest, DIGEST_LEN);
  4142. if (nickname)
  4143. tor_asprintf(&ent->description, "directory server \"%s\" at %s:%d",
  4144. nickname, hostname_, (int)dir_port);
  4145. else
  4146. tor_asprintf(&ent->description, "directory server at %s:%d",
  4147. hostname_, (int)dir_port);
  4148. ent->fake_status.addr = ent->addr;
  4149. tor_addr_copy(&ent->fake_status.ipv6_addr, &ent->ipv6_addr);
  4150. memcpy(ent->fake_status.identity_digest, digest, DIGEST_LEN);
  4151. if (nickname)
  4152. strlcpy(ent->fake_status.nickname, nickname,
  4153. sizeof(ent->fake_status.nickname));
  4154. else
  4155. ent->fake_status.nickname[0] = '\0';
  4156. ent->fake_status.dir_port = ent->dir_port;
  4157. ent->fake_status.or_port = ent->or_port;
  4158. ent->fake_status.ipv6_orport = ent->ipv6_orport;
  4159. return ent;
  4160. }
  4161. /** Create an authoritative directory server at
  4162. * <b>address</b>:<b>port</b>, with identity key <b>digest</b>. If
  4163. * <b>address</b> is NULL, add ourself. Return the new trusted directory
  4164. * server entry on success or NULL if we couldn't add it. */
  4165. dir_server_t *
  4166. trusted_dir_server_new(const char *nickname, const char *address,
  4167. uint16_t dir_port, uint16_t or_port,
  4168. const tor_addr_port_t *ipv6_addrport,
  4169. const char *digest, const char *v3_auth_digest,
  4170. dirinfo_type_t type, double weight)
  4171. {
  4172. uint32_t a;
  4173. tor_addr_t addr;
  4174. char *hostname=NULL;
  4175. dir_server_t *result;
  4176. if (!address) { /* The address is us; we should guess. */
  4177. if (resolve_my_address(LOG_WARN, get_options(),
  4178. &a, NULL, &hostname) < 0) {
  4179. log_warn(LD_CONFIG,
  4180. "Couldn't find a suitable address when adding ourself as a "
  4181. "trusted directory server.");
  4182. return NULL;
  4183. }
  4184. if (!hostname)
  4185. hostname = tor_dup_ip(a);
  4186. } else {
  4187. if (tor_lookup_hostname(address, &a)) {
  4188. log_warn(LD_CONFIG,
  4189. "Unable to lookup address for directory server at '%s'",
  4190. address);
  4191. return NULL;
  4192. }
  4193. hostname = tor_strdup(address);
  4194. }
  4195. tor_addr_from_ipv4h(&addr, a);
  4196. result = dir_server_new(1, nickname, &addr, hostname,
  4197. dir_port, or_port,
  4198. ipv6_addrport,
  4199. digest,
  4200. v3_auth_digest, type, weight);
  4201. tor_free(hostname);
  4202. return result;
  4203. }
  4204. /** Return a new dir_server_t for a fallback directory server at
  4205. * <b>addr</b>:<b>or_port</b>/<b>dir_port</b>, with identity key digest
  4206. * <b>id_digest</b> */
  4207. dir_server_t *
  4208. fallback_dir_server_new(const tor_addr_t *addr,
  4209. uint16_t dir_port, uint16_t or_port,
  4210. const tor_addr_port_t *addrport_ipv6,
  4211. const char *id_digest, double weight)
  4212. {
  4213. return dir_server_new(0, NULL, addr, NULL, dir_port, or_port,
  4214. addrport_ipv6,
  4215. id_digest,
  4216. NULL, ALL_DIRINFO, weight);
  4217. }
  4218. /** Add a directory server to the global list(s). */
  4219. void
  4220. dir_server_add(dir_server_t *ent)
  4221. {
  4222. if (!trusted_dir_servers)
  4223. trusted_dir_servers = smartlist_new();
  4224. if (!fallback_dir_servers)
  4225. fallback_dir_servers = smartlist_new();
  4226. if (ent->is_authority)
  4227. smartlist_add(trusted_dir_servers, ent);
  4228. smartlist_add(fallback_dir_servers, ent);
  4229. router_dir_info_changed();
  4230. }
  4231. /** Free storage held in <b>cert</b>. */
  4232. void
  4233. authority_cert_free_(authority_cert_t *cert)
  4234. {
  4235. if (!cert)
  4236. return;
  4237. tor_free(cert->cache_info.signed_descriptor_body);
  4238. crypto_pk_free(cert->signing_key);
  4239. crypto_pk_free(cert->identity_key);
  4240. tor_free(cert);
  4241. }
  4242. #define dir_server_free(val) \
  4243. FREE_AND_NULL(dir_server_t, dir_server_free_, (val))
  4244. /** Free storage held in <b>ds</b>. */
  4245. static void
  4246. dir_server_free_(dir_server_t *ds)
  4247. {
  4248. if (!ds)
  4249. return;
  4250. tor_free(ds->nickname);
  4251. tor_free(ds->description);
  4252. tor_free(ds->address);
  4253. tor_free(ds);
  4254. }
  4255. /** Remove all members from the list of dir servers. */
  4256. void
  4257. clear_dir_servers(void)
  4258. {
  4259. if (fallback_dir_servers) {
  4260. SMARTLIST_FOREACH(fallback_dir_servers, dir_server_t *, ent,
  4261. dir_server_free(ent));
  4262. smartlist_clear(fallback_dir_servers);
  4263. } else {
  4264. fallback_dir_servers = smartlist_new();
  4265. }
  4266. if (trusted_dir_servers) {
  4267. smartlist_clear(trusted_dir_servers);
  4268. } else {
  4269. trusted_dir_servers = smartlist_new();
  4270. }
  4271. router_dir_info_changed();
  4272. }
  4273. /** For every current directory connection whose purpose is <b>purpose</b>,
  4274. * and where the resource being downloaded begins with <b>prefix</b>, split
  4275. * rest of the resource into base16 fingerprints (or base64 fingerprints if
  4276. * purpose==DIR_PURPOSE_FETCH_MICRODESC), decode them, and set the
  4277. * corresponding elements of <b>result</b> to a nonzero value.
  4278. */
  4279. static void
  4280. list_pending_downloads(digestmap_t *result, digest256map_t *result256,
  4281. int purpose, const char *prefix)
  4282. {
  4283. const size_t p_len = strlen(prefix);
  4284. smartlist_t *tmp = smartlist_new();
  4285. smartlist_t *conns = get_connection_array();
  4286. int flags = DSR_HEX;
  4287. if (purpose == DIR_PURPOSE_FETCH_MICRODESC)
  4288. flags = DSR_DIGEST256|DSR_BASE64;
  4289. tor_assert(result || result256);
  4290. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, conn) {
  4291. if (conn->type == CONN_TYPE_DIR &&
  4292. conn->purpose == purpose &&
  4293. !conn->marked_for_close) {
  4294. const char *resource = TO_DIR_CONN(conn)->requested_resource;
  4295. if (!strcmpstart(resource, prefix))
  4296. dir_split_resource_into_fingerprints(resource + p_len,
  4297. tmp, NULL, flags);
  4298. }
  4299. } SMARTLIST_FOREACH_END(conn);
  4300. if (result) {
  4301. SMARTLIST_FOREACH(tmp, char *, d,
  4302. {
  4303. digestmap_set(result, d, (void*)1);
  4304. tor_free(d);
  4305. });
  4306. } else if (result256) {
  4307. SMARTLIST_FOREACH(tmp, uint8_t *, d,
  4308. {
  4309. digest256map_set(result256, d, (void*)1);
  4310. tor_free(d);
  4311. });
  4312. }
  4313. smartlist_free(tmp);
  4314. }
  4315. /** For every router descriptor (or extra-info document if <b>extrainfo</b> is
  4316. * true) we are currently downloading by descriptor digest, set result[d] to
  4317. * (void*)1. */
  4318. static void
  4319. list_pending_descriptor_downloads(digestmap_t *result, int extrainfo)
  4320. {
  4321. int purpose =
  4322. extrainfo ? DIR_PURPOSE_FETCH_EXTRAINFO : DIR_PURPOSE_FETCH_SERVERDESC;
  4323. list_pending_downloads(result, NULL, purpose, "d/");
  4324. }
  4325. /** For every microdescriptor we are currently downloading by descriptor
  4326. * digest, set result[d] to (void*)1.
  4327. */
  4328. void
  4329. list_pending_microdesc_downloads(digest256map_t *result)
  4330. {
  4331. list_pending_downloads(NULL, result, DIR_PURPOSE_FETCH_MICRODESC, "d/");
  4332. }
  4333. /** For every certificate we are currently downloading by (identity digest,
  4334. * signing key digest) pair, set result[fp_pair] to (void *1).
  4335. */
  4336. static void
  4337. list_pending_fpsk_downloads(fp_pair_map_t *result)
  4338. {
  4339. const char *pfx = "fp-sk/";
  4340. smartlist_t *tmp;
  4341. smartlist_t *conns;
  4342. const char *resource;
  4343. tor_assert(result);
  4344. tmp = smartlist_new();
  4345. conns = get_connection_array();
  4346. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, conn) {
  4347. if (conn->type == CONN_TYPE_DIR &&
  4348. conn->purpose == DIR_PURPOSE_FETCH_CERTIFICATE &&
  4349. !conn->marked_for_close) {
  4350. resource = TO_DIR_CONN(conn)->requested_resource;
  4351. if (!strcmpstart(resource, pfx))
  4352. dir_split_resource_into_fingerprint_pairs(resource + strlen(pfx),
  4353. tmp);
  4354. }
  4355. } SMARTLIST_FOREACH_END(conn);
  4356. SMARTLIST_FOREACH_BEGIN(tmp, fp_pair_t *, fp) {
  4357. fp_pair_map_set(result, fp, (void*)1);
  4358. tor_free(fp);
  4359. } SMARTLIST_FOREACH_END(fp);
  4360. smartlist_free(tmp);
  4361. }
  4362. /** Launch downloads for all the descriptors whose digests or digests256
  4363. * are listed as digests[i] for lo <= i < hi. (Lo and hi may be out of
  4364. * range.) If <b>source</b> is given, download from <b>source</b>;
  4365. * otherwise, download from an appropriate random directory server.
  4366. */
  4367. MOCK_IMPL(STATIC void,
  4368. initiate_descriptor_downloads,(const routerstatus_t *source,
  4369. int purpose, smartlist_t *digests,
  4370. int lo, int hi, int pds_flags))
  4371. {
  4372. char *resource, *cp;
  4373. int digest_len, enc_digest_len;
  4374. const char *sep;
  4375. int b64_256;
  4376. smartlist_t *tmp;
  4377. if (purpose == DIR_PURPOSE_FETCH_MICRODESC) {
  4378. /* Microdescriptors are downloaded by "-"-separated base64-encoded
  4379. * 256-bit digests. */
  4380. digest_len = DIGEST256_LEN;
  4381. enc_digest_len = BASE64_DIGEST256_LEN + 1;
  4382. sep = "-";
  4383. b64_256 = 1;
  4384. } else {
  4385. digest_len = DIGEST_LEN;
  4386. enc_digest_len = HEX_DIGEST_LEN + 1;
  4387. sep = "+";
  4388. b64_256 = 0;
  4389. }
  4390. if (lo < 0)
  4391. lo = 0;
  4392. if (hi > smartlist_len(digests))
  4393. hi = smartlist_len(digests);
  4394. if (hi-lo <= 0)
  4395. return;
  4396. tmp = smartlist_new();
  4397. for (; lo < hi; ++lo) {
  4398. cp = tor_malloc(enc_digest_len);
  4399. if (b64_256) {
  4400. digest256_to_base64(cp, smartlist_get(digests, lo));
  4401. } else {
  4402. base16_encode(cp, enc_digest_len, smartlist_get(digests, lo),
  4403. digest_len);
  4404. }
  4405. smartlist_add(tmp, cp);
  4406. }
  4407. cp = smartlist_join_strings(tmp, sep, 0, NULL);
  4408. tor_asprintf(&resource, "d/%s.z", cp);
  4409. SMARTLIST_FOREACH(tmp, char *, cp1, tor_free(cp1));
  4410. smartlist_free(tmp);
  4411. tor_free(cp);
  4412. if (source) {
  4413. /* We know which authority or directory mirror we want. */
  4414. directory_request_t *req = directory_request_new(purpose);
  4415. directory_request_set_routerstatus(req, source);
  4416. directory_request_set_resource(req, resource);
  4417. directory_initiate_request(req);
  4418. directory_request_free(req);
  4419. } else {
  4420. directory_get_from_dirserver(purpose, ROUTER_PURPOSE_GENERAL, resource,
  4421. pds_flags, DL_WANT_ANY_DIRSERVER);
  4422. }
  4423. tor_free(resource);
  4424. }
  4425. /** Return the max number of hashes to put in a URL for a given request.
  4426. */
  4427. static int
  4428. max_dl_per_request(const or_options_t *options, int purpose)
  4429. {
  4430. /* Since squid does not like URLs >= 4096 bytes we limit it to 96.
  4431. * 4096 - strlen(http://[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535
  4432. * /tor/server/d/.z) == 4026
  4433. * 4026/41 (40 for the hash and 1 for the + that separates them) => 98
  4434. * So use 96 because it's a nice number.
  4435. *
  4436. * For microdescriptors, the calculation is
  4437. * 4096 - strlen(http://[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535
  4438. * /tor/micro/d/.z) == 4027
  4439. * 4027/44 (43 for the hash and 1 for the - that separates them) => 91
  4440. * So use 90 because it's a nice number.
  4441. */
  4442. int max = 96;
  4443. if (purpose == DIR_PURPOSE_FETCH_MICRODESC) {
  4444. max = 90;
  4445. }
  4446. /* If we're going to tunnel our connections, we can ask for a lot more
  4447. * in a request. */
  4448. if (directory_must_use_begindir(options)) {
  4449. max = 500;
  4450. }
  4451. return max;
  4452. }
  4453. /** Don't split our requests so finely that we are requesting fewer than
  4454. * this number per server. (Grouping more than this at once leads to
  4455. * diminishing returns.) */
  4456. #define MIN_DL_PER_REQUEST 32
  4457. /** To prevent a single screwy cache from confusing us by selective reply,
  4458. * try to split our requests into at least this many requests. */
  4459. #define MIN_REQUESTS 3
  4460. /** If we want fewer than this many descriptors, wait until we
  4461. * want more, or until TestingClientMaxIntervalWithoutRequest has passed. */
  4462. #define MAX_DL_TO_DELAY 16
  4463. /** Given a <b>purpose</b> (FETCH_MICRODESC or FETCH_SERVERDESC) and a list of
  4464. * router descriptor digests or microdescriptor digest256s in
  4465. * <b>downloadable</b>, decide whether to delay fetching until we have more.
  4466. * If we don't want to delay, launch one or more requests to the appropriate
  4467. * directory authorities.
  4468. */
  4469. void
  4470. launch_descriptor_downloads(int purpose,
  4471. smartlist_t *downloadable,
  4472. const routerstatus_t *source, time_t now)
  4473. {
  4474. const or_options_t *options = get_options();
  4475. const char *descname;
  4476. const int fetch_microdesc = (purpose == DIR_PURPOSE_FETCH_MICRODESC);
  4477. int n_downloadable = smartlist_len(downloadable);
  4478. int i, n_per_request, max_dl_per_req;
  4479. const char *req_plural = "", *rtr_plural = "";
  4480. int pds_flags = PDS_RETRY_IF_NO_SERVERS;
  4481. tor_assert(fetch_microdesc || purpose == DIR_PURPOSE_FETCH_SERVERDESC);
  4482. descname = fetch_microdesc ? "microdesc" : "routerdesc";
  4483. if (!n_downloadable)
  4484. return;
  4485. if (!directory_fetches_dir_info_early(options)) {
  4486. if (n_downloadable >= MAX_DL_TO_DELAY) {
  4487. log_debug(LD_DIR,
  4488. "There are enough downloadable %ss to launch requests.",
  4489. descname);
  4490. } else if (! router_have_minimum_dir_info()) {
  4491. log_debug(LD_DIR,
  4492. "We are only missing %d %ss, but we'll fetch anyway, since "
  4493. "we don't yet have enough directory info.",
  4494. n_downloadable, descname);
  4495. } else {
  4496. /* should delay */
  4497. if ((last_descriptor_download_attempted +
  4498. options->TestingClientMaxIntervalWithoutRequest) > now)
  4499. return;
  4500. if (last_descriptor_download_attempted) {
  4501. log_info(LD_DIR,
  4502. "There are not many downloadable %ss, but we've "
  4503. "been waiting long enough (%d seconds). Downloading.",
  4504. descname,
  4505. (int)(now-last_descriptor_download_attempted));
  4506. } else {
  4507. log_info(LD_DIR,
  4508. "There are not many downloadable %ss, but we haven't "
  4509. "tried downloading descriptors recently. Downloading.",
  4510. descname);
  4511. }
  4512. }
  4513. }
  4514. if (!authdir_mode(options)) {
  4515. /* If we wind up going to the authorities, we want to only open one
  4516. * connection to each authority at a time, so that we don't overload
  4517. * them. We do this by setting PDS_NO_EXISTING_SERVERDESC_FETCH
  4518. * regardless of whether we're a cache or not.
  4519. *
  4520. * Setting this flag can make initiate_descriptor_downloads() ignore
  4521. * requests. We need to make sure that we do in fact call
  4522. * update_router_descriptor_downloads() later on, once the connections
  4523. * have succeeded or failed.
  4524. */
  4525. pds_flags |= fetch_microdesc ?
  4526. PDS_NO_EXISTING_MICRODESC_FETCH :
  4527. PDS_NO_EXISTING_SERVERDESC_FETCH;
  4528. }
  4529. n_per_request = CEIL_DIV(n_downloadable, MIN_REQUESTS);
  4530. max_dl_per_req = max_dl_per_request(options, purpose);
  4531. if (n_per_request > max_dl_per_req)
  4532. n_per_request = max_dl_per_req;
  4533. if (n_per_request < MIN_DL_PER_REQUEST) {
  4534. n_per_request = MIN(MIN_DL_PER_REQUEST, n_downloadable);
  4535. }
  4536. if (n_downloadable > n_per_request)
  4537. req_plural = rtr_plural = "s";
  4538. else if (n_downloadable > 1)
  4539. rtr_plural = "s";
  4540. log_info(LD_DIR,
  4541. "Launching %d request%s for %d %s%s, %d at a time",
  4542. CEIL_DIV(n_downloadable, n_per_request), req_plural,
  4543. n_downloadable, descname, rtr_plural, n_per_request);
  4544. smartlist_sort_digests(downloadable);
  4545. for (i=0; i < n_downloadable; i += n_per_request) {
  4546. initiate_descriptor_downloads(source, purpose,
  4547. downloadable, i, i+n_per_request,
  4548. pds_flags);
  4549. }
  4550. last_descriptor_download_attempted = now;
  4551. }
  4552. /** For any descriptor that we want that's currently listed in
  4553. * <b>consensus</b>, download it as appropriate. */
  4554. void
  4555. update_consensus_router_descriptor_downloads(time_t now, int is_vote,
  4556. networkstatus_t *consensus)
  4557. {
  4558. const or_options_t *options = get_options();
  4559. digestmap_t *map = NULL;
  4560. smartlist_t *no_longer_old = smartlist_new();
  4561. smartlist_t *downloadable = smartlist_new();
  4562. routerstatus_t *source = NULL;
  4563. int authdir = authdir_mode(options);
  4564. int n_delayed=0, n_have=0, n_would_reject=0, n_wouldnt_use=0,
  4565. n_inprogress=0, n_in_oldrouters=0;
  4566. if (directory_too_idle_to_fetch_descriptors(options, now))
  4567. goto done;
  4568. if (!consensus)
  4569. goto done;
  4570. if (is_vote) {
  4571. /* where's it from, so we know whom to ask for descriptors */
  4572. dir_server_t *ds;
  4573. networkstatus_voter_info_t *voter = smartlist_get(consensus->voters, 0);
  4574. tor_assert(voter);
  4575. ds = trusteddirserver_get_by_v3_auth_digest(voter->identity_digest);
  4576. if (ds)
  4577. source = &(ds->fake_status);
  4578. else
  4579. log_warn(LD_DIR, "couldn't lookup source from vote?");
  4580. }
  4581. map = digestmap_new();
  4582. list_pending_descriptor_downloads(map, 0);
  4583. SMARTLIST_FOREACH_BEGIN(consensus->routerstatus_list, void *, rsp) {
  4584. routerstatus_t *rs =
  4585. is_vote ? &(((vote_routerstatus_t *)rsp)->status) : rsp;
  4586. signed_descriptor_t *sd;
  4587. if ((sd = router_get_by_descriptor_digest(rs->descriptor_digest))) {
  4588. const routerinfo_t *ri;
  4589. ++n_have;
  4590. if (!(ri = router_get_by_id_digest(rs->identity_digest)) ||
  4591. tor_memneq(ri->cache_info.signed_descriptor_digest,
  4592. sd->signed_descriptor_digest, DIGEST_LEN)) {
  4593. /* We have a descriptor with this digest, but either there is no
  4594. * entry in routerlist with the same ID (!ri), or there is one,
  4595. * but the identity digest differs (memneq).
  4596. */
  4597. smartlist_add(no_longer_old, sd);
  4598. ++n_in_oldrouters; /* We have it in old_routers. */
  4599. }
  4600. continue; /* We have it already. */
  4601. }
  4602. if (digestmap_get(map, rs->descriptor_digest)) {
  4603. ++n_inprogress;
  4604. continue; /* We have an in-progress download. */
  4605. }
  4606. if (!download_status_is_ready(&rs->dl_status, now,
  4607. options->TestingDescriptorMaxDownloadTries)) {
  4608. ++n_delayed; /* Not ready for retry. */
  4609. continue;
  4610. }
  4611. if (authdir && dirserv_would_reject_router(rs)) {
  4612. ++n_would_reject;
  4613. continue; /* We would throw it out immediately. */
  4614. }
  4615. if (!we_want_to_fetch_flavor(options, consensus->flavor) &&
  4616. !client_would_use_router(rs, now)) {
  4617. ++n_wouldnt_use;
  4618. continue; /* We would never use it ourself. */
  4619. }
  4620. if (is_vote && source) {
  4621. char time_bufnew[ISO_TIME_LEN+1];
  4622. char time_bufold[ISO_TIME_LEN+1];
  4623. const routerinfo_t *oldrouter;
  4624. oldrouter = router_get_by_id_digest(rs->identity_digest);
  4625. format_iso_time(time_bufnew, rs->published_on);
  4626. if (oldrouter)
  4627. format_iso_time(time_bufold, oldrouter->cache_info.published_on);
  4628. log_info(LD_DIR, "Learned about %s (%s vs %s) from %s's vote (%s)",
  4629. routerstatus_describe(rs),
  4630. time_bufnew,
  4631. oldrouter ? time_bufold : "none",
  4632. source->nickname, oldrouter ? "known" : "unknown");
  4633. }
  4634. smartlist_add(downloadable, rs->descriptor_digest);
  4635. } SMARTLIST_FOREACH_END(rsp);
  4636. if (!authdir_mode_v3(options)
  4637. && smartlist_len(no_longer_old)) {
  4638. routerlist_t *rl = router_get_routerlist();
  4639. log_info(LD_DIR, "%d router descriptors listed in consensus are "
  4640. "currently in old_routers; making them current.",
  4641. smartlist_len(no_longer_old));
  4642. SMARTLIST_FOREACH_BEGIN(no_longer_old, signed_descriptor_t *, sd) {
  4643. const char *msg;
  4644. was_router_added_t r;
  4645. time_t tmp_cert_expiration_time;
  4646. routerinfo_t *ri = routerlist_reparse_old(rl, sd);
  4647. if (!ri) {
  4648. log_warn(LD_BUG, "Failed to re-parse a router.");
  4649. continue;
  4650. }
  4651. /* need to remember for below, since add_to_routerlist may free. */
  4652. tmp_cert_expiration_time = ri->cert_expiration_time;
  4653. r = router_add_to_routerlist(ri, &msg, 1, 0);
  4654. if (WRA_WAS_OUTDATED(r)) {
  4655. log_warn(LD_DIR, "Couldn't add re-parsed router: %s. This isn't "
  4656. "usually a big deal, but you should make sure that your "
  4657. "clock and timezone are set correctly.",
  4658. msg?msg:"???");
  4659. if (r == ROUTER_CERTS_EXPIRED) {
  4660. char time_cons[ISO_TIME_LEN+1];
  4661. char time_cert_expires[ISO_TIME_LEN+1];
  4662. format_iso_time(time_cons, consensus->valid_after);
  4663. format_iso_time(time_cert_expires, tmp_cert_expiration_time);
  4664. log_warn(LD_DIR, " (I'm looking at a consensus from %s; This "
  4665. "router's certificates began expiring at %s.)",
  4666. time_cons, time_cert_expires);
  4667. }
  4668. }
  4669. } SMARTLIST_FOREACH_END(sd);
  4670. routerlist_assert_ok(rl);
  4671. }
  4672. log_info(LD_DIR,
  4673. "%d router descriptors downloadable. %d delayed; %d present "
  4674. "(%d of those were in old_routers); %d would_reject; "
  4675. "%d wouldnt_use; %d in progress.",
  4676. smartlist_len(downloadable), n_delayed, n_have, n_in_oldrouters,
  4677. n_would_reject, n_wouldnt_use, n_inprogress);
  4678. launch_descriptor_downloads(DIR_PURPOSE_FETCH_SERVERDESC,
  4679. downloadable, source, now);
  4680. digestmap_free(map, NULL);
  4681. done:
  4682. smartlist_free(downloadable);
  4683. smartlist_free(no_longer_old);
  4684. }
  4685. /** How often should we launch a server/authority request to be sure of getting
  4686. * a guess for our IP? */
  4687. /*XXXX+ this info should come from netinfo cells or something, or we should
  4688. * do this only when we aren't seeing incoming data. see bug 652. */
  4689. #define DUMMY_DOWNLOAD_INTERVAL (20*60)
  4690. /** As needed, launch a dummy router descriptor fetch to see if our
  4691. * address has changed. */
  4692. static void
  4693. launch_dummy_descriptor_download_as_needed(time_t now,
  4694. const or_options_t *options)
  4695. {
  4696. static time_t last_dummy_download = 0;
  4697. /* XXXX+ we could be smarter here; see notes on bug 652. */
  4698. /* If we're a server that doesn't have a configured address, we rely on
  4699. * directory fetches to learn when our address changes. So if we haven't
  4700. * tried to get any routerdescs in a long time, try a dummy fetch now. */
  4701. if (!options->Address &&
  4702. server_mode(options) &&
  4703. last_descriptor_download_attempted + DUMMY_DOWNLOAD_INTERVAL < now &&
  4704. last_dummy_download + DUMMY_DOWNLOAD_INTERVAL < now) {
  4705. last_dummy_download = now;
  4706. /* XX/teor - do we want an authority here, because they are less likely
  4707. * to give us the wrong address? (See #17782)
  4708. * I'm leaving the previous behaviour intact, because I don't like
  4709. * the idea of some relays contacting an authority every 20 minutes. */
  4710. directory_get_from_dirserver(DIR_PURPOSE_FETCH_SERVERDESC,
  4711. ROUTER_PURPOSE_GENERAL, "authority.z",
  4712. PDS_RETRY_IF_NO_SERVERS,
  4713. DL_WANT_ANY_DIRSERVER);
  4714. }
  4715. }
  4716. /** Launch downloads for router status as needed. */
  4717. void
  4718. update_router_descriptor_downloads(time_t now)
  4719. {
  4720. const or_options_t *options = get_options();
  4721. if (should_delay_dir_fetches(options, NULL))
  4722. return;
  4723. if (!we_fetch_router_descriptors(options))
  4724. return;
  4725. update_consensus_router_descriptor_downloads(now, 0,
  4726. networkstatus_get_reasonably_live_consensus(now, FLAV_NS));
  4727. }
  4728. /** Launch extrainfo downloads as needed. */
  4729. void
  4730. update_extrainfo_downloads(time_t now)
  4731. {
  4732. const or_options_t *options = get_options();
  4733. routerlist_t *rl;
  4734. smartlist_t *wanted;
  4735. digestmap_t *pending;
  4736. int old_routers, i, max_dl_per_req;
  4737. int n_no_ei = 0, n_pending = 0, n_have = 0, n_delay = 0, n_bogus[2] = {0,0};
  4738. if (! options->DownloadExtraInfo)
  4739. return;
  4740. if (should_delay_dir_fetches(options, NULL))
  4741. return;
  4742. if (!router_have_minimum_dir_info())
  4743. return;
  4744. pending = digestmap_new();
  4745. list_pending_descriptor_downloads(pending, 1);
  4746. rl = router_get_routerlist();
  4747. wanted = smartlist_new();
  4748. for (old_routers = 0; old_routers < 2; ++old_routers) {
  4749. smartlist_t *lst = old_routers ? rl->old_routers : rl->routers;
  4750. for (i = 0; i < smartlist_len(lst); ++i) {
  4751. signed_descriptor_t *sd;
  4752. char *d;
  4753. if (old_routers)
  4754. sd = smartlist_get(lst, i);
  4755. else
  4756. sd = &((routerinfo_t*)smartlist_get(lst, i))->cache_info;
  4757. if (sd->is_extrainfo)
  4758. continue; /* This should never happen. */
  4759. if (old_routers && !router_get_by_id_digest(sd->identity_digest))
  4760. continue; /* Couldn't check the signature if we got it. */
  4761. if (sd->extrainfo_is_bogus)
  4762. continue;
  4763. d = sd->extra_info_digest;
  4764. if (tor_digest_is_zero(d)) {
  4765. ++n_no_ei;
  4766. continue;
  4767. }
  4768. if (eimap_get(rl->extra_info_map, d)) {
  4769. ++n_have;
  4770. continue;
  4771. }
  4772. if (!download_status_is_ready(&sd->ei_dl_status, now,
  4773. options->TestingDescriptorMaxDownloadTries)) {
  4774. ++n_delay;
  4775. continue;
  4776. }
  4777. if (digestmap_get(pending, d)) {
  4778. ++n_pending;
  4779. continue;
  4780. }
  4781. const signed_descriptor_t *sd2 = router_get_by_extrainfo_digest(d);
  4782. if (sd2 != sd) {
  4783. if (sd2 != NULL) {
  4784. char d1[HEX_DIGEST_LEN+1], d2[HEX_DIGEST_LEN+1];
  4785. char d3[HEX_DIGEST_LEN+1], d4[HEX_DIGEST_LEN+1];
  4786. base16_encode(d1, sizeof(d1), sd->identity_digest, DIGEST_LEN);
  4787. base16_encode(d2, sizeof(d2), sd2->identity_digest, DIGEST_LEN);
  4788. base16_encode(d3, sizeof(d3), d, DIGEST_LEN);
  4789. base16_encode(d4, sizeof(d3), sd2->extra_info_digest, DIGEST_LEN);
  4790. log_info(LD_DIR, "Found an entry in %s with mismatched "
  4791. "router_get_by_extrainfo_digest() value. This has ID %s "
  4792. "but the entry in the map has ID %s. This has EI digest "
  4793. "%s and the entry in the map has EI digest %s.",
  4794. old_routers?"old_routers":"routers",
  4795. d1, d2, d3, d4);
  4796. } else {
  4797. char d1[HEX_DIGEST_LEN+1], d2[HEX_DIGEST_LEN+1];
  4798. base16_encode(d1, sizeof(d1), sd->identity_digest, DIGEST_LEN);
  4799. base16_encode(d2, sizeof(d2), d, DIGEST_LEN);
  4800. log_info(LD_DIR, "Found an entry in %s with NULL "
  4801. "router_get_by_extrainfo_digest() value. This has ID %s "
  4802. "and EI digest %s.",
  4803. old_routers?"old_routers":"routers",
  4804. d1, d2);
  4805. }
  4806. ++n_bogus[old_routers];
  4807. continue;
  4808. }
  4809. smartlist_add(wanted, d);
  4810. }
  4811. }
  4812. digestmap_free(pending, NULL);
  4813. log_info(LD_DIR, "Extrainfo download status: %d router with no ei, %d "
  4814. "with present ei, %d delaying, %d pending, %d downloadable, %d "
  4815. "bogus in routers, %d bogus in old_routers",
  4816. n_no_ei, n_have, n_delay, n_pending, smartlist_len(wanted),
  4817. n_bogus[0], n_bogus[1]);
  4818. smartlist_shuffle(wanted);
  4819. max_dl_per_req = max_dl_per_request(options, DIR_PURPOSE_FETCH_EXTRAINFO);
  4820. for (i = 0; i < smartlist_len(wanted); i += max_dl_per_req) {
  4821. initiate_descriptor_downloads(NULL, DIR_PURPOSE_FETCH_EXTRAINFO,
  4822. wanted, i, i+max_dl_per_req,
  4823. PDS_RETRY_IF_NO_SERVERS|PDS_NO_EXISTING_SERVERDESC_FETCH);
  4824. }
  4825. smartlist_free(wanted);
  4826. }
  4827. /** Reset the consensus and extra-info download failure count on all routers.
  4828. * When we get a new consensus,
  4829. * routers_update_status_from_consensus_networkstatus() will reset the
  4830. * download statuses on the descriptors in that consensus.
  4831. */
  4832. void
  4833. router_reset_descriptor_download_failures(void)
  4834. {
  4835. log_debug(LD_GENERAL,
  4836. "In router_reset_descriptor_download_failures()");
  4837. networkstatus_reset_download_failures();
  4838. last_descriptor_download_attempted = 0;
  4839. if (!routerlist)
  4840. return;
  4841. /* We want to download *all* extra-info descriptors, not just those in
  4842. * the consensus we currently have (or are about to have) */
  4843. SMARTLIST_FOREACH(routerlist->routers, routerinfo_t *, ri,
  4844. {
  4845. download_status_reset(&ri->cache_info.ei_dl_status);
  4846. });
  4847. SMARTLIST_FOREACH(routerlist->old_routers, signed_descriptor_t *, sd,
  4848. {
  4849. download_status_reset(&sd->ei_dl_status);
  4850. });
  4851. }
  4852. /** Any changes in a router descriptor's publication time larger than this are
  4853. * automatically non-cosmetic. */
  4854. #define ROUTER_MAX_COSMETIC_TIME_DIFFERENCE (2*60*60)
  4855. /** We allow uptime to vary from how much it ought to be by this much. */
  4856. #define ROUTER_ALLOW_UPTIME_DRIFT (6*60*60)
  4857. /** Return true iff the only differences between r1 and r2 are such that
  4858. * would not cause a recent (post 0.1.1.6) dirserver to republish.
  4859. */
  4860. int
  4861. router_differences_are_cosmetic(const routerinfo_t *r1, const routerinfo_t *r2)
  4862. {
  4863. time_t r1pub, r2pub;
  4864. long time_difference;
  4865. tor_assert(r1 && r2);
  4866. /* r1 should be the one that was published first. */
  4867. if (r1->cache_info.published_on > r2->cache_info.published_on) {
  4868. const routerinfo_t *ri_tmp = r2;
  4869. r2 = r1;
  4870. r1 = ri_tmp;
  4871. }
  4872. /* If any key fields differ, they're different. */
  4873. if (r1->addr != r2->addr ||
  4874. strcasecmp(r1->nickname, r2->nickname) ||
  4875. r1->or_port != r2->or_port ||
  4876. !tor_addr_eq(&r1->ipv6_addr, &r2->ipv6_addr) ||
  4877. r1->ipv6_orport != r2->ipv6_orport ||
  4878. r1->dir_port != r2->dir_port ||
  4879. r1->purpose != r2->purpose ||
  4880. !crypto_pk_eq_keys(r1->onion_pkey, r2->onion_pkey) ||
  4881. !crypto_pk_eq_keys(r1->identity_pkey, r2->identity_pkey) ||
  4882. strcasecmp(r1->platform, r2->platform) ||
  4883. (r1->contact_info && !r2->contact_info) || /* contact_info is optional */
  4884. (!r1->contact_info && r2->contact_info) ||
  4885. (r1->contact_info && r2->contact_info &&
  4886. strcasecmp(r1->contact_info, r2->contact_info)) ||
  4887. r1->is_hibernating != r2->is_hibernating ||
  4888. ! addr_policies_eq(r1->exit_policy, r2->exit_policy) ||
  4889. (r1->supports_tunnelled_dir_requests !=
  4890. r2->supports_tunnelled_dir_requests))
  4891. return 0;
  4892. if ((r1->declared_family == NULL) != (r2->declared_family == NULL))
  4893. return 0;
  4894. if (r1->declared_family && r2->declared_family) {
  4895. int i, n;
  4896. if (smartlist_len(r1->declared_family)!=smartlist_len(r2->declared_family))
  4897. return 0;
  4898. n = smartlist_len(r1->declared_family);
  4899. for (i=0; i < n; ++i) {
  4900. if (strcasecmp(smartlist_get(r1->declared_family, i),
  4901. smartlist_get(r2->declared_family, i)))
  4902. return 0;
  4903. }
  4904. }
  4905. /* Did bandwidth change a lot? */
  4906. if ((r1->bandwidthcapacity < r2->bandwidthcapacity/2) ||
  4907. (r2->bandwidthcapacity < r1->bandwidthcapacity/2))
  4908. return 0;
  4909. /* Did the bandwidthrate or bandwidthburst change? */
  4910. if ((r1->bandwidthrate != r2->bandwidthrate) ||
  4911. (r1->bandwidthburst != r2->bandwidthburst))
  4912. return 0;
  4913. /* Did more than 12 hours pass? */
  4914. if (r1->cache_info.published_on + ROUTER_MAX_COSMETIC_TIME_DIFFERENCE
  4915. < r2->cache_info.published_on)
  4916. return 0;
  4917. /* Did uptime fail to increase by approximately the amount we would think,
  4918. * give or take some slop? */
  4919. r1pub = r1->cache_info.published_on;
  4920. r2pub = r2->cache_info.published_on;
  4921. time_difference = labs(r2->uptime - (r1->uptime + (r2pub - r1pub)));
  4922. if (time_difference > ROUTER_ALLOW_UPTIME_DRIFT &&
  4923. time_difference > r1->uptime * .05 &&
  4924. time_difference > r2->uptime * .05)
  4925. return 0;
  4926. /* Otherwise, the difference is cosmetic. */
  4927. return 1;
  4928. }
  4929. /** Check whether <b>sd</b> describes a router descriptor compatible with the
  4930. * extrainfo document <b>ei</b>.
  4931. *
  4932. * <b>identity_pkey</b> (which must also be provided) is RSA1024 identity key
  4933. * for the router. We use it to check the signature of the extrainfo document,
  4934. * if it has not already been checked.
  4935. *
  4936. * If no router is compatible with <b>ei</b>, <b>ei</b> should be
  4937. * dropped. Return 0 for "compatible", return 1 for "reject, and inform
  4938. * whoever uploaded <b>ei</b>, and return -1 for "reject silently.". If
  4939. * <b>msg</b> is present, set *<b>msg</b> to a description of the
  4940. * incompatibility (if any).
  4941. *
  4942. * Set the extrainfo_is_bogus field in <b>sd</b> if the digests matched
  4943. * but the extrainfo was nonetheless incompatible.
  4944. **/
  4945. int
  4946. routerinfo_incompatible_with_extrainfo(const crypto_pk_t *identity_pkey,
  4947. extrainfo_t *ei,
  4948. signed_descriptor_t *sd,
  4949. const char **msg)
  4950. {
  4951. int digest_matches, digest256_matches, r=1;
  4952. tor_assert(identity_pkey);
  4953. tor_assert(sd);
  4954. tor_assert(ei);
  4955. if (ei->bad_sig) {
  4956. if (msg) *msg = "Extrainfo signature was bad, or signed with wrong key.";
  4957. return 1;
  4958. }
  4959. digest_matches = tor_memeq(ei->cache_info.signed_descriptor_digest,
  4960. sd->extra_info_digest, DIGEST_LEN);
  4961. /* Set digest256_matches to 1 if the digest is correct, or if no
  4962. * digest256 was in the ri. */
  4963. digest256_matches = tor_memeq(ei->digest256,
  4964. sd->extra_info_digest256, DIGEST256_LEN);
  4965. digest256_matches |=
  4966. tor_mem_is_zero(sd->extra_info_digest256, DIGEST256_LEN);
  4967. /* The identity must match exactly to have been generated at the same time
  4968. * by the same router. */
  4969. if (tor_memneq(sd->identity_digest,
  4970. ei->cache_info.identity_digest,
  4971. DIGEST_LEN)) {
  4972. if (msg) *msg = "Extrainfo nickname or identity did not match routerinfo";
  4973. goto err; /* different servers */
  4974. }
  4975. if (! tor_cert_opt_eq(sd->signing_key_cert,
  4976. ei->cache_info.signing_key_cert)) {
  4977. if (msg) *msg = "Extrainfo signing key cert didn't match routerinfo";
  4978. goto err; /* different servers */
  4979. }
  4980. if (ei->pending_sig) {
  4981. char signed_digest[128];
  4982. if (crypto_pk_public_checksig(identity_pkey,
  4983. signed_digest, sizeof(signed_digest),
  4984. ei->pending_sig, ei->pending_sig_len) != DIGEST_LEN ||
  4985. tor_memneq(signed_digest, ei->cache_info.signed_descriptor_digest,
  4986. DIGEST_LEN)) {
  4987. ei->bad_sig = 1;
  4988. tor_free(ei->pending_sig);
  4989. if (msg) *msg = "Extrainfo signature bad, or signed with wrong key";
  4990. goto err; /* Bad signature, or no match. */
  4991. }
  4992. ei->cache_info.send_unencrypted = sd->send_unencrypted;
  4993. tor_free(ei->pending_sig);
  4994. }
  4995. if (ei->cache_info.published_on < sd->published_on) {
  4996. if (msg) *msg = "Extrainfo published time did not match routerdesc";
  4997. goto err;
  4998. } else if (ei->cache_info.published_on > sd->published_on) {
  4999. if (msg) *msg = "Extrainfo published time did not match routerdesc";
  5000. r = -1;
  5001. goto err;
  5002. }
  5003. if (!digest256_matches && !digest_matches) {
  5004. if (msg) *msg = "Neither digest256 or digest matched "
  5005. "digest from routerdesc";
  5006. goto err;
  5007. }
  5008. if (!digest256_matches) {
  5009. if (msg) *msg = "Extrainfo digest did not match digest256 from routerdesc";
  5010. goto err; /* Digest doesn't match declared value. */
  5011. }
  5012. if (!digest_matches) {
  5013. if (msg) *msg = "Extrainfo digest did not match value from routerdesc";
  5014. goto err; /* Digest doesn't match declared value. */
  5015. }
  5016. return 0;
  5017. err:
  5018. if (digest_matches) {
  5019. /* This signature was okay, and the digest was right: This is indeed the
  5020. * corresponding extrainfo. But insanely, it doesn't match the routerinfo
  5021. * that lists it. Don't try to fetch this one again. */
  5022. sd->extrainfo_is_bogus = 1;
  5023. }
  5024. return r;
  5025. }
  5026. /* Does ri have a valid ntor onion key?
  5027. * Valid ntor onion keys exist and have at least one non-zero byte. */
  5028. int
  5029. routerinfo_has_curve25519_onion_key(const routerinfo_t *ri)
  5030. {
  5031. if (!ri) {
  5032. return 0;
  5033. }
  5034. if (!ri->onion_curve25519_pkey) {
  5035. return 0;
  5036. }
  5037. if (tor_mem_is_zero((const char*)ri->onion_curve25519_pkey->public_key,
  5038. CURVE25519_PUBKEY_LEN)) {
  5039. return 0;
  5040. }
  5041. return 1;
  5042. }
  5043. /* Is rs running a tor version known to support EXTEND2 cells?
  5044. * If allow_unknown_versions is true, return true if we can't tell
  5045. * (from a versions line or a protocols line) whether it supports extend2
  5046. * cells.
  5047. * Otherwise, return false if the version is unknown. */
  5048. int
  5049. routerstatus_version_supports_extend2_cells(const routerstatus_t *rs,
  5050. int allow_unknown_versions)
  5051. {
  5052. if (!rs) {
  5053. return allow_unknown_versions;
  5054. }
  5055. if (!rs->pv.protocols_known) {
  5056. return allow_unknown_versions;
  5057. }
  5058. return rs->pv.supports_extend2_cells;
  5059. }
  5060. /** Assert that the internal representation of <b>rl</b> is
  5061. * self-consistent. */
  5062. void
  5063. routerlist_assert_ok(const routerlist_t *rl)
  5064. {
  5065. routerinfo_t *r2;
  5066. signed_descriptor_t *sd2;
  5067. if (!rl)
  5068. return;
  5069. SMARTLIST_FOREACH_BEGIN(rl->routers, routerinfo_t *, r) {
  5070. r2 = rimap_get(rl->identity_map, r->cache_info.identity_digest);
  5071. tor_assert(r == r2);
  5072. sd2 = sdmap_get(rl->desc_digest_map,
  5073. r->cache_info.signed_descriptor_digest);
  5074. tor_assert(&(r->cache_info) == sd2);
  5075. tor_assert(r->cache_info.routerlist_index == r_sl_idx);
  5076. /* XXXX
  5077. *
  5078. * Hoo boy. We need to fix this one, and the fix is a bit tricky, so
  5079. * commenting this out is just a band-aid.
  5080. *
  5081. * The problem is that, although well-behaved router descriptors
  5082. * should never have the same value for their extra_info_digest, it's
  5083. * possible for ill-behaved routers to claim whatever they like there.
  5084. *
  5085. * The real answer is to trash desc_by_eid_map and instead have
  5086. * something that indicates for a given extra-info digest we want,
  5087. * what its download status is. We'll do that as a part of routerlist
  5088. * refactoring once consensus directories are in. For now,
  5089. * this rep violation is probably harmless: an adversary can make us
  5090. * reset our retry count for an extrainfo, but that's not the end
  5091. * of the world. Changing the representation in 0.2.0.x would just
  5092. * destabilize the codebase.
  5093. if (!tor_digest_is_zero(r->cache_info.extra_info_digest)) {
  5094. signed_descriptor_t *sd3 =
  5095. sdmap_get(rl->desc_by_eid_map, r->cache_info.extra_info_digest);
  5096. tor_assert(sd3 == &(r->cache_info));
  5097. }
  5098. */
  5099. } SMARTLIST_FOREACH_END(r);
  5100. SMARTLIST_FOREACH_BEGIN(rl->old_routers, signed_descriptor_t *, sd) {
  5101. r2 = rimap_get(rl->identity_map, sd->identity_digest);
  5102. tor_assert(!r2 || sd != &(r2->cache_info));
  5103. sd2 = sdmap_get(rl->desc_digest_map, sd->signed_descriptor_digest);
  5104. tor_assert(sd == sd2);
  5105. tor_assert(sd->routerlist_index == sd_sl_idx);
  5106. /* XXXX see above.
  5107. if (!tor_digest_is_zero(sd->extra_info_digest)) {
  5108. signed_descriptor_t *sd3 =
  5109. sdmap_get(rl->desc_by_eid_map, sd->extra_info_digest);
  5110. tor_assert(sd3 == sd);
  5111. }
  5112. */
  5113. } SMARTLIST_FOREACH_END(sd);
  5114. RIMAP_FOREACH(rl->identity_map, d, r) {
  5115. tor_assert(tor_memeq(r->cache_info.identity_digest, d, DIGEST_LEN));
  5116. } DIGESTMAP_FOREACH_END;
  5117. SDMAP_FOREACH(rl->desc_digest_map, d, sd) {
  5118. tor_assert(tor_memeq(sd->signed_descriptor_digest, d, DIGEST_LEN));
  5119. } DIGESTMAP_FOREACH_END;
  5120. SDMAP_FOREACH(rl->desc_by_eid_map, d, sd) {
  5121. tor_assert(!tor_digest_is_zero(d));
  5122. tor_assert(sd);
  5123. tor_assert(tor_memeq(sd->extra_info_digest, d, DIGEST_LEN));
  5124. } DIGESTMAP_FOREACH_END;
  5125. EIMAP_FOREACH(rl->extra_info_map, d, ei) {
  5126. signed_descriptor_t *sd;
  5127. tor_assert(tor_memeq(ei->cache_info.signed_descriptor_digest,
  5128. d, DIGEST_LEN));
  5129. sd = sdmap_get(rl->desc_by_eid_map,
  5130. ei->cache_info.signed_descriptor_digest);
  5131. // tor_assert(sd); // XXXX see above
  5132. if (sd) {
  5133. tor_assert(tor_memeq(ei->cache_info.signed_descriptor_digest,
  5134. sd->extra_info_digest, DIGEST_LEN));
  5135. }
  5136. } DIGESTMAP_FOREACH_END;
  5137. }
  5138. /** Allocate and return a new string representing the contact info
  5139. * and platform string for <b>router</b>,
  5140. * surrounded by quotes and using standard C escapes.
  5141. *
  5142. * THIS FUNCTION IS NOT REENTRANT. Don't call it from outside the main
  5143. * thread. Also, each call invalidates the last-returned value, so don't
  5144. * try log_warn(LD_GENERAL, "%s %s", esc_router_info(a), esc_router_info(b));
  5145. *
  5146. * If <b>router</b> is NULL, it just frees its internal memory and returns.
  5147. */
  5148. const char *
  5149. esc_router_info(const routerinfo_t *router)
  5150. {
  5151. static char *info=NULL;
  5152. char *esc_contact, *esc_platform;
  5153. tor_free(info);
  5154. if (!router)
  5155. return NULL; /* we're exiting; just free the memory we use */
  5156. esc_contact = esc_for_log(router->contact_info);
  5157. esc_platform = esc_for_log(router->platform);
  5158. tor_asprintf(&info, "Contact %s, Platform %s", esc_contact, esc_platform);
  5159. tor_free(esc_contact);
  5160. tor_free(esc_platform);
  5161. return info;
  5162. }
  5163. /** Helper for sorting: compare two routerinfos by their identity
  5164. * digest. */
  5165. static int
  5166. compare_routerinfo_by_id_digest_(const void **a, const void **b)
  5167. {
  5168. routerinfo_t *first = *(routerinfo_t **)a, *second = *(routerinfo_t **)b;
  5169. return fast_memcmp(first->cache_info.identity_digest,
  5170. second->cache_info.identity_digest,
  5171. DIGEST_LEN);
  5172. }
  5173. /** Sort a list of routerinfo_t in ascending order of identity digest. */
  5174. void
  5175. routers_sort_by_identity(smartlist_t *routers)
  5176. {
  5177. smartlist_sort(routers, compare_routerinfo_by_id_digest_);
  5178. }
  5179. /** Called when we change a node set, or when we reload the geoip IPv4 list:
  5180. * recompute all country info in all configuration node sets and in the
  5181. * routerlist. */
  5182. void
  5183. refresh_all_country_info(void)
  5184. {
  5185. const or_options_t *options = get_options();
  5186. if (options->EntryNodes)
  5187. routerset_refresh_countries(options->EntryNodes);
  5188. if (options->ExitNodes)
  5189. routerset_refresh_countries(options->ExitNodes);
  5190. if (options->ExcludeNodes)
  5191. routerset_refresh_countries(options->ExcludeNodes);
  5192. if (options->ExcludeExitNodes)
  5193. routerset_refresh_countries(options->ExcludeExitNodes);
  5194. if (options->ExcludeExitNodesUnion_)
  5195. routerset_refresh_countries(options->ExcludeExitNodesUnion_);
  5196. nodelist_refresh_countries();
  5197. }