control.c 245 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321
  1. /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  2. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  3. /* See LICENSE for licensing information */
  4. /**
  5. * \file control.c
  6. * \brief Implementation for Tor's control-socket interface.
  7. *
  8. * A "controller" is an external program that monitors and controls a Tor
  9. * instance via a text-based protocol. It connects to Tor via a connection
  10. * to a local socket.
  11. *
  12. * The protocol is line-driven. The controller sends commands terminated by a
  13. * CRLF. Tor sends lines that are either <em>replies</em> to what the
  14. * controller has said, or <em>events</em> that Tor sends to the controller
  15. * asynchronously based on occurrences in the Tor network model.
  16. *
  17. * See the control-spec.txt file in the torspec.git repository for full
  18. * details on protocol.
  19. *
  20. * This module generally has two kinds of entry points: those based on having
  21. * received a command on a controller socket, which are handled in
  22. * connection_control_process_inbuf(), and dispatched to individual functions
  23. * with names like control_handle_COMMANDNAME(); and those based on events
  24. * that occur elsewhere in Tor, which are handled by functions with names like
  25. * control_event_EVENTTYPE().
  26. *
  27. * Controller events are not sent immediately; rather, they are inserted into
  28. * the queued_control_events array, and flushed later from
  29. * flush_queued_events_cb(). Doing this simplifies our callgraph greatly,
  30. * by limiting the number of places in Tor that can call back into the network
  31. * stack.
  32. **/
  33. #define CONTROL_PRIVATE
  34. #include "or.h"
  35. #include "addressmap.h"
  36. #include "bridges.h"
  37. #include "buffers.h"
  38. #include "channel.h"
  39. #include "channeltls.h"
  40. #include "circuitbuild.h"
  41. #include "circuitlist.h"
  42. #include "circuitstats.h"
  43. #include "circuituse.h"
  44. #include "command.h"
  45. #include "compat_libevent.h"
  46. #include "config.h"
  47. #include "confparse.h"
  48. #include "connection.h"
  49. #include "connection_edge.h"
  50. #include "connection_or.h"
  51. #include "control.h"
  52. #include "directory.h"
  53. #include "dirserv.h"
  54. #include "dnsserv.h"
  55. #include "entrynodes.h"
  56. #include "geoip.h"
  57. #include "hibernate.h"
  58. #include "hs_common.h"
  59. #include "main.h"
  60. #include "microdesc.h"
  61. #include "networkstatus.h"
  62. #include "nodelist.h"
  63. #include "policies.h"
  64. #include "proto_control0.h"
  65. #include "proto_http.h"
  66. #include "reasons.h"
  67. #include "rendclient.h"
  68. #include "rendcommon.h"
  69. #include "rendservice.h"
  70. #include "rephist.h"
  71. #include "router.h"
  72. #include "routerlist.h"
  73. #include "routerparse.h"
  74. #include "shared_random.h"
  75. #ifndef _WIN32
  76. #include <pwd.h>
  77. #include <sys/resource.h>
  78. #endif
  79. #include <event2/event.h>
  80. #include "crypto_s2k.h"
  81. #include "procmon.h"
  82. /** Yield true iff <b>s</b> is the state of a control_connection_t that has
  83. * finished authentication and is accepting commands. */
  84. #define STATE_IS_OPEN(s) ((s) == CONTROL_CONN_STATE_OPEN)
  85. /** Bitfield: The bit 1&lt;&lt;e is set if <b>any</b> open control
  86. * connection is interested in events of type <b>e</b>. We use this
  87. * so that we can decide to skip generating event messages that nobody
  88. * has interest in without having to walk over the global connection
  89. * list to find out.
  90. **/
  91. typedef uint64_t event_mask_t;
  92. /** An event mask of all the events that any controller is interested in
  93. * receiving. */
  94. static event_mask_t global_event_mask = 0;
  95. /** True iff we have disabled log messages from being sent to the controller */
  96. static int disable_log_messages = 0;
  97. /** Macro: true if any control connection is interested in events of type
  98. * <b>e</b>. */
  99. #define EVENT_IS_INTERESTING(e) \
  100. (!! (global_event_mask & EVENT_MASK_(e)))
  101. /** If we're using cookie-type authentication, how long should our cookies be?
  102. */
  103. #define AUTHENTICATION_COOKIE_LEN 32
  104. /** If true, we've set authentication_cookie to a secret code and
  105. * stored it to disk. */
  106. static int authentication_cookie_is_set = 0;
  107. /** If authentication_cookie_is_set, a secret cookie that we've stored to disk
  108. * and which we're using to authenticate controllers. (If the controller can
  109. * read it off disk, it has permission to connect.) */
  110. static uint8_t *authentication_cookie = NULL;
  111. #define SAFECOOKIE_SERVER_TO_CONTROLLER_CONSTANT \
  112. "Tor safe cookie authentication server-to-controller hash"
  113. #define SAFECOOKIE_CONTROLLER_TO_SERVER_CONSTANT \
  114. "Tor safe cookie authentication controller-to-server hash"
  115. #define SAFECOOKIE_SERVER_NONCE_LEN DIGEST256_LEN
  116. /** The list of onion services that have been added via ADD_ONION that do not
  117. * belong to any particular control connection.
  118. */
  119. static smartlist_t *detached_onion_services = NULL;
  120. /** A sufficiently large size to record the last bootstrap phase string. */
  121. #define BOOTSTRAP_MSG_LEN 1024
  122. /** What was the last bootstrap phase message we sent? We keep track
  123. * of this so we can respond to getinfo status/bootstrap-phase queries. */
  124. static char last_sent_bootstrap_message[BOOTSTRAP_MSG_LEN];
  125. static void connection_printf_to_buf(control_connection_t *conn,
  126. const char *format, ...)
  127. CHECK_PRINTF(2,3);
  128. static void send_control_event_impl(uint16_t event,
  129. const char *format, va_list ap)
  130. CHECK_PRINTF(2,0);
  131. static int control_event_status(int type, int severity, const char *format,
  132. va_list args)
  133. CHECK_PRINTF(3,0);
  134. static void send_control_done(control_connection_t *conn);
  135. static void send_control_event(uint16_t event,
  136. const char *format, ...)
  137. CHECK_PRINTF(2,3);
  138. static int handle_control_setconf(control_connection_t *conn, uint32_t len,
  139. char *body);
  140. static int handle_control_resetconf(control_connection_t *conn, uint32_t len,
  141. char *body);
  142. static int handle_control_getconf(control_connection_t *conn, uint32_t len,
  143. const char *body);
  144. static int handle_control_loadconf(control_connection_t *conn, uint32_t len,
  145. const char *body);
  146. static int handle_control_setevents(control_connection_t *conn, uint32_t len,
  147. const char *body);
  148. static int handle_control_authenticate(control_connection_t *conn,
  149. uint32_t len,
  150. const char *body);
  151. static int handle_control_signal(control_connection_t *conn, uint32_t len,
  152. const char *body);
  153. static int handle_control_mapaddress(control_connection_t *conn, uint32_t len,
  154. const char *body);
  155. static char *list_getinfo_options(void);
  156. static int handle_control_getinfo(control_connection_t *conn, uint32_t len,
  157. const char *body);
  158. static int handle_control_extendcircuit(control_connection_t *conn,
  159. uint32_t len,
  160. const char *body);
  161. static int handle_control_setcircuitpurpose(control_connection_t *conn,
  162. uint32_t len, const char *body);
  163. static int handle_control_attachstream(control_connection_t *conn,
  164. uint32_t len,
  165. const char *body);
  166. static int handle_control_postdescriptor(control_connection_t *conn,
  167. uint32_t len,
  168. const char *body);
  169. static int handle_control_redirectstream(control_connection_t *conn,
  170. uint32_t len,
  171. const char *body);
  172. static int handle_control_closestream(control_connection_t *conn, uint32_t len,
  173. const char *body);
  174. static int handle_control_closecircuit(control_connection_t *conn,
  175. uint32_t len,
  176. const char *body);
  177. static int handle_control_resolve(control_connection_t *conn, uint32_t len,
  178. const char *body);
  179. static int handle_control_usefeature(control_connection_t *conn,
  180. uint32_t len,
  181. const char *body);
  182. static int handle_control_hsfetch(control_connection_t *conn, uint32_t len,
  183. const char *body);
  184. static int handle_control_hspost(control_connection_t *conn, uint32_t len,
  185. const char *body);
  186. static int handle_control_add_onion(control_connection_t *conn, uint32_t len,
  187. const char *body);
  188. static int handle_control_del_onion(control_connection_t *conn, uint32_t len,
  189. const char *body);
  190. static int write_stream_target_to_buf(entry_connection_t *conn, char *buf,
  191. size_t len);
  192. static void orconn_target_get_name(char *buf, size_t len,
  193. or_connection_t *conn);
  194. static int get_cached_network_liveness(void);
  195. static void set_cached_network_liveness(int liveness);
  196. static void flush_queued_events_cb(evutil_socket_t fd, short what, void *arg);
  197. static char * download_status_to_string(const download_status_t *dl);
  198. /** Given a control event code for a message event, return the corresponding
  199. * log severity. */
  200. static inline int
  201. event_to_log_severity(int event)
  202. {
  203. switch (event) {
  204. case EVENT_DEBUG_MSG: return LOG_DEBUG;
  205. case EVENT_INFO_MSG: return LOG_INFO;
  206. case EVENT_NOTICE_MSG: return LOG_NOTICE;
  207. case EVENT_WARN_MSG: return LOG_WARN;
  208. case EVENT_ERR_MSG: return LOG_ERR;
  209. default: return -1;
  210. }
  211. }
  212. /** Given a log severity, return the corresponding control event code. */
  213. static inline int
  214. log_severity_to_event(int severity)
  215. {
  216. switch (severity) {
  217. case LOG_DEBUG: return EVENT_DEBUG_MSG;
  218. case LOG_INFO: return EVENT_INFO_MSG;
  219. case LOG_NOTICE: return EVENT_NOTICE_MSG;
  220. case LOG_WARN: return EVENT_WARN_MSG;
  221. case LOG_ERR: return EVENT_ERR_MSG;
  222. default: return -1;
  223. }
  224. }
  225. /** Helper: clear bandwidth counters of all origin circuits. */
  226. static void
  227. clear_circ_bw_fields(void)
  228. {
  229. origin_circuit_t *ocirc;
  230. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  231. if (!CIRCUIT_IS_ORIGIN(circ))
  232. continue;
  233. ocirc = TO_ORIGIN_CIRCUIT(circ);
  234. ocirc->n_written_circ_bw = ocirc->n_read_circ_bw = 0;
  235. }
  236. SMARTLIST_FOREACH_END(circ);
  237. }
  238. /** Set <b>global_event_mask*</b> to the bitwise OR of each live control
  239. * connection's event_mask field. */
  240. void
  241. control_update_global_event_mask(void)
  242. {
  243. smartlist_t *conns = get_connection_array();
  244. event_mask_t old_mask, new_mask;
  245. old_mask = global_event_mask;
  246. global_event_mask = 0;
  247. SMARTLIST_FOREACH(conns, connection_t *, _conn,
  248. {
  249. if (_conn->type == CONN_TYPE_CONTROL &&
  250. STATE_IS_OPEN(_conn->state)) {
  251. control_connection_t *conn = TO_CONTROL_CONN(_conn);
  252. global_event_mask |= conn->event_mask;
  253. }
  254. });
  255. new_mask = global_event_mask;
  256. /* Handle the aftermath. Set up the log callback to tell us only what
  257. * we want to hear...*/
  258. control_adjust_event_log_severity();
  259. /* ...then, if we've started logging stream or circ bw, clear the
  260. * appropriate fields. */
  261. if (! (old_mask & EVENT_STREAM_BANDWIDTH_USED) &&
  262. (new_mask & EVENT_STREAM_BANDWIDTH_USED)) {
  263. SMARTLIST_FOREACH(conns, connection_t *, conn,
  264. {
  265. if (conn->type == CONN_TYPE_AP) {
  266. edge_connection_t *edge_conn = TO_EDGE_CONN(conn);
  267. edge_conn->n_written = edge_conn->n_read = 0;
  268. }
  269. });
  270. }
  271. if (! (old_mask & EVENT_CIRC_BANDWIDTH_USED) &&
  272. (new_mask & EVENT_CIRC_BANDWIDTH_USED)) {
  273. clear_circ_bw_fields();
  274. }
  275. }
  276. /** Adjust the log severities that result in control_event_logmsg being called
  277. * to match the severity of log messages that any controllers are interested
  278. * in. */
  279. void
  280. control_adjust_event_log_severity(void)
  281. {
  282. int i;
  283. int min_log_event=EVENT_ERR_MSG, max_log_event=EVENT_DEBUG_MSG;
  284. for (i = EVENT_DEBUG_MSG; i <= EVENT_ERR_MSG; ++i) {
  285. if (EVENT_IS_INTERESTING(i)) {
  286. min_log_event = i;
  287. break;
  288. }
  289. }
  290. for (i = EVENT_ERR_MSG; i >= EVENT_DEBUG_MSG; --i) {
  291. if (EVENT_IS_INTERESTING(i)) {
  292. max_log_event = i;
  293. break;
  294. }
  295. }
  296. if (EVENT_IS_INTERESTING(EVENT_STATUS_GENERAL)) {
  297. if (min_log_event > EVENT_NOTICE_MSG)
  298. min_log_event = EVENT_NOTICE_MSG;
  299. if (max_log_event < EVENT_ERR_MSG)
  300. max_log_event = EVENT_ERR_MSG;
  301. }
  302. if (min_log_event <= max_log_event)
  303. change_callback_log_severity(event_to_log_severity(min_log_event),
  304. event_to_log_severity(max_log_event),
  305. control_event_logmsg);
  306. else
  307. change_callback_log_severity(LOG_ERR, LOG_ERR,
  308. control_event_logmsg);
  309. }
  310. /** Return true iff the event with code <b>c</b> is being sent to any current
  311. * control connection. This is useful if the amount of work needed to prepare
  312. * to call the appropriate control_event_...() function is high.
  313. */
  314. int
  315. control_event_is_interesting(int event)
  316. {
  317. return EVENT_IS_INTERESTING(event);
  318. }
  319. /** Append a NUL-terminated string <b>s</b> to the end of
  320. * <b>conn</b>-\>outbuf.
  321. */
  322. static inline void
  323. connection_write_str_to_buf(const char *s, control_connection_t *conn)
  324. {
  325. size_t len = strlen(s);
  326. connection_buf_add(s, len, TO_CONN(conn));
  327. }
  328. /** Given a <b>len</b>-character string in <b>data</b>, made of lines
  329. * terminated by CRLF, allocate a new string in *<b>out</b>, and copy the
  330. * contents of <b>data</b> into *<b>out</b>, adding a period before any period
  331. * that appears at the start of a line, and adding a period-CRLF line at
  332. * the end. Replace all LF characters sequences with CRLF. Return the number
  333. * of bytes in *<b>out</b>.
  334. */
  335. STATIC size_t
  336. write_escaped_data(const char *data, size_t len, char **out)
  337. {
  338. tor_assert(len < SIZE_MAX - 9);
  339. size_t sz_out = len+8+1;
  340. char *outp;
  341. const char *start = data, *end;
  342. size_t i;
  343. int start_of_line;
  344. for (i=0; i < len; ++i) {
  345. if (data[i] == '\n') {
  346. sz_out += 2; /* Maybe add a CR; maybe add a dot. */
  347. if (sz_out >= SIZE_T_CEILING) {
  348. log_warn(LD_BUG, "Input to write_escaped_data was too long");
  349. *out = tor_strdup(".\r\n");
  350. return 3;
  351. }
  352. }
  353. }
  354. *out = outp = tor_malloc(sz_out);
  355. end = data+len;
  356. start_of_line = 1;
  357. while (data < end) {
  358. if (*data == '\n') {
  359. if (data > start && data[-1] != '\r')
  360. *outp++ = '\r';
  361. start_of_line = 1;
  362. } else if (*data == '.') {
  363. if (start_of_line) {
  364. start_of_line = 0;
  365. *outp++ = '.';
  366. }
  367. } else {
  368. start_of_line = 0;
  369. }
  370. *outp++ = *data++;
  371. }
  372. if (outp < *out+2 || fast_memcmp(outp-2, "\r\n", 2)) {
  373. *outp++ = '\r';
  374. *outp++ = '\n';
  375. }
  376. *outp++ = '.';
  377. *outp++ = '\r';
  378. *outp++ = '\n';
  379. *outp = '\0'; /* NUL-terminate just in case. */
  380. tor_assert(outp >= *out);
  381. tor_assert((size_t)(outp - *out) <= sz_out);
  382. return outp - *out;
  383. }
  384. /** Given a <b>len</b>-character string in <b>data</b>, made of lines
  385. * terminated by CRLF, allocate a new string in *<b>out</b>, and copy
  386. * the contents of <b>data</b> into *<b>out</b>, removing any period
  387. * that appears at the start of a line, and replacing all CRLF sequences
  388. * with LF. Return the number of
  389. * bytes in *<b>out</b>. */
  390. STATIC size_t
  391. read_escaped_data(const char *data, size_t len, char **out)
  392. {
  393. char *outp;
  394. const char *next;
  395. const char *end;
  396. *out = outp = tor_malloc(len+1);
  397. end = data+len;
  398. while (data < end) {
  399. /* we're at the start of a line. */
  400. if (*data == '.')
  401. ++data;
  402. next = memchr(data, '\n', end-data);
  403. if (next) {
  404. size_t n_to_copy = next-data;
  405. /* Don't copy a CR that precedes this LF. */
  406. if (n_to_copy && *(next-1) == '\r')
  407. --n_to_copy;
  408. memcpy(outp, data, n_to_copy);
  409. outp += n_to_copy;
  410. data = next+1; /* This will point at the start of the next line,
  411. * or the end of the string, or a period. */
  412. } else {
  413. memcpy(outp, data, end-data);
  414. outp += (end-data);
  415. *outp = '\0';
  416. return outp - *out;
  417. }
  418. *outp++ = '\n';
  419. }
  420. *outp = '\0';
  421. return outp - *out;
  422. }
  423. /** If the first <b>in_len_max</b> characters in <b>start</b> contain a
  424. * double-quoted string with escaped characters, return the length of that
  425. * string (as encoded, including quotes). Otherwise return -1. */
  426. static inline int
  427. get_escaped_string_length(const char *start, size_t in_len_max,
  428. int *chars_out)
  429. {
  430. const char *cp, *end;
  431. int chars = 0;
  432. if (*start != '\"')
  433. return -1;
  434. cp = start+1;
  435. end = start+in_len_max;
  436. /* Calculate length. */
  437. while (1) {
  438. if (cp >= end) {
  439. return -1; /* Too long. */
  440. } else if (*cp == '\\') {
  441. if (++cp == end)
  442. return -1; /* Can't escape EOS. */
  443. ++cp;
  444. ++chars;
  445. } else if (*cp == '\"') {
  446. break;
  447. } else {
  448. ++cp;
  449. ++chars;
  450. }
  451. }
  452. if (chars_out)
  453. *chars_out = chars;
  454. return (int)(cp - start+1);
  455. }
  456. /** As decode_escaped_string, but does not decode the string: copies the
  457. * entire thing, including quotation marks. */
  458. static const char *
  459. extract_escaped_string(const char *start, size_t in_len_max,
  460. char **out, size_t *out_len)
  461. {
  462. int length = get_escaped_string_length(start, in_len_max, NULL);
  463. if (length<0)
  464. return NULL;
  465. *out_len = length;
  466. *out = tor_strndup(start, *out_len);
  467. return start+length;
  468. }
  469. /** Given a pointer to a string starting at <b>start</b> containing
  470. * <b>in_len_max</b> characters, decode a string beginning with one double
  471. * quote, containing any number of non-quote characters or characters escaped
  472. * with a backslash, and ending with a final double quote. Place the resulting
  473. * string (unquoted, unescaped) into a newly allocated string in *<b>out</b>;
  474. * store its length in <b>out_len</b>. On success, return a pointer to the
  475. * character immediately following the escaped string. On failure, return
  476. * NULL. */
  477. static const char *
  478. decode_escaped_string(const char *start, size_t in_len_max,
  479. char **out, size_t *out_len)
  480. {
  481. const char *cp, *end;
  482. char *outp;
  483. int len, n_chars = 0;
  484. len = get_escaped_string_length(start, in_len_max, &n_chars);
  485. if (len<0)
  486. return NULL;
  487. end = start+len-1; /* Index of last quote. */
  488. tor_assert(*end == '\"');
  489. outp = *out = tor_malloc(len+1);
  490. *out_len = n_chars;
  491. cp = start+1;
  492. while (cp < end) {
  493. if (*cp == '\\')
  494. ++cp;
  495. *outp++ = *cp++;
  496. }
  497. *outp = '\0';
  498. tor_assert((outp - *out) == (int)*out_len);
  499. return end+1;
  500. }
  501. /** Acts like sprintf, but writes its formatted string to the end of
  502. * <b>conn</b>-\>outbuf. */
  503. static void
  504. connection_printf_to_buf(control_connection_t *conn, const char *format, ...)
  505. {
  506. va_list ap;
  507. char *buf = NULL;
  508. int len;
  509. va_start(ap,format);
  510. len = tor_vasprintf(&buf, format, ap);
  511. va_end(ap);
  512. if (len < 0) {
  513. log_err(LD_BUG, "Unable to format string for controller.");
  514. tor_assert(0);
  515. }
  516. connection_buf_add(buf, (size_t)len, TO_CONN(conn));
  517. tor_free(buf);
  518. }
  519. /** Write all of the open control ports to ControlPortWriteToFile */
  520. void
  521. control_ports_write_to_file(void)
  522. {
  523. smartlist_t *lines;
  524. char *joined = NULL;
  525. const or_options_t *options = get_options();
  526. if (!options->ControlPortWriteToFile)
  527. return;
  528. lines = smartlist_new();
  529. SMARTLIST_FOREACH_BEGIN(get_connection_array(), const connection_t *, conn) {
  530. if (conn->type != CONN_TYPE_CONTROL_LISTENER || conn->marked_for_close)
  531. continue;
  532. #ifdef AF_UNIX
  533. if (conn->socket_family == AF_UNIX) {
  534. smartlist_add_asprintf(lines, "UNIX_PORT=%s\n", conn->address);
  535. continue;
  536. }
  537. #endif /* defined(AF_UNIX) */
  538. smartlist_add_asprintf(lines, "PORT=%s:%d\n", conn->address, conn->port);
  539. } SMARTLIST_FOREACH_END(conn);
  540. joined = smartlist_join_strings(lines, "", 0, NULL);
  541. if (write_str_to_file(options->ControlPortWriteToFile, joined, 0) < 0) {
  542. log_warn(LD_CONTROL, "Writing %s failed: %s",
  543. options->ControlPortWriteToFile, strerror(errno));
  544. }
  545. #ifndef _WIN32
  546. if (options->ControlPortFileGroupReadable) {
  547. if (chmod(options->ControlPortWriteToFile, 0640)) {
  548. log_warn(LD_FS,"Unable to make %s group-readable.",
  549. options->ControlPortWriteToFile);
  550. }
  551. }
  552. #endif /* !defined(_WIN32) */
  553. tor_free(joined);
  554. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  555. smartlist_free(lines);
  556. }
  557. /** Send a "DONE" message down the control connection <b>conn</b>. */
  558. static void
  559. send_control_done(control_connection_t *conn)
  560. {
  561. connection_write_str_to_buf("250 OK\r\n", conn);
  562. }
  563. /** Represents an event that's queued to be sent to one or more
  564. * controllers. */
  565. typedef struct queued_event_s {
  566. uint16_t event;
  567. char *msg;
  568. } queued_event_t;
  569. /** Pointer to int. If this is greater than 0, we don't allow new events to be
  570. * queued. */
  571. static tor_threadlocal_t block_event_queue_flag;
  572. /** Holds a smartlist of queued_event_t objects that may need to be sent
  573. * to one or more controllers */
  574. static smartlist_t *queued_control_events = NULL;
  575. /** True if the flush_queued_events_event is pending. */
  576. static int flush_queued_event_pending = 0;
  577. /** Lock to protect the above fields. */
  578. static tor_mutex_t *queued_control_events_lock = NULL;
  579. /** An event that should fire in order to flush the contents of
  580. * queued_control_events. */
  581. static struct event *flush_queued_events_event = NULL;
  582. void
  583. control_initialize_event_queue(void)
  584. {
  585. if (queued_control_events == NULL) {
  586. queued_control_events = smartlist_new();
  587. }
  588. if (flush_queued_events_event == NULL) {
  589. struct event_base *b = tor_libevent_get_base();
  590. if (b) {
  591. flush_queued_events_event = tor_event_new(b,
  592. -1, 0, flush_queued_events_cb,
  593. NULL);
  594. tor_assert(flush_queued_events_event);
  595. }
  596. }
  597. if (queued_control_events_lock == NULL) {
  598. queued_control_events_lock = tor_mutex_new();
  599. tor_threadlocal_init(&block_event_queue_flag);
  600. }
  601. }
  602. static int *
  603. get_block_event_queue(void)
  604. {
  605. int *val = tor_threadlocal_get(&block_event_queue_flag);
  606. if (PREDICT_UNLIKELY(val == NULL)) {
  607. val = tor_malloc_zero(sizeof(int));
  608. tor_threadlocal_set(&block_event_queue_flag, val);
  609. }
  610. return val;
  611. }
  612. /** Helper: inserts an event on the list of events queued to be sent to
  613. * one or more controllers, and schedules the events to be flushed if needed.
  614. *
  615. * This function takes ownership of <b>msg</b>, and may free it.
  616. *
  617. * We queue these events rather than send them immediately in order to break
  618. * the dependency in our callgraph from code that generates events for the
  619. * controller, and the network layer at large. Otherwise, nearly every
  620. * interesting part of Tor would potentially call every other interesting part
  621. * of Tor.
  622. */
  623. MOCK_IMPL(STATIC void,
  624. queue_control_event_string,(uint16_t event, char *msg))
  625. {
  626. /* This is redundant with checks done elsewhere, but it's a last-ditch
  627. * attempt to avoid queueing something we shouldn't have to queue. */
  628. if (PREDICT_UNLIKELY( ! EVENT_IS_INTERESTING(event) )) {
  629. tor_free(msg);
  630. return;
  631. }
  632. int *block_event_queue = get_block_event_queue();
  633. if (*block_event_queue) {
  634. tor_free(msg);
  635. return;
  636. }
  637. queued_event_t *ev = tor_malloc(sizeof(*ev));
  638. ev->event = event;
  639. ev->msg = msg;
  640. /* No queueing an event while queueing an event */
  641. ++*block_event_queue;
  642. tor_mutex_acquire(queued_control_events_lock);
  643. tor_assert(queued_control_events);
  644. smartlist_add(queued_control_events, ev);
  645. int activate_event = 0;
  646. if (! flush_queued_event_pending && in_main_thread()) {
  647. activate_event = 1;
  648. flush_queued_event_pending = 1;
  649. }
  650. tor_mutex_release(queued_control_events_lock);
  651. --*block_event_queue;
  652. /* We just put an event on the queue; mark the queue to be
  653. * flushed. We only do this from the main thread for now; otherwise,
  654. * we'd need to incur locking overhead in Libevent or use a socket.
  655. */
  656. if (activate_event) {
  657. tor_assert(flush_queued_events_event);
  658. event_active(flush_queued_events_event, EV_READ, 1);
  659. }
  660. }
  661. /** Release all storage held by <b>ev</b>. */
  662. static void
  663. queued_event_free(queued_event_t *ev)
  664. {
  665. if (ev == NULL)
  666. return;
  667. tor_free(ev->msg);
  668. tor_free(ev);
  669. }
  670. /** Send every queued event to every controller that's interested in it,
  671. * and remove the events from the queue. If <b>force</b> is true,
  672. * then make all controllers send their data out immediately, since we
  673. * may be about to shut down. */
  674. static void
  675. queued_events_flush_all(int force)
  676. {
  677. if (PREDICT_UNLIKELY(queued_control_events == NULL)) {
  678. return;
  679. }
  680. smartlist_t *all_conns = get_connection_array();
  681. smartlist_t *controllers = smartlist_new();
  682. smartlist_t *queued_events;
  683. int *block_event_queue = get_block_event_queue();
  684. ++*block_event_queue;
  685. tor_mutex_acquire(queued_control_events_lock);
  686. /* No queueing an event while flushing events. */
  687. flush_queued_event_pending = 0;
  688. queued_events = queued_control_events;
  689. queued_control_events = smartlist_new();
  690. tor_mutex_release(queued_control_events_lock);
  691. /* Gather all the controllers that will care... */
  692. SMARTLIST_FOREACH_BEGIN(all_conns, connection_t *, conn) {
  693. if (conn->type == CONN_TYPE_CONTROL &&
  694. !conn->marked_for_close &&
  695. conn->state == CONTROL_CONN_STATE_OPEN) {
  696. control_connection_t *control_conn = TO_CONTROL_CONN(conn);
  697. smartlist_add(controllers, control_conn);
  698. }
  699. } SMARTLIST_FOREACH_END(conn);
  700. SMARTLIST_FOREACH_BEGIN(queued_events, queued_event_t *, ev) {
  701. const event_mask_t bit = ((event_mask_t)1) << ev->event;
  702. const size_t msg_len = strlen(ev->msg);
  703. SMARTLIST_FOREACH_BEGIN(controllers, control_connection_t *,
  704. control_conn) {
  705. if (control_conn->event_mask & bit) {
  706. connection_buf_add(ev->msg, msg_len, TO_CONN(control_conn));
  707. }
  708. } SMARTLIST_FOREACH_END(control_conn);
  709. queued_event_free(ev);
  710. } SMARTLIST_FOREACH_END(ev);
  711. if (force) {
  712. SMARTLIST_FOREACH_BEGIN(controllers, control_connection_t *,
  713. control_conn) {
  714. connection_flush(TO_CONN(control_conn));
  715. } SMARTLIST_FOREACH_END(control_conn);
  716. }
  717. smartlist_free(queued_events);
  718. smartlist_free(controllers);
  719. --*block_event_queue;
  720. }
  721. /** Libevent callback: Flushes pending events to controllers that are
  722. * interested in them. */
  723. static void
  724. flush_queued_events_cb(evutil_socket_t fd, short what, void *arg)
  725. {
  726. (void) fd;
  727. (void) what;
  728. (void) arg;
  729. queued_events_flush_all(0);
  730. }
  731. /** Send an event to all v1 controllers that are listening for code
  732. * <b>event</b>. The event's body is given by <b>msg</b>.
  733. *
  734. * The EXTENDED_FORMAT and NONEXTENDED_FORMAT flags behave similarly with
  735. * respect to the EXTENDED_EVENTS feature. */
  736. MOCK_IMPL(STATIC void,
  737. send_control_event_string,(uint16_t event,
  738. const char *msg))
  739. {
  740. tor_assert(event >= EVENT_MIN_ && event <= EVENT_MAX_);
  741. queue_control_event_string(event, tor_strdup(msg));
  742. }
  743. /** Helper for send_control_event and control_event_status:
  744. * Send an event to all v1 controllers that are listening for code
  745. * <b>event</b>. The event's body is created by the printf-style format in
  746. * <b>format</b>, and other arguments as provided. */
  747. static void
  748. send_control_event_impl(uint16_t event,
  749. const char *format, va_list ap)
  750. {
  751. char *buf = NULL;
  752. int len;
  753. len = tor_vasprintf(&buf, format, ap);
  754. if (len < 0) {
  755. log_warn(LD_BUG, "Unable to format event for controller.");
  756. return;
  757. }
  758. queue_control_event_string(event, buf);
  759. }
  760. /** Send an event to all v1 controllers that are listening for code
  761. * <b>event</b>. The event's body is created by the printf-style format in
  762. * <b>format</b>, and other arguments as provided. */
  763. static void
  764. send_control_event(uint16_t event,
  765. const char *format, ...)
  766. {
  767. va_list ap;
  768. va_start(ap, format);
  769. send_control_event_impl(event, format, ap);
  770. va_end(ap);
  771. }
  772. /** Given a text circuit <b>id</b>, return the corresponding circuit. */
  773. static origin_circuit_t *
  774. get_circ(const char *id)
  775. {
  776. uint32_t n_id;
  777. int ok;
  778. n_id = (uint32_t) tor_parse_ulong(id, 10, 0, UINT32_MAX, &ok, NULL);
  779. if (!ok)
  780. return NULL;
  781. return circuit_get_by_global_id(n_id);
  782. }
  783. /** Given a text stream <b>id</b>, return the corresponding AP connection. */
  784. static entry_connection_t *
  785. get_stream(const char *id)
  786. {
  787. uint64_t n_id;
  788. int ok;
  789. connection_t *conn;
  790. n_id = tor_parse_uint64(id, 10, 0, UINT64_MAX, &ok, NULL);
  791. if (!ok)
  792. return NULL;
  793. conn = connection_get_by_global_id(n_id);
  794. if (!conn || conn->type != CONN_TYPE_AP || conn->marked_for_close)
  795. return NULL;
  796. return TO_ENTRY_CONN(conn);
  797. }
  798. /** Helper for setconf and resetconf. Acts like setconf, except
  799. * it passes <b>use_defaults</b> on to options_trial_assign(). Modifies the
  800. * contents of body.
  801. */
  802. static int
  803. control_setconf_helper(control_connection_t *conn, uint32_t len, char *body,
  804. int use_defaults)
  805. {
  806. setopt_err_t opt_err;
  807. config_line_t *lines=NULL;
  808. char *start = body;
  809. char *errstring = NULL;
  810. const unsigned flags =
  811. CAL_CLEAR_FIRST | (use_defaults ? CAL_USE_DEFAULTS : 0);
  812. char *config;
  813. smartlist_t *entries = smartlist_new();
  814. /* We have a string, "body", of the format '(key(=val|="val")?)' entries
  815. * separated by space. break it into a list of configuration entries. */
  816. while (*body) {
  817. char *eq = body;
  818. char *key;
  819. char *entry;
  820. while (!TOR_ISSPACE(*eq) && *eq != '=')
  821. ++eq;
  822. key = tor_strndup(body, eq-body);
  823. body = eq+1;
  824. if (*eq == '=') {
  825. char *val=NULL;
  826. size_t val_len=0;
  827. if (*body != '\"') {
  828. char *val_start = body;
  829. while (!TOR_ISSPACE(*body))
  830. body++;
  831. val = tor_strndup(val_start, body-val_start);
  832. val_len = strlen(val);
  833. } else {
  834. body = (char*)extract_escaped_string(body, (len - (body-start)),
  835. &val, &val_len);
  836. if (!body) {
  837. connection_write_str_to_buf("551 Couldn't parse string\r\n", conn);
  838. SMARTLIST_FOREACH(entries, char *, cp, tor_free(cp));
  839. smartlist_free(entries);
  840. tor_free(key);
  841. return 0;
  842. }
  843. }
  844. tor_asprintf(&entry, "%s %s", key, val);
  845. tor_free(key);
  846. tor_free(val);
  847. } else {
  848. entry = key;
  849. }
  850. smartlist_add(entries, entry);
  851. while (TOR_ISSPACE(*body))
  852. ++body;
  853. }
  854. smartlist_add_strdup(entries, "");
  855. config = smartlist_join_strings(entries, "\n", 0, NULL);
  856. SMARTLIST_FOREACH(entries, char *, cp, tor_free(cp));
  857. smartlist_free(entries);
  858. if (config_get_lines(config, &lines, 0) < 0) {
  859. log_warn(LD_CONTROL,"Controller gave us config lines we can't parse.");
  860. connection_write_str_to_buf("551 Couldn't parse configuration\r\n",
  861. conn);
  862. tor_free(config);
  863. return 0;
  864. }
  865. tor_free(config);
  866. opt_err = options_trial_assign(lines, flags, &errstring);
  867. {
  868. const char *msg;
  869. switch (opt_err) {
  870. case SETOPT_ERR_MISC:
  871. msg = "552 Unrecognized option";
  872. break;
  873. case SETOPT_ERR_PARSE:
  874. msg = "513 Unacceptable option value";
  875. break;
  876. case SETOPT_ERR_TRANSITION:
  877. msg = "553 Transition not allowed";
  878. break;
  879. case SETOPT_ERR_SETTING:
  880. default:
  881. msg = "553 Unable to set option";
  882. break;
  883. case SETOPT_OK:
  884. config_free_lines(lines);
  885. send_control_done(conn);
  886. return 0;
  887. }
  888. log_warn(LD_CONTROL,
  889. "Controller gave us config lines that didn't validate: %s",
  890. errstring);
  891. connection_printf_to_buf(conn, "%s: %s\r\n", msg, errstring);
  892. config_free_lines(lines);
  893. tor_free(errstring);
  894. return 0;
  895. }
  896. }
  897. /** Called when we receive a SETCONF message: parse the body and try
  898. * to update our configuration. Reply with a DONE or ERROR message.
  899. * Modifies the contents of body.*/
  900. static int
  901. handle_control_setconf(control_connection_t *conn, uint32_t len, char *body)
  902. {
  903. return control_setconf_helper(conn, len, body, 0);
  904. }
  905. /** Called when we receive a RESETCONF message: parse the body and try
  906. * to update our configuration. Reply with a DONE or ERROR message.
  907. * Modifies the contents of body. */
  908. static int
  909. handle_control_resetconf(control_connection_t *conn, uint32_t len, char *body)
  910. {
  911. return control_setconf_helper(conn, len, body, 1);
  912. }
  913. /** Called when we receive a GETCONF message. Parse the request, and
  914. * reply with a CONFVALUE or an ERROR message */
  915. static int
  916. handle_control_getconf(control_connection_t *conn, uint32_t body_len,
  917. const char *body)
  918. {
  919. smartlist_t *questions = smartlist_new();
  920. smartlist_t *answers = smartlist_new();
  921. smartlist_t *unrecognized = smartlist_new();
  922. char *msg = NULL;
  923. size_t msg_len;
  924. const or_options_t *options = get_options();
  925. int i, len;
  926. (void) body_len; /* body is NUL-terminated; so we can ignore len. */
  927. smartlist_split_string(questions, body, " ",
  928. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  929. SMARTLIST_FOREACH_BEGIN(questions, const char *, q) {
  930. if (!option_is_recognized(q)) {
  931. smartlist_add(unrecognized, (char*) q);
  932. } else {
  933. config_line_t *answer = option_get_assignment(options,q);
  934. if (!answer) {
  935. const char *name = option_get_canonical_name(q);
  936. smartlist_add_asprintf(answers, "250-%s\r\n", name);
  937. }
  938. while (answer) {
  939. config_line_t *next;
  940. smartlist_add_asprintf(answers, "250-%s=%s\r\n",
  941. answer->key, answer->value);
  942. next = answer->next;
  943. tor_free(answer->key);
  944. tor_free(answer->value);
  945. tor_free(answer);
  946. answer = next;
  947. }
  948. }
  949. } SMARTLIST_FOREACH_END(q);
  950. if ((len = smartlist_len(unrecognized))) {
  951. for (i=0; i < len-1; ++i)
  952. connection_printf_to_buf(conn,
  953. "552-Unrecognized configuration key \"%s\"\r\n",
  954. (char*)smartlist_get(unrecognized, i));
  955. connection_printf_to_buf(conn,
  956. "552 Unrecognized configuration key \"%s\"\r\n",
  957. (char*)smartlist_get(unrecognized, len-1));
  958. } else if ((len = smartlist_len(answers))) {
  959. char *tmp = smartlist_get(answers, len-1);
  960. tor_assert(strlen(tmp)>4);
  961. tmp[3] = ' ';
  962. msg = smartlist_join_strings(answers, "", 0, &msg_len);
  963. connection_buf_add(msg, msg_len, TO_CONN(conn));
  964. } else {
  965. connection_write_str_to_buf("250 OK\r\n", conn);
  966. }
  967. SMARTLIST_FOREACH(answers, char *, cp, tor_free(cp));
  968. smartlist_free(answers);
  969. SMARTLIST_FOREACH(questions, char *, cp, tor_free(cp));
  970. smartlist_free(questions);
  971. smartlist_free(unrecognized);
  972. tor_free(msg);
  973. return 0;
  974. }
  975. /** Called when we get a +LOADCONF message. */
  976. static int
  977. handle_control_loadconf(control_connection_t *conn, uint32_t len,
  978. const char *body)
  979. {
  980. setopt_err_t retval;
  981. char *errstring = NULL;
  982. const char *msg = NULL;
  983. (void) len;
  984. retval = options_init_from_string(NULL, body, CMD_RUN_TOR, NULL, &errstring);
  985. if (retval != SETOPT_OK)
  986. log_warn(LD_CONTROL,
  987. "Controller gave us config file that didn't validate: %s",
  988. errstring);
  989. switch (retval) {
  990. case SETOPT_ERR_PARSE:
  991. msg = "552 Invalid config file";
  992. break;
  993. case SETOPT_ERR_TRANSITION:
  994. msg = "553 Transition not allowed";
  995. break;
  996. case SETOPT_ERR_SETTING:
  997. msg = "553 Unable to set option";
  998. break;
  999. case SETOPT_ERR_MISC:
  1000. default:
  1001. msg = "550 Unable to load config";
  1002. break;
  1003. case SETOPT_OK:
  1004. break;
  1005. }
  1006. if (msg) {
  1007. if (errstring)
  1008. connection_printf_to_buf(conn, "%s: %s\r\n", msg, errstring);
  1009. else
  1010. connection_printf_to_buf(conn, "%s\r\n", msg);
  1011. } else {
  1012. send_control_done(conn);
  1013. }
  1014. tor_free(errstring);
  1015. return 0;
  1016. }
  1017. /** Helper structure: maps event values to their names. */
  1018. struct control_event_t {
  1019. uint16_t event_code;
  1020. const char *event_name;
  1021. };
  1022. /** Table mapping event values to their names. Used to implement SETEVENTS
  1023. * and GETINFO events/names, and to keep they in sync. */
  1024. static const struct control_event_t control_event_table[] = {
  1025. { EVENT_CIRCUIT_STATUS, "CIRC" },
  1026. { EVENT_CIRCUIT_STATUS_MINOR, "CIRC_MINOR" },
  1027. { EVENT_STREAM_STATUS, "STREAM" },
  1028. { EVENT_OR_CONN_STATUS, "ORCONN" },
  1029. { EVENT_BANDWIDTH_USED, "BW" },
  1030. { EVENT_DEBUG_MSG, "DEBUG" },
  1031. { EVENT_INFO_MSG, "INFO" },
  1032. { EVENT_NOTICE_MSG, "NOTICE" },
  1033. { EVENT_WARN_MSG, "WARN" },
  1034. { EVENT_ERR_MSG, "ERR" },
  1035. { EVENT_NEW_DESC, "NEWDESC" },
  1036. { EVENT_ADDRMAP, "ADDRMAP" },
  1037. { EVENT_DESCCHANGED, "DESCCHANGED" },
  1038. { EVENT_NS, "NS" },
  1039. { EVENT_STATUS_GENERAL, "STATUS_GENERAL" },
  1040. { EVENT_STATUS_CLIENT, "STATUS_CLIENT" },
  1041. { EVENT_STATUS_SERVER, "STATUS_SERVER" },
  1042. { EVENT_GUARD, "GUARD" },
  1043. { EVENT_STREAM_BANDWIDTH_USED, "STREAM_BW" },
  1044. { EVENT_CLIENTS_SEEN, "CLIENTS_SEEN" },
  1045. { EVENT_NEWCONSENSUS, "NEWCONSENSUS" },
  1046. { EVENT_BUILDTIMEOUT_SET, "BUILDTIMEOUT_SET" },
  1047. { EVENT_GOT_SIGNAL, "SIGNAL" },
  1048. { EVENT_CONF_CHANGED, "CONF_CHANGED"},
  1049. { EVENT_CONN_BW, "CONN_BW" },
  1050. { EVENT_CELL_STATS, "CELL_STATS" },
  1051. { EVENT_TB_EMPTY, "TB_EMPTY" },
  1052. { EVENT_CIRC_BANDWIDTH_USED, "CIRC_BW" },
  1053. { EVENT_TRANSPORT_LAUNCHED, "TRANSPORT_LAUNCHED" },
  1054. { EVENT_HS_DESC, "HS_DESC" },
  1055. { EVENT_HS_DESC_CONTENT, "HS_DESC_CONTENT" },
  1056. { EVENT_NETWORK_LIVENESS, "NETWORK_LIVENESS" },
  1057. { 0, NULL },
  1058. };
  1059. /** Called when we get a SETEVENTS message: update conn->event_mask,
  1060. * and reply with DONE or ERROR. */
  1061. static int
  1062. handle_control_setevents(control_connection_t *conn, uint32_t len,
  1063. const char *body)
  1064. {
  1065. int event_code;
  1066. event_mask_t event_mask = 0;
  1067. smartlist_t *events = smartlist_new();
  1068. (void) len;
  1069. smartlist_split_string(events, body, " ",
  1070. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1071. SMARTLIST_FOREACH_BEGIN(events, const char *, ev)
  1072. {
  1073. if (!strcasecmp(ev, "EXTENDED") ||
  1074. !strcasecmp(ev, "AUTHDIR_NEWDESCS")) {
  1075. log_warn(LD_CONTROL, "The \"%s\" SETEVENTS argument is no longer "
  1076. "supported.", ev);
  1077. continue;
  1078. } else {
  1079. int i;
  1080. event_code = -1;
  1081. for (i = 0; control_event_table[i].event_name != NULL; ++i) {
  1082. if (!strcasecmp(ev, control_event_table[i].event_name)) {
  1083. event_code = control_event_table[i].event_code;
  1084. break;
  1085. }
  1086. }
  1087. if (event_code == -1) {
  1088. connection_printf_to_buf(conn, "552 Unrecognized event \"%s\"\r\n",
  1089. ev);
  1090. SMARTLIST_FOREACH(events, char *, e, tor_free(e));
  1091. smartlist_free(events);
  1092. return 0;
  1093. }
  1094. }
  1095. event_mask |= (((event_mask_t)1) << event_code);
  1096. }
  1097. SMARTLIST_FOREACH_END(ev);
  1098. SMARTLIST_FOREACH(events, char *, e, tor_free(e));
  1099. smartlist_free(events);
  1100. conn->event_mask = event_mask;
  1101. control_update_global_event_mask();
  1102. send_control_done(conn);
  1103. return 0;
  1104. }
  1105. /** Decode the hashed, base64'd passwords stored in <b>passwords</b>.
  1106. * Return a smartlist of acceptable passwords (unterminated strings of
  1107. * length S2K_RFC2440_SPECIFIER_LEN+DIGEST_LEN) on success, or NULL on
  1108. * failure.
  1109. */
  1110. smartlist_t *
  1111. decode_hashed_passwords(config_line_t *passwords)
  1112. {
  1113. char decoded[64];
  1114. config_line_t *cl;
  1115. smartlist_t *sl = smartlist_new();
  1116. tor_assert(passwords);
  1117. for (cl = passwords; cl; cl = cl->next) {
  1118. const char *hashed = cl->value;
  1119. if (!strcmpstart(hashed, "16:")) {
  1120. if (base16_decode(decoded, sizeof(decoded), hashed+3, strlen(hashed+3))
  1121. != S2K_RFC2440_SPECIFIER_LEN + DIGEST_LEN
  1122. || strlen(hashed+3) != (S2K_RFC2440_SPECIFIER_LEN+DIGEST_LEN)*2) {
  1123. goto err;
  1124. }
  1125. } else {
  1126. if (base64_decode(decoded, sizeof(decoded), hashed, strlen(hashed))
  1127. != S2K_RFC2440_SPECIFIER_LEN+DIGEST_LEN) {
  1128. goto err;
  1129. }
  1130. }
  1131. smartlist_add(sl,
  1132. tor_memdup(decoded, S2K_RFC2440_SPECIFIER_LEN+DIGEST_LEN));
  1133. }
  1134. return sl;
  1135. err:
  1136. SMARTLIST_FOREACH(sl, char*, cp, tor_free(cp));
  1137. smartlist_free(sl);
  1138. return NULL;
  1139. }
  1140. /** Called when we get an AUTHENTICATE message. Check whether the
  1141. * authentication is valid, and if so, update the connection's state to
  1142. * OPEN. Reply with DONE or ERROR.
  1143. */
  1144. static int
  1145. handle_control_authenticate(control_connection_t *conn, uint32_t len,
  1146. const char *body)
  1147. {
  1148. int used_quoted_string = 0;
  1149. const or_options_t *options = get_options();
  1150. const char *errstr = "Unknown error";
  1151. char *password;
  1152. size_t password_len;
  1153. const char *cp;
  1154. int i;
  1155. int bad_cookie=0, bad_password=0;
  1156. smartlist_t *sl = NULL;
  1157. if (!len) {
  1158. password = tor_strdup("");
  1159. password_len = 0;
  1160. } else if (TOR_ISXDIGIT(body[0])) {
  1161. cp = body;
  1162. while (TOR_ISXDIGIT(*cp))
  1163. ++cp;
  1164. i = (int)(cp - body);
  1165. tor_assert(i>0);
  1166. password_len = i/2;
  1167. password = tor_malloc(password_len + 1);
  1168. if (base16_decode(password, password_len+1, body, i)
  1169. != (int) password_len) {
  1170. connection_write_str_to_buf(
  1171. "551 Invalid hexadecimal encoding. Maybe you tried a plain text "
  1172. "password? If so, the standard requires that you put it in "
  1173. "double quotes.\r\n", conn);
  1174. connection_mark_for_close(TO_CONN(conn));
  1175. tor_free(password);
  1176. return 0;
  1177. }
  1178. } else {
  1179. if (!decode_escaped_string(body, len, &password, &password_len)) {
  1180. connection_write_str_to_buf("551 Invalid quoted string. You need "
  1181. "to put the password in double quotes.\r\n", conn);
  1182. connection_mark_for_close(TO_CONN(conn));
  1183. return 0;
  1184. }
  1185. used_quoted_string = 1;
  1186. }
  1187. if (conn->safecookie_client_hash != NULL) {
  1188. /* The controller has chosen safe cookie authentication; the only
  1189. * acceptable authentication value is the controller-to-server
  1190. * response. */
  1191. tor_assert(authentication_cookie_is_set);
  1192. if (password_len != DIGEST256_LEN) {
  1193. log_warn(LD_CONTROL,
  1194. "Got safe cookie authentication response with wrong length "
  1195. "(%d)", (int)password_len);
  1196. errstr = "Wrong length for safe cookie response.";
  1197. goto err;
  1198. }
  1199. if (tor_memneq(conn->safecookie_client_hash, password, DIGEST256_LEN)) {
  1200. log_warn(LD_CONTROL,
  1201. "Got incorrect safe cookie authentication response");
  1202. errstr = "Safe cookie response did not match expected value.";
  1203. goto err;
  1204. }
  1205. tor_free(conn->safecookie_client_hash);
  1206. goto ok;
  1207. }
  1208. if (!options->CookieAuthentication && !options->HashedControlPassword &&
  1209. !options->HashedControlSessionPassword) {
  1210. /* if Tor doesn't demand any stronger authentication, then
  1211. * the controller can get in with anything. */
  1212. goto ok;
  1213. }
  1214. if (options->CookieAuthentication) {
  1215. int also_password = options->HashedControlPassword != NULL ||
  1216. options->HashedControlSessionPassword != NULL;
  1217. if (password_len != AUTHENTICATION_COOKIE_LEN) {
  1218. if (!also_password) {
  1219. log_warn(LD_CONTROL, "Got authentication cookie with wrong length "
  1220. "(%d)", (int)password_len);
  1221. errstr = "Wrong length on authentication cookie.";
  1222. goto err;
  1223. }
  1224. bad_cookie = 1;
  1225. } else if (tor_memneq(authentication_cookie, password, password_len)) {
  1226. if (!also_password) {
  1227. log_warn(LD_CONTROL, "Got mismatched authentication cookie");
  1228. errstr = "Authentication cookie did not match expected value.";
  1229. goto err;
  1230. }
  1231. bad_cookie = 1;
  1232. } else {
  1233. goto ok;
  1234. }
  1235. }
  1236. if (options->HashedControlPassword ||
  1237. options->HashedControlSessionPassword) {
  1238. int bad = 0;
  1239. smartlist_t *sl_tmp;
  1240. char received[DIGEST_LEN];
  1241. int also_cookie = options->CookieAuthentication;
  1242. sl = smartlist_new();
  1243. if (options->HashedControlPassword) {
  1244. sl_tmp = decode_hashed_passwords(options->HashedControlPassword);
  1245. if (!sl_tmp)
  1246. bad = 1;
  1247. else {
  1248. smartlist_add_all(sl, sl_tmp);
  1249. smartlist_free(sl_tmp);
  1250. }
  1251. }
  1252. if (options->HashedControlSessionPassword) {
  1253. sl_tmp = decode_hashed_passwords(options->HashedControlSessionPassword);
  1254. if (!sl_tmp)
  1255. bad = 1;
  1256. else {
  1257. smartlist_add_all(sl, sl_tmp);
  1258. smartlist_free(sl_tmp);
  1259. }
  1260. }
  1261. if (bad) {
  1262. if (!also_cookie) {
  1263. log_warn(LD_BUG,
  1264. "Couldn't decode HashedControlPassword: invalid base16");
  1265. errstr="Couldn't decode HashedControlPassword value in configuration.";
  1266. goto err;
  1267. }
  1268. bad_password = 1;
  1269. SMARTLIST_FOREACH(sl, char *, str, tor_free(str));
  1270. smartlist_free(sl);
  1271. sl = NULL;
  1272. } else {
  1273. SMARTLIST_FOREACH(sl, char *, expected,
  1274. {
  1275. secret_to_key_rfc2440(received,DIGEST_LEN,
  1276. password,password_len,expected);
  1277. if (tor_memeq(expected + S2K_RFC2440_SPECIFIER_LEN,
  1278. received, DIGEST_LEN))
  1279. goto ok;
  1280. });
  1281. SMARTLIST_FOREACH(sl, char *, str, tor_free(str));
  1282. smartlist_free(sl);
  1283. sl = NULL;
  1284. if (used_quoted_string)
  1285. errstr = "Password did not match HashedControlPassword value from "
  1286. "configuration";
  1287. else
  1288. errstr = "Password did not match HashedControlPassword value from "
  1289. "configuration. Maybe you tried a plain text password? "
  1290. "If so, the standard requires that you put it in double quotes.";
  1291. bad_password = 1;
  1292. if (!also_cookie)
  1293. goto err;
  1294. }
  1295. }
  1296. /** We only get here if both kinds of authentication failed. */
  1297. tor_assert(bad_password && bad_cookie);
  1298. log_warn(LD_CONTROL, "Bad password or authentication cookie on controller.");
  1299. errstr = "Password did not match HashedControlPassword *or* authentication "
  1300. "cookie.";
  1301. err:
  1302. tor_free(password);
  1303. connection_printf_to_buf(conn, "515 Authentication failed: %s\r\n", errstr);
  1304. connection_mark_for_close(TO_CONN(conn));
  1305. if (sl) { /* clean up */
  1306. SMARTLIST_FOREACH(sl, char *, str, tor_free(str));
  1307. smartlist_free(sl);
  1308. }
  1309. return 0;
  1310. ok:
  1311. log_info(LD_CONTROL, "Authenticated control connection ("TOR_SOCKET_T_FORMAT
  1312. ")", conn->base_.s);
  1313. send_control_done(conn);
  1314. conn->base_.state = CONTROL_CONN_STATE_OPEN;
  1315. tor_free(password);
  1316. if (sl) { /* clean up */
  1317. SMARTLIST_FOREACH(sl, char *, str, tor_free(str));
  1318. smartlist_free(sl);
  1319. }
  1320. return 0;
  1321. }
  1322. /** Called when we get a SAVECONF command. Try to flush the current options to
  1323. * disk, and report success or failure. */
  1324. static int
  1325. handle_control_saveconf(control_connection_t *conn, uint32_t len,
  1326. const char *body)
  1327. {
  1328. (void) len;
  1329. int force = !strcmpstart(body, "FORCE");
  1330. const or_options_t *options = get_options();
  1331. if ((!force && options->IncludeUsed) || options_save_current() < 0) {
  1332. connection_write_str_to_buf(
  1333. "551 Unable to write configuration to disk.\r\n", conn);
  1334. } else {
  1335. send_control_done(conn);
  1336. }
  1337. return 0;
  1338. }
  1339. struct signal_t {
  1340. int sig;
  1341. const char *signal_name;
  1342. };
  1343. static const struct signal_t signal_table[] = {
  1344. { SIGHUP, "RELOAD" },
  1345. { SIGHUP, "HUP" },
  1346. { SIGINT, "SHUTDOWN" },
  1347. { SIGUSR1, "DUMP" },
  1348. { SIGUSR1, "USR1" },
  1349. { SIGUSR2, "DEBUG" },
  1350. { SIGUSR2, "USR2" },
  1351. { SIGTERM, "HALT" },
  1352. { SIGTERM, "TERM" },
  1353. { SIGTERM, "INT" },
  1354. { SIGNEWNYM, "NEWNYM" },
  1355. { SIGCLEARDNSCACHE, "CLEARDNSCACHE"},
  1356. { SIGHEARTBEAT, "HEARTBEAT"},
  1357. { 0, NULL },
  1358. };
  1359. /** Called when we get a SIGNAL command. React to the provided signal, and
  1360. * report success or failure. (If the signal results in a shutdown, success
  1361. * may not be reported.) */
  1362. static int
  1363. handle_control_signal(control_connection_t *conn, uint32_t len,
  1364. const char *body)
  1365. {
  1366. int sig = -1;
  1367. int i;
  1368. int n = 0;
  1369. char *s;
  1370. (void) len;
  1371. while (body[n] && ! TOR_ISSPACE(body[n]))
  1372. ++n;
  1373. s = tor_strndup(body, n);
  1374. for (i = 0; signal_table[i].signal_name != NULL; ++i) {
  1375. if (!strcasecmp(s, signal_table[i].signal_name)) {
  1376. sig = signal_table[i].sig;
  1377. break;
  1378. }
  1379. }
  1380. if (sig < 0)
  1381. connection_printf_to_buf(conn, "552 Unrecognized signal code \"%s\"\r\n",
  1382. s);
  1383. tor_free(s);
  1384. if (sig < 0)
  1385. return 0;
  1386. send_control_done(conn);
  1387. /* Flush the "done" first if the signal might make us shut down. */
  1388. if (sig == SIGTERM || sig == SIGINT)
  1389. connection_flush(TO_CONN(conn));
  1390. activate_signal(sig);
  1391. return 0;
  1392. }
  1393. /** Called when we get a TAKEOWNERSHIP command. Mark this connection
  1394. * as an owning connection, so that we will exit if the connection
  1395. * closes. */
  1396. static int
  1397. handle_control_takeownership(control_connection_t *conn, uint32_t len,
  1398. const char *body)
  1399. {
  1400. (void)len;
  1401. (void)body;
  1402. conn->is_owning_control_connection = 1;
  1403. log_info(LD_CONTROL, "Control connection %d has taken ownership of this "
  1404. "Tor instance.",
  1405. (int)(conn->base_.s));
  1406. send_control_done(conn);
  1407. return 0;
  1408. }
  1409. /** Return true iff <b>addr</b> is unusable as a mapaddress target because of
  1410. * containing funny characters. */
  1411. static int
  1412. address_is_invalid_mapaddress_target(const char *addr)
  1413. {
  1414. if (!strcmpstart(addr, "*."))
  1415. return address_is_invalid_destination(addr+2, 1);
  1416. else
  1417. return address_is_invalid_destination(addr, 1);
  1418. }
  1419. /** Called when we get a MAPADDRESS command; try to bind all listed addresses,
  1420. * and report success or failure. */
  1421. static int
  1422. handle_control_mapaddress(control_connection_t *conn, uint32_t len,
  1423. const char *body)
  1424. {
  1425. smartlist_t *elts;
  1426. smartlist_t *lines;
  1427. smartlist_t *reply;
  1428. char *r;
  1429. size_t sz;
  1430. (void) len; /* body is NUL-terminated, so it's safe to ignore the length. */
  1431. lines = smartlist_new();
  1432. elts = smartlist_new();
  1433. reply = smartlist_new();
  1434. smartlist_split_string(lines, body, " ",
  1435. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  1436. SMARTLIST_FOREACH_BEGIN(lines, char *, line) {
  1437. tor_strlower(line);
  1438. smartlist_split_string(elts, line, "=", 0, 2);
  1439. if (smartlist_len(elts) == 2) {
  1440. const char *from = smartlist_get(elts,0);
  1441. const char *to = smartlist_get(elts,1);
  1442. if (address_is_invalid_mapaddress_target(to)) {
  1443. smartlist_add_asprintf(reply,
  1444. "512-syntax error: invalid address '%s'", to);
  1445. log_warn(LD_CONTROL,
  1446. "Skipping invalid argument '%s' in MapAddress msg", to);
  1447. } else if (!strcmp(from, ".") || !strcmp(from, "0.0.0.0") ||
  1448. !strcmp(from, "::")) {
  1449. const char type =
  1450. !strcmp(from,".") ? RESOLVED_TYPE_HOSTNAME :
  1451. (!strcmp(from, "0.0.0.0") ? RESOLVED_TYPE_IPV4 : RESOLVED_TYPE_IPV6);
  1452. const char *address = addressmap_register_virtual_address(
  1453. type, tor_strdup(to));
  1454. if (!address) {
  1455. smartlist_add_asprintf(reply,
  1456. "451-resource exhausted: skipping '%s'", line);
  1457. log_warn(LD_CONTROL,
  1458. "Unable to allocate address for '%s' in MapAddress msg",
  1459. safe_str_client(line));
  1460. } else {
  1461. smartlist_add_asprintf(reply, "250-%s=%s", address, to);
  1462. }
  1463. } else {
  1464. const char *msg;
  1465. if (addressmap_register_auto(from, to, 1,
  1466. ADDRMAPSRC_CONTROLLER, &msg) < 0) {
  1467. smartlist_add_asprintf(reply,
  1468. "512-syntax error: invalid address mapping "
  1469. " '%s': %s", line, msg);
  1470. log_warn(LD_CONTROL,
  1471. "Skipping invalid argument '%s' in MapAddress msg: %s",
  1472. line, msg);
  1473. } else {
  1474. smartlist_add_asprintf(reply, "250-%s", line);
  1475. }
  1476. }
  1477. } else {
  1478. smartlist_add_asprintf(reply, "512-syntax error: mapping '%s' is "
  1479. "not of expected form 'foo=bar'.", line);
  1480. log_info(LD_CONTROL, "Skipping MapAddress '%s': wrong "
  1481. "number of items.",
  1482. safe_str_client(line));
  1483. }
  1484. SMARTLIST_FOREACH(elts, char *, cp, tor_free(cp));
  1485. smartlist_clear(elts);
  1486. } SMARTLIST_FOREACH_END(line);
  1487. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  1488. smartlist_free(lines);
  1489. smartlist_free(elts);
  1490. if (smartlist_len(reply)) {
  1491. ((char*)smartlist_get(reply,smartlist_len(reply)-1))[3] = ' ';
  1492. r = smartlist_join_strings(reply, "\r\n", 1, &sz);
  1493. connection_buf_add(r, sz, TO_CONN(conn));
  1494. tor_free(r);
  1495. } else {
  1496. const char *response =
  1497. "512 syntax error: not enough arguments to mapaddress.\r\n";
  1498. connection_buf_add(response, strlen(response), TO_CONN(conn));
  1499. }
  1500. SMARTLIST_FOREACH(reply, char *, cp, tor_free(cp));
  1501. smartlist_free(reply);
  1502. return 0;
  1503. }
  1504. /** Implementation helper for GETINFO: knows the answers for various
  1505. * trivial-to-implement questions. */
  1506. static int
  1507. getinfo_helper_misc(control_connection_t *conn, const char *question,
  1508. char **answer, const char **errmsg)
  1509. {
  1510. (void) conn;
  1511. if (!strcmp(question, "version")) {
  1512. *answer = tor_strdup(get_version());
  1513. } else if (!strcmp(question, "bw-event-cache")) {
  1514. *answer = get_bw_samples();
  1515. } else if (!strcmp(question, "config-file")) {
  1516. const char *a = get_torrc_fname(0);
  1517. if (a)
  1518. *answer = tor_strdup(a);
  1519. } else if (!strcmp(question, "config-defaults-file")) {
  1520. const char *a = get_torrc_fname(1);
  1521. if (a)
  1522. *answer = tor_strdup(a);
  1523. } else if (!strcmp(question, "config-text")) {
  1524. *answer = options_dump(get_options(), OPTIONS_DUMP_MINIMAL);
  1525. } else if (!strcmp(question, "config-can-saveconf")) {
  1526. *answer = tor_strdup(get_options()->IncludeUsed ? "0" : "1");
  1527. } else if (!strcmp(question, "info/names")) {
  1528. *answer = list_getinfo_options();
  1529. } else if (!strcmp(question, "dormant")) {
  1530. int dormant = rep_hist_circbuilding_dormant(time(NULL));
  1531. *answer = tor_strdup(dormant ? "1" : "0");
  1532. } else if (!strcmp(question, "events/names")) {
  1533. int i;
  1534. smartlist_t *event_names = smartlist_new();
  1535. for (i = 0; control_event_table[i].event_name != NULL; ++i) {
  1536. smartlist_add(event_names, (char *)control_event_table[i].event_name);
  1537. }
  1538. *answer = smartlist_join_strings(event_names, " ", 0, NULL);
  1539. smartlist_free(event_names);
  1540. } else if (!strcmp(question, "signal/names")) {
  1541. smartlist_t *signal_names = smartlist_new();
  1542. int j;
  1543. for (j = 0; signal_table[j].signal_name != NULL; ++j) {
  1544. smartlist_add(signal_names, (char*)signal_table[j].signal_name);
  1545. }
  1546. *answer = smartlist_join_strings(signal_names, " ", 0, NULL);
  1547. smartlist_free(signal_names);
  1548. } else if (!strcmp(question, "features/names")) {
  1549. *answer = tor_strdup("VERBOSE_NAMES EXTENDED_EVENTS");
  1550. } else if (!strcmp(question, "address")) {
  1551. uint32_t addr;
  1552. if (router_pick_published_address(get_options(), &addr, 0) < 0) {
  1553. *errmsg = "Address unknown";
  1554. return -1;
  1555. }
  1556. *answer = tor_dup_ip(addr);
  1557. } else if (!strcmp(question, "traffic/read")) {
  1558. tor_asprintf(answer, U64_FORMAT, U64_PRINTF_ARG(get_bytes_read()));
  1559. } else if (!strcmp(question, "traffic/written")) {
  1560. tor_asprintf(answer, U64_FORMAT, U64_PRINTF_ARG(get_bytes_written()));
  1561. } else if (!strcmp(question, "process/pid")) {
  1562. int myPid = -1;
  1563. #ifdef _WIN32
  1564. myPid = _getpid();
  1565. #else
  1566. myPid = getpid();
  1567. #endif
  1568. tor_asprintf(answer, "%d", myPid);
  1569. } else if (!strcmp(question, "process/uid")) {
  1570. #ifdef _WIN32
  1571. *answer = tor_strdup("-1");
  1572. #else
  1573. int myUid = geteuid();
  1574. tor_asprintf(answer, "%d", myUid);
  1575. #endif /* defined(_WIN32) */
  1576. } else if (!strcmp(question, "process/user")) {
  1577. #ifdef _WIN32
  1578. *answer = tor_strdup("");
  1579. #else
  1580. int myUid = geteuid();
  1581. const struct passwd *myPwEntry = tor_getpwuid(myUid);
  1582. if (myPwEntry) {
  1583. *answer = tor_strdup(myPwEntry->pw_name);
  1584. } else {
  1585. *answer = tor_strdup("");
  1586. }
  1587. #endif /* defined(_WIN32) */
  1588. } else if (!strcmp(question, "process/descriptor-limit")) {
  1589. int max_fds = get_max_sockets();
  1590. tor_asprintf(answer, "%d", max_fds);
  1591. } else if (!strcmp(question, "limits/max-mem-in-queues")) {
  1592. tor_asprintf(answer, U64_FORMAT,
  1593. U64_PRINTF_ARG(get_options()->MaxMemInQueues));
  1594. } else if (!strcmp(question, "fingerprint")) {
  1595. crypto_pk_t *server_key;
  1596. if (!server_mode(get_options())) {
  1597. *errmsg = "Not running in server mode";
  1598. return -1;
  1599. }
  1600. server_key = get_server_identity_key();
  1601. *answer = tor_malloc(HEX_DIGEST_LEN+1);
  1602. crypto_pk_get_fingerprint(server_key, *answer, 0);
  1603. }
  1604. return 0;
  1605. }
  1606. /** Awful hack: return a newly allocated string based on a routerinfo and
  1607. * (possibly) an extrainfo, sticking the read-history and write-history from
  1608. * <b>ei</b> into the resulting string. The thing you get back won't
  1609. * necessarily have a valid signature.
  1610. *
  1611. * New code should never use this; it's for backward compatibility.
  1612. *
  1613. * NOTE: <b>ri_body</b> is as returned by signed_descriptor_get_body: it might
  1614. * not be NUL-terminated. */
  1615. static char *
  1616. munge_extrainfo_into_routerinfo(const char *ri_body,
  1617. const signed_descriptor_t *ri,
  1618. const signed_descriptor_t *ei)
  1619. {
  1620. char *out = NULL, *outp;
  1621. int i;
  1622. const char *router_sig;
  1623. const char *ei_body = signed_descriptor_get_body(ei);
  1624. size_t ri_len = ri->signed_descriptor_len;
  1625. size_t ei_len = ei->signed_descriptor_len;
  1626. if (!ei_body)
  1627. goto bail;
  1628. outp = out = tor_malloc(ri_len+ei_len+1);
  1629. if (!(router_sig = tor_memstr(ri_body, ri_len, "\nrouter-signature")))
  1630. goto bail;
  1631. ++router_sig;
  1632. memcpy(out, ri_body, router_sig-ri_body);
  1633. outp += router_sig-ri_body;
  1634. for (i=0; i < 2; ++i) {
  1635. const char *kwd = i ? "\nwrite-history " : "\nread-history ";
  1636. const char *cp, *eol;
  1637. if (!(cp = tor_memstr(ei_body, ei_len, kwd)))
  1638. continue;
  1639. ++cp;
  1640. if (!(eol = memchr(cp, '\n', ei_len - (cp-ei_body))))
  1641. continue;
  1642. memcpy(outp, cp, eol-cp+1);
  1643. outp += eol-cp+1;
  1644. }
  1645. memcpy(outp, router_sig, ri_len - (router_sig-ri_body));
  1646. *outp++ = '\0';
  1647. tor_assert(outp-out < (int)(ri_len+ei_len+1));
  1648. return out;
  1649. bail:
  1650. tor_free(out);
  1651. return tor_strndup(ri_body, ri->signed_descriptor_len);
  1652. }
  1653. /** Implementation helper for GETINFO: answers requests for information about
  1654. * which ports are bound. */
  1655. static int
  1656. getinfo_helper_listeners(control_connection_t *control_conn,
  1657. const char *question,
  1658. char **answer, const char **errmsg)
  1659. {
  1660. int type;
  1661. smartlist_t *res;
  1662. (void)control_conn;
  1663. (void)errmsg;
  1664. if (!strcmp(question, "net/listeners/or"))
  1665. type = CONN_TYPE_OR_LISTENER;
  1666. else if (!strcmp(question, "net/listeners/dir"))
  1667. type = CONN_TYPE_DIR_LISTENER;
  1668. else if (!strcmp(question, "net/listeners/socks"))
  1669. type = CONN_TYPE_AP_LISTENER;
  1670. else if (!strcmp(question, "net/listeners/trans"))
  1671. type = CONN_TYPE_AP_TRANS_LISTENER;
  1672. else if (!strcmp(question, "net/listeners/natd"))
  1673. type = CONN_TYPE_AP_NATD_LISTENER;
  1674. else if (!strcmp(question, "net/listeners/dns"))
  1675. type = CONN_TYPE_AP_DNS_LISTENER;
  1676. else if (!strcmp(question, "net/listeners/control"))
  1677. type = CONN_TYPE_CONTROL_LISTENER;
  1678. else
  1679. return 0; /* unknown key */
  1680. res = smartlist_new();
  1681. SMARTLIST_FOREACH_BEGIN(get_connection_array(), connection_t *, conn) {
  1682. struct sockaddr_storage ss;
  1683. socklen_t ss_len = sizeof(ss);
  1684. if (conn->type != type || conn->marked_for_close || !SOCKET_OK(conn->s))
  1685. continue;
  1686. if (getsockname(conn->s, (struct sockaddr *)&ss, &ss_len) < 0) {
  1687. smartlist_add_asprintf(res, "%s:%d", conn->address, (int)conn->port);
  1688. } else {
  1689. char *tmp = tor_sockaddr_to_str((struct sockaddr *)&ss);
  1690. smartlist_add(res, esc_for_log(tmp));
  1691. tor_free(tmp);
  1692. }
  1693. } SMARTLIST_FOREACH_END(conn);
  1694. *answer = smartlist_join_strings(res, " ", 0, NULL);
  1695. SMARTLIST_FOREACH(res, char *, cp, tor_free(cp));
  1696. smartlist_free(res);
  1697. return 0;
  1698. }
  1699. /** Implementation helper for GETINFO: knows the answers for questions about
  1700. * directory information. */
  1701. STATIC int
  1702. getinfo_helper_dir(control_connection_t *control_conn,
  1703. const char *question, char **answer,
  1704. const char **errmsg)
  1705. {
  1706. (void) control_conn;
  1707. if (!strcmpstart(question, "desc/id/")) {
  1708. const routerinfo_t *ri = NULL;
  1709. const node_t *node = node_get_by_hex_id(question+strlen("desc/id/"), 0);
  1710. if (node)
  1711. ri = node->ri;
  1712. if (ri) {
  1713. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1714. if (body)
  1715. *answer = tor_strndup(body, ri->cache_info.signed_descriptor_len);
  1716. } else if (! we_fetch_router_descriptors(get_options())) {
  1717. /* Descriptors won't be available, provide proper error */
  1718. *errmsg = "We fetch microdescriptors, not router "
  1719. "descriptors. You'll need to use md/id/* "
  1720. "instead of desc/id/*.";
  1721. return 0;
  1722. }
  1723. } else if (!strcmpstart(question, "desc/name/")) {
  1724. const routerinfo_t *ri = NULL;
  1725. /* XXX Setting 'warn_if_unnamed' here is a bit silly -- the
  1726. * warning goes to the user, not to the controller. */
  1727. const node_t *node =
  1728. node_get_by_nickname(question+strlen("desc/name/"), 0);
  1729. if (node)
  1730. ri = node->ri;
  1731. if (ri) {
  1732. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1733. if (body)
  1734. *answer = tor_strndup(body, ri->cache_info.signed_descriptor_len);
  1735. } else if (! we_fetch_router_descriptors(get_options())) {
  1736. /* Descriptors won't be available, provide proper error */
  1737. *errmsg = "We fetch microdescriptors, not router "
  1738. "descriptors. You'll need to use md/name/* "
  1739. "instead of desc/name/*.";
  1740. return 0;
  1741. }
  1742. } else if (!strcmp(question, "desc/download-enabled")) {
  1743. int r = we_fetch_router_descriptors(get_options());
  1744. tor_asprintf(answer, "%d", !!r);
  1745. } else if (!strcmp(question, "desc/all-recent")) {
  1746. routerlist_t *routerlist = router_get_routerlist();
  1747. smartlist_t *sl = smartlist_new();
  1748. if (routerlist && routerlist->routers) {
  1749. SMARTLIST_FOREACH(routerlist->routers, const routerinfo_t *, ri,
  1750. {
  1751. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1752. if (body)
  1753. smartlist_add(sl,
  1754. tor_strndup(body, ri->cache_info.signed_descriptor_len));
  1755. });
  1756. }
  1757. *answer = smartlist_join_strings(sl, "", 0, NULL);
  1758. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  1759. smartlist_free(sl);
  1760. } else if (!strcmp(question, "desc/all-recent-extrainfo-hack")) {
  1761. /* XXXX Remove this once Torstat asks for extrainfos. */
  1762. routerlist_t *routerlist = router_get_routerlist();
  1763. smartlist_t *sl = smartlist_new();
  1764. if (routerlist && routerlist->routers) {
  1765. SMARTLIST_FOREACH_BEGIN(routerlist->routers, const routerinfo_t *, ri) {
  1766. const char *body = signed_descriptor_get_body(&ri->cache_info);
  1767. signed_descriptor_t *ei = extrainfo_get_by_descriptor_digest(
  1768. ri->cache_info.extra_info_digest);
  1769. if (ei && body) {
  1770. smartlist_add(sl, munge_extrainfo_into_routerinfo(body,
  1771. &ri->cache_info, ei));
  1772. } else if (body) {
  1773. smartlist_add(sl,
  1774. tor_strndup(body, ri->cache_info.signed_descriptor_len));
  1775. }
  1776. } SMARTLIST_FOREACH_END(ri);
  1777. }
  1778. *answer = smartlist_join_strings(sl, "", 0, NULL);
  1779. SMARTLIST_FOREACH(sl, char *, c, tor_free(c));
  1780. smartlist_free(sl);
  1781. } else if (!strcmpstart(question, "hs/client/desc/id/")) {
  1782. rend_cache_entry_t *e = NULL;
  1783. question += strlen("hs/client/desc/id/");
  1784. if (strlen(question) != REND_SERVICE_ID_LEN_BASE32) {
  1785. *errmsg = "Invalid address";
  1786. return -1;
  1787. }
  1788. if (!rend_cache_lookup_entry(question, -1, &e)) {
  1789. /* Descriptor found in cache */
  1790. *answer = tor_strdup(e->desc);
  1791. } else {
  1792. *errmsg = "Not found in cache";
  1793. return -1;
  1794. }
  1795. } else if (!strcmpstart(question, "hs/service/desc/id/")) {
  1796. rend_cache_entry_t *e = NULL;
  1797. question += strlen("hs/service/desc/id/");
  1798. if (strlen(question) != REND_SERVICE_ID_LEN_BASE32) {
  1799. *errmsg = "Invalid address";
  1800. return -1;
  1801. }
  1802. if (!rend_cache_lookup_v2_desc_as_service(question, &e)) {
  1803. /* Descriptor found in cache */
  1804. *answer = tor_strdup(e->desc);
  1805. } else {
  1806. *errmsg = "Not found in cache";
  1807. return -1;
  1808. }
  1809. } else if (!strcmpstart(question, "md/id/")) {
  1810. const node_t *node = node_get_by_hex_id(question+strlen("md/id/"), 0);
  1811. const microdesc_t *md = NULL;
  1812. if (node) md = node->md;
  1813. if (md && md->body) {
  1814. *answer = tor_strndup(md->body, md->bodylen);
  1815. }
  1816. } else if (!strcmpstart(question, "md/name/")) {
  1817. /* XXX Setting 'warn_if_unnamed' here is a bit silly -- the
  1818. * warning goes to the user, not to the controller. */
  1819. const node_t *node = node_get_by_nickname(question+strlen("md/name/"), 0);
  1820. /* XXXX duplicated code */
  1821. const microdesc_t *md = NULL;
  1822. if (node) md = node->md;
  1823. if (md && md->body) {
  1824. *answer = tor_strndup(md->body, md->bodylen);
  1825. }
  1826. } else if (!strcmp(question, "md/download-enabled")) {
  1827. int r = we_fetch_microdescriptors(get_options());
  1828. tor_asprintf(answer, "%d", !!r);
  1829. } else if (!strcmpstart(question, "desc-annotations/id/")) {
  1830. const routerinfo_t *ri = NULL;
  1831. const node_t *node =
  1832. node_get_by_hex_id(question+strlen("desc-annotations/id/"), 0);
  1833. if (node)
  1834. ri = node->ri;
  1835. if (ri) {
  1836. const char *annotations =
  1837. signed_descriptor_get_annotations(&ri->cache_info);
  1838. if (annotations)
  1839. *answer = tor_strndup(annotations,
  1840. ri->cache_info.annotations_len);
  1841. }
  1842. } else if (!strcmpstart(question, "dir/server/")) {
  1843. size_t answer_len = 0;
  1844. char *url = NULL;
  1845. smartlist_t *descs = smartlist_new();
  1846. const char *msg;
  1847. int res;
  1848. char *cp;
  1849. tor_asprintf(&url, "/tor/%s", question+4);
  1850. res = dirserv_get_routerdescs(descs, url, &msg);
  1851. if (res) {
  1852. log_warn(LD_CONTROL, "getinfo '%s': %s", question, msg);
  1853. smartlist_free(descs);
  1854. tor_free(url);
  1855. *errmsg = msg;
  1856. return -1;
  1857. }
  1858. SMARTLIST_FOREACH(descs, signed_descriptor_t *, sd,
  1859. answer_len += sd->signed_descriptor_len);
  1860. cp = *answer = tor_malloc(answer_len+1);
  1861. SMARTLIST_FOREACH(descs, signed_descriptor_t *, sd,
  1862. {
  1863. memcpy(cp, signed_descriptor_get_body(sd),
  1864. sd->signed_descriptor_len);
  1865. cp += sd->signed_descriptor_len;
  1866. });
  1867. *cp = '\0';
  1868. tor_free(url);
  1869. smartlist_free(descs);
  1870. } else if (!strcmpstart(question, "dir/status/")) {
  1871. *answer = tor_strdup("");
  1872. } else if (!strcmp(question, "dir/status-vote/current/consensus")) { /* v3 */
  1873. if (we_want_to_fetch_flavor(get_options(), FLAV_NS)) {
  1874. const cached_dir_t *consensus = dirserv_get_consensus("ns");
  1875. if (consensus)
  1876. *answer = tor_strdup(consensus->dir);
  1877. }
  1878. if (!*answer) { /* try loading it from disk */
  1879. char *filename = get_datadir_fname("cached-consensus");
  1880. *answer = read_file_to_str(filename, RFTS_IGNORE_MISSING, NULL);
  1881. tor_free(filename);
  1882. if (!*answer) { /* generate an error */
  1883. *errmsg = "Could not open cached consensus. "
  1884. "Make sure FetchUselessDescriptors is set to 1.";
  1885. return -1;
  1886. }
  1887. }
  1888. } else if (!strcmp(question, "network-status")) { /* v1 */
  1889. static int network_status_warned = 0;
  1890. if (!network_status_warned) {
  1891. log_warn(LD_CONTROL, "GETINFO network-status is deprecated; it will "
  1892. "go away in a future version of Tor.");
  1893. network_status_warned = 1;
  1894. }
  1895. routerlist_t *routerlist = router_get_routerlist();
  1896. if (!routerlist || !routerlist->routers ||
  1897. list_server_status_v1(routerlist->routers, answer, 1) < 0) {
  1898. return -1;
  1899. }
  1900. } else if (!strcmpstart(question, "extra-info/digest/")) {
  1901. question += strlen("extra-info/digest/");
  1902. if (strlen(question) == HEX_DIGEST_LEN) {
  1903. char d[DIGEST_LEN];
  1904. signed_descriptor_t *sd = NULL;
  1905. if (base16_decode(d, sizeof(d), question, strlen(question))
  1906. == sizeof(d)) {
  1907. /* XXXX this test should move into extrainfo_get_by_descriptor_digest,
  1908. * but I don't want to risk affecting other parts of the code,
  1909. * especially since the rules for using our own extrainfo (including
  1910. * when it might be freed) are different from those for using one
  1911. * we have downloaded. */
  1912. if (router_extrainfo_digest_is_me(d))
  1913. sd = &(router_get_my_extrainfo()->cache_info);
  1914. else
  1915. sd = extrainfo_get_by_descriptor_digest(d);
  1916. }
  1917. if (sd) {
  1918. const char *body = signed_descriptor_get_body(sd);
  1919. if (body)
  1920. *answer = tor_strndup(body, sd->signed_descriptor_len);
  1921. }
  1922. }
  1923. }
  1924. return 0;
  1925. }
  1926. /** Given a smartlist of 20-byte digests, return a newly allocated string
  1927. * containing each of those digests in order, formatted in HEX, and terminated
  1928. * with a newline. */
  1929. static char *
  1930. digest_list_to_string(const smartlist_t *sl)
  1931. {
  1932. int len;
  1933. char *result, *s;
  1934. /* Allow for newlines, and a \0 at the end */
  1935. len = smartlist_len(sl) * (HEX_DIGEST_LEN + 1) + 1;
  1936. result = tor_malloc_zero(len);
  1937. s = result;
  1938. SMARTLIST_FOREACH_BEGIN(sl, const char *, digest) {
  1939. base16_encode(s, HEX_DIGEST_LEN + 1, digest, DIGEST_LEN);
  1940. s[HEX_DIGEST_LEN] = '\n';
  1941. s += HEX_DIGEST_LEN + 1;
  1942. } SMARTLIST_FOREACH_END(digest);
  1943. *s = '\0';
  1944. return result;
  1945. }
  1946. /** Turn a download_status_t into a human-readable description in a newly
  1947. * allocated string. The format is specified in control-spec.txt, under
  1948. * the documentation for "GETINFO download/..." . */
  1949. static char *
  1950. download_status_to_string(const download_status_t *dl)
  1951. {
  1952. char *rv = NULL, *tmp;
  1953. char tbuf[ISO_TIME_LEN+1];
  1954. const char *schedule_str, *want_authority_str;
  1955. const char *increment_on_str, *backoff_str;
  1956. if (dl) {
  1957. /* Get some substrings of the eventual output ready */
  1958. format_iso_time(tbuf, download_status_get_next_attempt_at(dl));
  1959. switch (dl->schedule) {
  1960. case DL_SCHED_GENERIC:
  1961. schedule_str = "DL_SCHED_GENERIC";
  1962. break;
  1963. case DL_SCHED_CONSENSUS:
  1964. schedule_str = "DL_SCHED_CONSENSUS";
  1965. break;
  1966. case DL_SCHED_BRIDGE:
  1967. schedule_str = "DL_SCHED_BRIDGE";
  1968. break;
  1969. default:
  1970. schedule_str = "unknown";
  1971. break;
  1972. }
  1973. switch (dl->want_authority) {
  1974. case DL_WANT_ANY_DIRSERVER:
  1975. want_authority_str = "DL_WANT_ANY_DIRSERVER";
  1976. break;
  1977. case DL_WANT_AUTHORITY:
  1978. want_authority_str = "DL_WANT_AUTHORITY";
  1979. break;
  1980. default:
  1981. want_authority_str = "unknown";
  1982. break;
  1983. }
  1984. switch (dl->increment_on) {
  1985. case DL_SCHED_INCREMENT_FAILURE:
  1986. increment_on_str = "DL_SCHED_INCREMENT_FAILURE";
  1987. break;
  1988. case DL_SCHED_INCREMENT_ATTEMPT:
  1989. increment_on_str = "DL_SCHED_INCREMENT_ATTEMPT";
  1990. break;
  1991. default:
  1992. increment_on_str = "unknown";
  1993. break;
  1994. }
  1995. switch (dl->backoff) {
  1996. case DL_SCHED_DETERMINISTIC:
  1997. backoff_str = "DL_SCHED_DETERMINISTIC";
  1998. break;
  1999. case DL_SCHED_RANDOM_EXPONENTIAL:
  2000. backoff_str = "DL_SCHED_RANDOM_EXPONENTIAL";
  2001. break;
  2002. default:
  2003. backoff_str = "unknown";
  2004. break;
  2005. }
  2006. /* Now assemble them */
  2007. tor_asprintf(&tmp,
  2008. "next-attempt-at %s\n"
  2009. "n-download-failures %u\n"
  2010. "n-download-attempts %u\n"
  2011. "schedule %s\n"
  2012. "want-authority %s\n"
  2013. "increment-on %s\n"
  2014. "backoff %s\n",
  2015. tbuf,
  2016. dl->n_download_failures,
  2017. dl->n_download_attempts,
  2018. schedule_str,
  2019. want_authority_str,
  2020. increment_on_str,
  2021. backoff_str);
  2022. if (dl->backoff == DL_SCHED_RANDOM_EXPONENTIAL) {
  2023. /* Additional fields become relevant in random-exponential mode */
  2024. tor_asprintf(&rv,
  2025. "%s"
  2026. "last-backoff-position %u\n"
  2027. "last-delay-used %d\n",
  2028. tmp,
  2029. dl->last_backoff_position,
  2030. dl->last_delay_used);
  2031. tor_free(tmp);
  2032. } else {
  2033. /* That was it */
  2034. rv = tmp;
  2035. }
  2036. }
  2037. return rv;
  2038. }
  2039. /** Handle the consensus download cases for getinfo_helper_downloads() */
  2040. STATIC void
  2041. getinfo_helper_downloads_networkstatus(const char *flavor,
  2042. download_status_t **dl_to_emit,
  2043. const char **errmsg)
  2044. {
  2045. /*
  2046. * We get the one for the current bootstrapped status by default, or
  2047. * take an extra /bootstrap or /running suffix
  2048. */
  2049. if (strcmp(flavor, "ns") == 0) {
  2050. *dl_to_emit = networkstatus_get_dl_status_by_flavor(FLAV_NS);
  2051. } else if (strcmp(flavor, "ns/bootstrap") == 0) {
  2052. *dl_to_emit = networkstatus_get_dl_status_by_flavor_bootstrap(FLAV_NS);
  2053. } else if (strcmp(flavor, "ns/running") == 0 ) {
  2054. *dl_to_emit = networkstatus_get_dl_status_by_flavor_running(FLAV_NS);
  2055. } else if (strcmp(flavor, "microdesc") == 0) {
  2056. *dl_to_emit = networkstatus_get_dl_status_by_flavor(FLAV_MICRODESC);
  2057. } else if (strcmp(flavor, "microdesc/bootstrap") == 0) {
  2058. *dl_to_emit =
  2059. networkstatus_get_dl_status_by_flavor_bootstrap(FLAV_MICRODESC);
  2060. } else if (strcmp(flavor, "microdesc/running") == 0) {
  2061. *dl_to_emit =
  2062. networkstatus_get_dl_status_by_flavor_running(FLAV_MICRODESC);
  2063. } else {
  2064. *errmsg = "Unknown flavor";
  2065. }
  2066. }
  2067. /** Handle the cert download cases for getinfo_helper_downloads() */
  2068. STATIC void
  2069. getinfo_helper_downloads_cert(const char *fp_sk_req,
  2070. download_status_t **dl_to_emit,
  2071. smartlist_t **digest_list,
  2072. const char **errmsg)
  2073. {
  2074. const char *sk_req;
  2075. char id_digest[DIGEST_LEN];
  2076. char sk_digest[DIGEST_LEN];
  2077. /*
  2078. * We have to handle four cases; fp_sk_req is the request with
  2079. * a prefix of "downloads/cert/" snipped off.
  2080. *
  2081. * Case 1: fp_sk_req = "fps"
  2082. * - We should emit a digest_list with a list of all the identity
  2083. * fingerprints that can be queried for certificate download status;
  2084. * get it by calling list_authority_ids_with_downloads().
  2085. *
  2086. * Case 2: fp_sk_req = "fp/<fp>" for some fingerprint fp
  2087. * - We want the default certificate for this identity fingerprint's
  2088. * download status; this is the download we get from URLs starting
  2089. * in /fp/ on the directory server. We can get it with
  2090. * id_only_download_status_for_authority_id().
  2091. *
  2092. * Case 3: fp_sk_req = "fp/<fp>/sks" for some fingerprint fp
  2093. * - We want a list of all signing key digests for this identity
  2094. * fingerprint which can be queried for certificate download status.
  2095. * Get it with list_sk_digests_for_authority_id().
  2096. *
  2097. * Case 4: fp_sk_req = "fp/<fp>/<sk>" for some fingerprint fp and
  2098. * signing key digest sk
  2099. * - We want the download status for the certificate for this specific
  2100. * signing key and fingerprint. These correspond to the ones we get
  2101. * from URLs starting in /fp-sk/ on the directory server. Get it with
  2102. * list_sk_digests_for_authority_id().
  2103. */
  2104. if (strcmp(fp_sk_req, "fps") == 0) {
  2105. *digest_list = list_authority_ids_with_downloads();
  2106. if (!(*digest_list)) {
  2107. *errmsg = "Failed to get list of authority identity digests (!)";
  2108. }
  2109. } else if (!strcmpstart(fp_sk_req, "fp/")) {
  2110. fp_sk_req += strlen("fp/");
  2111. /* Okay, look for another / to tell the fp from fp-sk cases */
  2112. sk_req = strchr(fp_sk_req, '/');
  2113. if (sk_req) {
  2114. /* okay, split it here and try to parse <fp> */
  2115. if (base16_decode(id_digest, DIGEST_LEN,
  2116. fp_sk_req, sk_req - fp_sk_req) == DIGEST_LEN) {
  2117. /* Skip past the '/' */
  2118. ++sk_req;
  2119. if (strcmp(sk_req, "sks") == 0) {
  2120. /* We're asking for the list of signing key fingerprints */
  2121. *digest_list = list_sk_digests_for_authority_id(id_digest);
  2122. if (!(*digest_list)) {
  2123. *errmsg = "Failed to get list of signing key digests for this "
  2124. "authority identity digest";
  2125. }
  2126. } else {
  2127. /* We've got a signing key digest */
  2128. if (base16_decode(sk_digest, DIGEST_LEN,
  2129. sk_req, strlen(sk_req)) == DIGEST_LEN) {
  2130. *dl_to_emit =
  2131. download_status_for_authority_id_and_sk(id_digest, sk_digest);
  2132. if (!(*dl_to_emit)) {
  2133. *errmsg = "Failed to get download status for this identity/"
  2134. "signing key digest pair";
  2135. }
  2136. } else {
  2137. *errmsg = "That didn't look like a signing key digest";
  2138. }
  2139. }
  2140. } else {
  2141. *errmsg = "That didn't look like an identity digest";
  2142. }
  2143. } else {
  2144. /* We're either in downloads/certs/fp/<fp>, or we can't parse <fp> */
  2145. if (strlen(fp_sk_req) == HEX_DIGEST_LEN) {
  2146. if (base16_decode(id_digest, DIGEST_LEN,
  2147. fp_sk_req, strlen(fp_sk_req)) == DIGEST_LEN) {
  2148. *dl_to_emit = id_only_download_status_for_authority_id(id_digest);
  2149. if (!(*dl_to_emit)) {
  2150. *errmsg = "Failed to get download status for this authority "
  2151. "identity digest";
  2152. }
  2153. } else {
  2154. *errmsg = "That didn't look like a digest";
  2155. }
  2156. } else {
  2157. *errmsg = "That didn't look like a digest";
  2158. }
  2159. }
  2160. } else {
  2161. *errmsg = "Unknown certificate download status query";
  2162. }
  2163. }
  2164. /** Handle the routerdesc download cases for getinfo_helper_downloads() */
  2165. STATIC void
  2166. getinfo_helper_downloads_desc(const char *desc_req,
  2167. download_status_t **dl_to_emit,
  2168. smartlist_t **digest_list,
  2169. const char **errmsg)
  2170. {
  2171. char desc_digest[DIGEST_LEN];
  2172. /*
  2173. * Two cases to handle here:
  2174. *
  2175. * Case 1: desc_req = "descs"
  2176. * - Emit a list of all router descriptor digests, which we get by
  2177. * calling router_get_descriptor_digests(); this can return NULL
  2178. * if we have no current ns-flavor consensus.
  2179. *
  2180. * Case 2: desc_req = <fp>
  2181. * - Check on the specified fingerprint and emit its download_status_t
  2182. * using router_get_dl_status_by_descriptor_digest().
  2183. */
  2184. if (strcmp(desc_req, "descs") == 0) {
  2185. *digest_list = router_get_descriptor_digests();
  2186. if (!(*digest_list)) {
  2187. *errmsg = "We don't seem to have a networkstatus-flavored consensus";
  2188. }
  2189. /*
  2190. * Microdescs don't use the download_status_t mechanism, so we don't
  2191. * answer queries about their downloads here; see microdesc.c.
  2192. */
  2193. } else if (strlen(desc_req) == HEX_DIGEST_LEN) {
  2194. if (base16_decode(desc_digest, DIGEST_LEN,
  2195. desc_req, strlen(desc_req)) == DIGEST_LEN) {
  2196. /* Okay we got a digest-shaped thing; try asking for it */
  2197. *dl_to_emit = router_get_dl_status_by_descriptor_digest(desc_digest);
  2198. if (!(*dl_to_emit)) {
  2199. *errmsg = "No such descriptor digest found";
  2200. }
  2201. } else {
  2202. *errmsg = "That didn't look like a digest";
  2203. }
  2204. } else {
  2205. *errmsg = "Unknown router descriptor download status query";
  2206. }
  2207. }
  2208. /** Handle the bridge download cases for getinfo_helper_downloads() */
  2209. STATIC void
  2210. getinfo_helper_downloads_bridge(const char *bridge_req,
  2211. download_status_t **dl_to_emit,
  2212. smartlist_t **digest_list,
  2213. const char **errmsg)
  2214. {
  2215. char bridge_digest[DIGEST_LEN];
  2216. /*
  2217. * Two cases to handle here:
  2218. *
  2219. * Case 1: bridge_req = "bridges"
  2220. * - Emit a list of all bridge identity digests, which we get by
  2221. * calling list_bridge_identities(); this can return NULL if we are
  2222. * not using bridges.
  2223. *
  2224. * Case 2: bridge_req = <fp>
  2225. * - Check on the specified fingerprint and emit its download_status_t
  2226. * using get_bridge_dl_status_by_id().
  2227. */
  2228. if (strcmp(bridge_req, "bridges") == 0) {
  2229. *digest_list = list_bridge_identities();
  2230. if (!(*digest_list)) {
  2231. *errmsg = "We don't seem to be using bridges";
  2232. }
  2233. } else if (strlen(bridge_req) == HEX_DIGEST_LEN) {
  2234. if (base16_decode(bridge_digest, DIGEST_LEN,
  2235. bridge_req, strlen(bridge_req)) == DIGEST_LEN) {
  2236. /* Okay we got a digest-shaped thing; try asking for it */
  2237. *dl_to_emit = get_bridge_dl_status_by_id(bridge_digest);
  2238. if (!(*dl_to_emit)) {
  2239. *errmsg = "No such bridge identity digest found";
  2240. }
  2241. } else {
  2242. *errmsg = "That didn't look like a digest";
  2243. }
  2244. } else {
  2245. *errmsg = "Unknown bridge descriptor download status query";
  2246. }
  2247. }
  2248. /** Implementation helper for GETINFO: knows the answers for questions about
  2249. * download status information. */
  2250. STATIC int
  2251. getinfo_helper_downloads(control_connection_t *control_conn,
  2252. const char *question, char **answer,
  2253. const char **errmsg)
  2254. {
  2255. download_status_t *dl_to_emit = NULL;
  2256. smartlist_t *digest_list = NULL;
  2257. /* Assert args are sane */
  2258. tor_assert(control_conn != NULL);
  2259. tor_assert(question != NULL);
  2260. tor_assert(answer != NULL);
  2261. tor_assert(errmsg != NULL);
  2262. /* We check for this later to see if we should supply a default */
  2263. *errmsg = NULL;
  2264. /* Are we after networkstatus downloads? */
  2265. if (!strcmpstart(question, "downloads/networkstatus/")) {
  2266. getinfo_helper_downloads_networkstatus(
  2267. question + strlen("downloads/networkstatus/"),
  2268. &dl_to_emit, errmsg);
  2269. /* Certificates? */
  2270. } else if (!strcmpstart(question, "downloads/cert/")) {
  2271. getinfo_helper_downloads_cert(
  2272. question + strlen("downloads/cert/"),
  2273. &dl_to_emit, &digest_list, errmsg);
  2274. /* Router descriptors? */
  2275. } else if (!strcmpstart(question, "downloads/desc/")) {
  2276. getinfo_helper_downloads_desc(
  2277. question + strlen("downloads/desc/"),
  2278. &dl_to_emit, &digest_list, errmsg);
  2279. /* Bridge descriptors? */
  2280. } else if (!strcmpstart(question, "downloads/bridge/")) {
  2281. getinfo_helper_downloads_bridge(
  2282. question + strlen("downloads/bridge/"),
  2283. &dl_to_emit, &digest_list, errmsg);
  2284. } else {
  2285. *errmsg = "Unknown download status query";
  2286. }
  2287. if (dl_to_emit) {
  2288. *answer = download_status_to_string(dl_to_emit);
  2289. return 0;
  2290. } else if (digest_list) {
  2291. *answer = digest_list_to_string(digest_list);
  2292. SMARTLIST_FOREACH(digest_list, void *, s, tor_free(s));
  2293. smartlist_free(digest_list);
  2294. return 0;
  2295. } else {
  2296. if (!(*errmsg)) {
  2297. *errmsg = "Unknown error";
  2298. }
  2299. return -1;
  2300. }
  2301. }
  2302. /** Allocate and return a description of <b>circ</b>'s current status,
  2303. * including its path (if any). */
  2304. static char *
  2305. circuit_describe_status_for_controller(origin_circuit_t *circ)
  2306. {
  2307. char *rv;
  2308. smartlist_t *descparts = smartlist_new();
  2309. {
  2310. char *vpath = circuit_list_path_for_controller(circ);
  2311. if (*vpath) {
  2312. smartlist_add(descparts, vpath);
  2313. } else {
  2314. tor_free(vpath); /* empty path; don't put an extra space in the result */
  2315. }
  2316. }
  2317. {
  2318. cpath_build_state_t *build_state = circ->build_state;
  2319. smartlist_t *flaglist = smartlist_new();
  2320. char *flaglist_joined;
  2321. if (build_state->onehop_tunnel)
  2322. smartlist_add(flaglist, (void *)"ONEHOP_TUNNEL");
  2323. if (build_state->is_internal)
  2324. smartlist_add(flaglist, (void *)"IS_INTERNAL");
  2325. if (build_state->need_capacity)
  2326. smartlist_add(flaglist, (void *)"NEED_CAPACITY");
  2327. if (build_state->need_uptime)
  2328. smartlist_add(flaglist, (void *)"NEED_UPTIME");
  2329. /* Only emit a BUILD_FLAGS argument if it will have a non-empty value. */
  2330. if (smartlist_len(flaglist)) {
  2331. flaglist_joined = smartlist_join_strings(flaglist, ",", 0, NULL);
  2332. smartlist_add_asprintf(descparts, "BUILD_FLAGS=%s", flaglist_joined);
  2333. tor_free(flaglist_joined);
  2334. }
  2335. smartlist_free(flaglist);
  2336. }
  2337. smartlist_add_asprintf(descparts, "PURPOSE=%s",
  2338. circuit_purpose_to_controller_string(circ->base_.purpose));
  2339. {
  2340. const char *hs_state =
  2341. circuit_purpose_to_controller_hs_state_string(circ->base_.purpose);
  2342. if (hs_state != NULL) {
  2343. smartlist_add_asprintf(descparts, "HS_STATE=%s", hs_state);
  2344. }
  2345. }
  2346. if (circ->rend_data != NULL) {
  2347. smartlist_add_asprintf(descparts, "REND_QUERY=%s",
  2348. rend_data_get_address(circ->rend_data));
  2349. }
  2350. {
  2351. char tbuf[ISO_TIME_USEC_LEN+1];
  2352. format_iso_time_nospace_usec(tbuf, &circ->base_.timestamp_created);
  2353. smartlist_add_asprintf(descparts, "TIME_CREATED=%s", tbuf);
  2354. }
  2355. // Show username and/or password if available.
  2356. if (circ->socks_username_len > 0) {
  2357. char* socks_username_escaped = esc_for_log_len(circ->socks_username,
  2358. (size_t) circ->socks_username_len);
  2359. smartlist_add_asprintf(descparts, "SOCKS_USERNAME=%s",
  2360. socks_username_escaped);
  2361. tor_free(socks_username_escaped);
  2362. }
  2363. if (circ->socks_password_len > 0) {
  2364. char* socks_password_escaped = esc_for_log_len(circ->socks_password,
  2365. (size_t) circ->socks_password_len);
  2366. smartlist_add_asprintf(descparts, "SOCKS_PASSWORD=%s",
  2367. socks_password_escaped);
  2368. tor_free(socks_password_escaped);
  2369. }
  2370. rv = smartlist_join_strings(descparts, " ", 0, NULL);
  2371. SMARTLIST_FOREACH(descparts, char *, cp, tor_free(cp));
  2372. smartlist_free(descparts);
  2373. return rv;
  2374. }
  2375. /** Implementation helper for GETINFO: knows how to generate summaries of the
  2376. * current states of things we send events about. */
  2377. static int
  2378. getinfo_helper_events(control_connection_t *control_conn,
  2379. const char *question, char **answer,
  2380. const char **errmsg)
  2381. {
  2382. const or_options_t *options = get_options();
  2383. (void) control_conn;
  2384. if (!strcmp(question, "circuit-status")) {
  2385. smartlist_t *status = smartlist_new();
  2386. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ_) {
  2387. origin_circuit_t *circ;
  2388. char *circdesc;
  2389. const char *state;
  2390. if (! CIRCUIT_IS_ORIGIN(circ_) || circ_->marked_for_close)
  2391. continue;
  2392. circ = TO_ORIGIN_CIRCUIT(circ_);
  2393. if (circ->base_.state == CIRCUIT_STATE_OPEN)
  2394. state = "BUILT";
  2395. else if (circ->base_.state == CIRCUIT_STATE_GUARD_WAIT)
  2396. state = "GUARD_WAIT";
  2397. else if (circ->cpath)
  2398. state = "EXTENDED";
  2399. else
  2400. state = "LAUNCHED";
  2401. circdesc = circuit_describe_status_for_controller(circ);
  2402. smartlist_add_asprintf(status, "%lu %s%s%s",
  2403. (unsigned long)circ->global_identifier,
  2404. state, *circdesc ? " " : "", circdesc);
  2405. tor_free(circdesc);
  2406. }
  2407. SMARTLIST_FOREACH_END(circ_);
  2408. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  2409. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  2410. smartlist_free(status);
  2411. } else if (!strcmp(question, "stream-status")) {
  2412. smartlist_t *conns = get_connection_array();
  2413. smartlist_t *status = smartlist_new();
  2414. char buf[256];
  2415. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, base_conn) {
  2416. const char *state;
  2417. entry_connection_t *conn;
  2418. circuit_t *circ;
  2419. origin_circuit_t *origin_circ = NULL;
  2420. if (base_conn->type != CONN_TYPE_AP ||
  2421. base_conn->marked_for_close ||
  2422. base_conn->state == AP_CONN_STATE_SOCKS_WAIT ||
  2423. base_conn->state == AP_CONN_STATE_NATD_WAIT)
  2424. continue;
  2425. conn = TO_ENTRY_CONN(base_conn);
  2426. switch (base_conn->state)
  2427. {
  2428. case AP_CONN_STATE_CONTROLLER_WAIT:
  2429. case AP_CONN_STATE_CIRCUIT_WAIT:
  2430. if (conn->socks_request &&
  2431. SOCKS_COMMAND_IS_RESOLVE(conn->socks_request->command))
  2432. state = "NEWRESOLVE";
  2433. else
  2434. state = "NEW";
  2435. break;
  2436. case AP_CONN_STATE_RENDDESC_WAIT:
  2437. case AP_CONN_STATE_CONNECT_WAIT:
  2438. state = "SENTCONNECT"; break;
  2439. case AP_CONN_STATE_RESOLVE_WAIT:
  2440. state = "SENTRESOLVE"; break;
  2441. case AP_CONN_STATE_OPEN:
  2442. state = "SUCCEEDED"; break;
  2443. default:
  2444. log_warn(LD_BUG, "Asked for stream in unknown state %d",
  2445. base_conn->state);
  2446. continue;
  2447. }
  2448. circ = circuit_get_by_edge_conn(ENTRY_TO_EDGE_CONN(conn));
  2449. if (circ && CIRCUIT_IS_ORIGIN(circ))
  2450. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  2451. write_stream_target_to_buf(conn, buf, sizeof(buf));
  2452. smartlist_add_asprintf(status, "%lu %s %lu %s",
  2453. (unsigned long) base_conn->global_identifier,state,
  2454. origin_circ?
  2455. (unsigned long)origin_circ->global_identifier : 0ul,
  2456. buf);
  2457. } SMARTLIST_FOREACH_END(base_conn);
  2458. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  2459. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  2460. smartlist_free(status);
  2461. } else if (!strcmp(question, "orconn-status")) {
  2462. smartlist_t *conns = get_connection_array();
  2463. smartlist_t *status = smartlist_new();
  2464. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, base_conn) {
  2465. const char *state;
  2466. char name[128];
  2467. or_connection_t *conn;
  2468. if (base_conn->type != CONN_TYPE_OR || base_conn->marked_for_close)
  2469. continue;
  2470. conn = TO_OR_CONN(base_conn);
  2471. if (conn->base_.state == OR_CONN_STATE_OPEN)
  2472. state = "CONNECTED";
  2473. else if (conn->nickname)
  2474. state = "LAUNCHED";
  2475. else
  2476. state = "NEW";
  2477. orconn_target_get_name(name, sizeof(name), conn);
  2478. smartlist_add_asprintf(status, "%s %s", name, state);
  2479. } SMARTLIST_FOREACH_END(base_conn);
  2480. *answer = smartlist_join_strings(status, "\r\n", 0, NULL);
  2481. SMARTLIST_FOREACH(status, char *, cp, tor_free(cp));
  2482. smartlist_free(status);
  2483. } else if (!strcmpstart(question, "address-mappings/")) {
  2484. time_t min_e, max_e;
  2485. smartlist_t *mappings;
  2486. question += strlen("address-mappings/");
  2487. if (!strcmp(question, "all")) {
  2488. min_e = 0; max_e = TIME_MAX;
  2489. } else if (!strcmp(question, "cache")) {
  2490. min_e = 2; max_e = TIME_MAX;
  2491. } else if (!strcmp(question, "config")) {
  2492. min_e = 0; max_e = 0;
  2493. } else if (!strcmp(question, "control")) {
  2494. min_e = 1; max_e = 1;
  2495. } else {
  2496. return 0;
  2497. }
  2498. mappings = smartlist_new();
  2499. addressmap_get_mappings(mappings, min_e, max_e, 1);
  2500. *answer = smartlist_join_strings(mappings, "\r\n", 0, NULL);
  2501. SMARTLIST_FOREACH(mappings, char *, cp, tor_free(cp));
  2502. smartlist_free(mappings);
  2503. } else if (!strcmpstart(question, "status/")) {
  2504. /* Note that status/ is not a catch-all for events; there's only supposed
  2505. * to be a status GETINFO if there's a corresponding STATUS event. */
  2506. if (!strcmp(question, "status/circuit-established")) {
  2507. *answer = tor_strdup(have_completed_a_circuit() ? "1" : "0");
  2508. } else if (!strcmp(question, "status/enough-dir-info")) {
  2509. *answer = tor_strdup(router_have_minimum_dir_info() ? "1" : "0");
  2510. } else if (!strcmp(question, "status/good-server-descriptor") ||
  2511. !strcmp(question, "status/accepted-server-descriptor")) {
  2512. /* They're equivalent for now, until we can figure out how to make
  2513. * good-server-descriptor be what we want. See comment in
  2514. * control-spec.txt. */
  2515. *answer = tor_strdup(directories_have_accepted_server_descriptor()
  2516. ? "1" : "0");
  2517. } else if (!strcmp(question, "status/reachability-succeeded/or")) {
  2518. *answer = tor_strdup(check_whether_orport_reachable(options) ?
  2519. "1" : "0");
  2520. } else if (!strcmp(question, "status/reachability-succeeded/dir")) {
  2521. *answer = tor_strdup(check_whether_dirport_reachable(options) ?
  2522. "1" : "0");
  2523. } else if (!strcmp(question, "status/reachability-succeeded")) {
  2524. tor_asprintf(answer, "OR=%d DIR=%d",
  2525. check_whether_orport_reachable(options) ? 1 : 0,
  2526. check_whether_dirport_reachable(options) ? 1 : 0);
  2527. } else if (!strcmp(question, "status/bootstrap-phase")) {
  2528. *answer = tor_strdup(last_sent_bootstrap_message);
  2529. } else if (!strcmpstart(question, "status/version/")) {
  2530. int is_server = server_mode(options);
  2531. networkstatus_t *c = networkstatus_get_latest_consensus();
  2532. version_status_t status;
  2533. const char *recommended;
  2534. if (c) {
  2535. recommended = is_server ? c->server_versions : c->client_versions;
  2536. status = tor_version_is_obsolete(VERSION, recommended);
  2537. } else {
  2538. recommended = "?";
  2539. status = VS_UNKNOWN;
  2540. }
  2541. if (!strcmp(question, "status/version/recommended")) {
  2542. *answer = tor_strdup(recommended);
  2543. return 0;
  2544. }
  2545. if (!strcmp(question, "status/version/current")) {
  2546. switch (status)
  2547. {
  2548. case VS_RECOMMENDED: *answer = tor_strdup("recommended"); break;
  2549. case VS_OLD: *answer = tor_strdup("obsolete"); break;
  2550. case VS_NEW: *answer = tor_strdup("new"); break;
  2551. case VS_NEW_IN_SERIES: *answer = tor_strdup("new in series"); break;
  2552. case VS_UNRECOMMENDED: *answer = tor_strdup("unrecommended"); break;
  2553. case VS_EMPTY: *answer = tor_strdup("none recommended"); break;
  2554. case VS_UNKNOWN: *answer = tor_strdup("unknown"); break;
  2555. default: tor_fragile_assert();
  2556. }
  2557. } else if (!strcmp(question, "status/version/num-versioning") ||
  2558. !strcmp(question, "status/version/num-concurring")) {
  2559. tor_asprintf(answer, "%d", get_n_authorities(V3_DIRINFO));
  2560. log_warn(LD_GENERAL, "%s is deprecated; it no longer gives useful "
  2561. "information", question);
  2562. }
  2563. } else if (!strcmp(question, "status/clients-seen")) {
  2564. char *bridge_stats = geoip_get_bridge_stats_controller(time(NULL));
  2565. if (!bridge_stats) {
  2566. *errmsg = "No bridge-client stats available";
  2567. return -1;
  2568. }
  2569. *answer = bridge_stats;
  2570. } else if (!strcmp(question, "status/fresh-relay-descs")) {
  2571. if (!server_mode(options)) {
  2572. *errmsg = "Only relays have descriptors";
  2573. return -1;
  2574. }
  2575. routerinfo_t *r;
  2576. extrainfo_t *e;
  2577. if (router_build_fresh_descriptor(&r, &e) < 0) {
  2578. *errmsg = "Error generating descriptor";
  2579. return -1;
  2580. }
  2581. size_t size = r->cache_info.signed_descriptor_len + 1;
  2582. if (e) {
  2583. size += e->cache_info.signed_descriptor_len + 1;
  2584. }
  2585. tor_assert(r->cache_info.signed_descriptor_len);
  2586. char *descs = tor_malloc(size);
  2587. char *cp = descs;
  2588. memcpy(cp, signed_descriptor_get_body(&r->cache_info),
  2589. r->cache_info.signed_descriptor_len);
  2590. cp += r->cache_info.signed_descriptor_len - 1;
  2591. if (e) {
  2592. if (cp[0] == '\0') {
  2593. cp[0] = '\n';
  2594. } else if (cp[0] != '\n') {
  2595. cp[1] = '\n';
  2596. cp++;
  2597. }
  2598. memcpy(cp, signed_descriptor_get_body(&e->cache_info),
  2599. e->cache_info.signed_descriptor_len);
  2600. cp += e->cache_info.signed_descriptor_len - 1;
  2601. }
  2602. if (cp[0] == '\n') {
  2603. cp[0] = '\0';
  2604. } else if (cp[0] != '\0') {
  2605. cp[1] = '\0';
  2606. }
  2607. *answer = descs;
  2608. routerinfo_free(r);
  2609. extrainfo_free(e);
  2610. } else {
  2611. return 0;
  2612. }
  2613. }
  2614. return 0;
  2615. }
  2616. /** Implementation helper for GETINFO: knows how to enumerate hidden services
  2617. * created via the control port. */
  2618. STATIC int
  2619. getinfo_helper_onions(control_connection_t *control_conn,
  2620. const char *question, char **answer,
  2621. const char **errmsg)
  2622. {
  2623. smartlist_t *onion_list = NULL;
  2624. (void) errmsg; /* no errors from this method */
  2625. if (control_conn && !strcmp(question, "onions/current")) {
  2626. onion_list = control_conn->ephemeral_onion_services;
  2627. } else if (!strcmp(question, "onions/detached")) {
  2628. onion_list = detached_onion_services;
  2629. } else {
  2630. return 0;
  2631. }
  2632. if (!onion_list || smartlist_len(onion_list) == 0) {
  2633. if (answer) {
  2634. *answer = tor_strdup("");
  2635. }
  2636. } else {
  2637. if (answer) {
  2638. *answer = smartlist_join_strings(onion_list, "\r\n", 0, NULL);
  2639. }
  2640. }
  2641. return 0;
  2642. }
  2643. /** Implementation helper for GETINFO: answers queries about network
  2644. * liveness. */
  2645. static int
  2646. getinfo_helper_liveness(control_connection_t *control_conn,
  2647. const char *question, char **answer,
  2648. const char **errmsg)
  2649. {
  2650. (void)control_conn;
  2651. (void)errmsg;
  2652. if (strcmp(question, "network-liveness") == 0) {
  2653. if (get_cached_network_liveness()) {
  2654. *answer = tor_strdup("up");
  2655. } else {
  2656. *answer = tor_strdup("down");
  2657. }
  2658. }
  2659. return 0;
  2660. }
  2661. /** Implementation helper for GETINFO: answers queries about shared random
  2662. * value. */
  2663. static int
  2664. getinfo_helper_sr(control_connection_t *control_conn,
  2665. const char *question, char **answer,
  2666. const char **errmsg)
  2667. {
  2668. (void) control_conn;
  2669. (void) errmsg;
  2670. if (!strcmp(question, "sr/current")) {
  2671. *answer = sr_get_current_for_control();
  2672. } else if (!strcmp(question, "sr/previous")) {
  2673. *answer = sr_get_previous_for_control();
  2674. }
  2675. /* Else statement here is unrecognized key so do nothing. */
  2676. return 0;
  2677. }
  2678. /** Callback function for GETINFO: on a given control connection, try to
  2679. * answer the question <b>q</b> and store the newly-allocated answer in
  2680. * *<b>a</b>. If an internal error occurs, return -1 and optionally set
  2681. * *<b>error_out</b> to point to an error message to be delivered to the
  2682. * controller. On success, _or if the key is not recognized_, return 0. Do not
  2683. * set <b>a</b> if the key is not recognized but you may set <b>error_out</b>
  2684. * to improve the error message.
  2685. */
  2686. typedef int (*getinfo_helper_t)(control_connection_t *,
  2687. const char *q, char **a,
  2688. const char **error_out);
  2689. /** A single item for the GETINFO question-to-answer-function table. */
  2690. typedef struct getinfo_item_t {
  2691. const char *varname; /**< The value (or prefix) of the question. */
  2692. getinfo_helper_t fn; /**< The function that knows the answer: NULL if
  2693. * this entry is documentation-only. */
  2694. const char *desc; /**< Description of the variable. */
  2695. int is_prefix; /** Must varname match exactly, or must it be a prefix? */
  2696. } getinfo_item_t;
  2697. #define ITEM(name, fn, desc) { name, getinfo_helper_##fn, desc, 0 }
  2698. #define PREFIX(name, fn, desc) { name, getinfo_helper_##fn, desc, 1 }
  2699. #define DOC(name, desc) { name, NULL, desc, 0 }
  2700. /** Table mapping questions accepted by GETINFO to the functions that know how
  2701. * to answer them. */
  2702. static const getinfo_item_t getinfo_items[] = {
  2703. ITEM("version", misc, "The current version of Tor."),
  2704. ITEM("bw-event-cache", misc, "Cached BW events for a short interval."),
  2705. ITEM("config-file", misc, "Current location of the \"torrc\" file."),
  2706. ITEM("config-defaults-file", misc, "Current location of the defaults file."),
  2707. ITEM("config-text", misc,
  2708. "Return the string that would be written by a saveconf command."),
  2709. ITEM("config-can-saveconf", misc,
  2710. "Is it possible to save the configuration to the \"torrc\" file?"),
  2711. ITEM("accounting/bytes", accounting,
  2712. "Number of bytes read/written so far in the accounting interval."),
  2713. ITEM("accounting/bytes-left", accounting,
  2714. "Number of bytes left to write/read so far in the accounting interval."),
  2715. ITEM("accounting/enabled", accounting, "Is accounting currently enabled?"),
  2716. ITEM("accounting/hibernating", accounting, "Are we hibernating or awake?"),
  2717. ITEM("accounting/interval-start", accounting,
  2718. "Time when the accounting period starts."),
  2719. ITEM("accounting/interval-end", accounting,
  2720. "Time when the accounting period ends."),
  2721. ITEM("accounting/interval-wake", accounting,
  2722. "Time to wake up in this accounting period."),
  2723. ITEM("helper-nodes", entry_guards, NULL), /* deprecated */
  2724. ITEM("entry-guards", entry_guards,
  2725. "Which nodes are we using as entry guards?"),
  2726. ITEM("fingerprint", misc, NULL),
  2727. PREFIX("config/", config, "Current configuration values."),
  2728. DOC("config/names",
  2729. "List of configuration options, types, and documentation."),
  2730. DOC("config/defaults",
  2731. "List of default values for configuration options. "
  2732. "See also config/names"),
  2733. PREFIX("downloads/networkstatus/", downloads,
  2734. "Download statuses for networkstatus objects"),
  2735. DOC("downloads/networkstatus/ns",
  2736. "Download status for current-mode networkstatus download"),
  2737. DOC("downloads/networkstatus/ns/bootstrap",
  2738. "Download status for bootstrap-time networkstatus download"),
  2739. DOC("downloads/networkstatus/ns/running",
  2740. "Download status for run-time networkstatus download"),
  2741. DOC("downloads/networkstatus/microdesc",
  2742. "Download status for current-mode microdesc download"),
  2743. DOC("downloads/networkstatus/microdesc/bootstrap",
  2744. "Download status for bootstrap-time microdesc download"),
  2745. DOC("downloads/networkstatus/microdesc/running",
  2746. "Download status for run-time microdesc download"),
  2747. PREFIX("downloads/cert/", downloads,
  2748. "Download statuses for certificates, by id fingerprint and "
  2749. "signing key"),
  2750. DOC("downloads/cert/fps",
  2751. "List of authority fingerprints for which any download statuses "
  2752. "exist"),
  2753. DOC("downloads/cert/fp/<fp>",
  2754. "Download status for <fp> with the default signing key; corresponds "
  2755. "to /fp/ URLs on directory server."),
  2756. DOC("downloads/cert/fp/<fp>/sks",
  2757. "List of signing keys for which specific download statuses are "
  2758. "available for this id fingerprint"),
  2759. DOC("downloads/cert/fp/<fp>/<sk>",
  2760. "Download status for <fp> with signing key <sk>; corresponds "
  2761. "to /fp-sk/ URLs on directory server."),
  2762. PREFIX("downloads/desc/", downloads,
  2763. "Download statuses for router descriptors, by descriptor digest"),
  2764. DOC("downloads/desc/descs",
  2765. "Return a list of known router descriptor digests"),
  2766. DOC("downloads/desc/<desc>",
  2767. "Return a download status for a given descriptor digest"),
  2768. PREFIX("downloads/bridge/", downloads,
  2769. "Download statuses for bridge descriptors, by bridge identity "
  2770. "digest"),
  2771. DOC("downloads/bridge/bridges",
  2772. "Return a list of configured bridge identity digests with download "
  2773. "statuses"),
  2774. DOC("downloads/bridge/<desc>",
  2775. "Return a download status for a given bridge identity digest"),
  2776. ITEM("info/names", misc,
  2777. "List of GETINFO options, types, and documentation."),
  2778. ITEM("events/names", misc,
  2779. "Events that the controller can ask for with SETEVENTS."),
  2780. ITEM("signal/names", misc, "Signal names recognized by the SIGNAL command"),
  2781. ITEM("features/names", misc, "What arguments can USEFEATURE take?"),
  2782. PREFIX("desc/id/", dir, "Router descriptors by ID."),
  2783. PREFIX("desc/name/", dir, "Router descriptors by nickname."),
  2784. ITEM("desc/all-recent", dir,
  2785. "All non-expired, non-superseded router descriptors."),
  2786. ITEM("desc/download-enabled", dir,
  2787. "Do we try to download router descriptors?"),
  2788. ITEM("desc/all-recent-extrainfo-hack", dir, NULL), /* Hack. */
  2789. PREFIX("md/id/", dir, "Microdescriptors by ID"),
  2790. PREFIX("md/name/", dir, "Microdescriptors by name"),
  2791. ITEM("md/download-enabled", dir,
  2792. "Do we try to download microdescriptors?"),
  2793. PREFIX("extra-info/digest/", dir, "Extra-info documents by digest."),
  2794. PREFIX("hs/client/desc/id", dir,
  2795. "Hidden Service descriptor in client's cache by onion."),
  2796. PREFIX("hs/service/desc/id/", dir,
  2797. "Hidden Service descriptor in services's cache by onion."),
  2798. PREFIX("net/listeners/", listeners, "Bound addresses by type"),
  2799. ITEM("ns/all", networkstatus,
  2800. "Brief summary of router status (v2 directory format)"),
  2801. PREFIX("ns/id/", networkstatus,
  2802. "Brief summary of router status by ID (v2 directory format)."),
  2803. PREFIX("ns/name/", networkstatus,
  2804. "Brief summary of router status by nickname (v2 directory format)."),
  2805. PREFIX("ns/purpose/", networkstatus,
  2806. "Brief summary of router status by purpose (v2 directory format)."),
  2807. PREFIX("consensus/", networkstatus,
  2808. "Information about and from the ns consensus."),
  2809. ITEM("network-status", dir,
  2810. "Brief summary of router status (v1 directory format)"),
  2811. ITEM("network-liveness", liveness,
  2812. "Current opinion on whether the network is live"),
  2813. ITEM("circuit-status", events, "List of current circuits originating here."),
  2814. ITEM("stream-status", events,"List of current streams."),
  2815. ITEM("orconn-status", events, "A list of current OR connections."),
  2816. ITEM("dormant", misc,
  2817. "Is Tor dormant (not building circuits because it's idle)?"),
  2818. PREFIX("address-mappings/", events, NULL),
  2819. DOC("address-mappings/all", "Current address mappings."),
  2820. DOC("address-mappings/cache", "Current cached DNS replies."),
  2821. DOC("address-mappings/config",
  2822. "Current address mappings from configuration."),
  2823. DOC("address-mappings/control", "Current address mappings from controller."),
  2824. PREFIX("status/", events, NULL),
  2825. DOC("status/circuit-established",
  2826. "Whether we think client functionality is working."),
  2827. DOC("status/enough-dir-info",
  2828. "Whether we have enough up-to-date directory information to build "
  2829. "circuits."),
  2830. DOC("status/bootstrap-phase",
  2831. "The last bootstrap phase status event that Tor sent."),
  2832. DOC("status/clients-seen",
  2833. "Breakdown of client countries seen by a bridge."),
  2834. DOC("status/fresh-relay-descs",
  2835. "A fresh relay/ei descriptor pair for Tor's current state. Not stored."),
  2836. DOC("status/version/recommended", "List of currently recommended versions."),
  2837. DOC("status/version/current", "Status of the current version."),
  2838. DOC("status/version/num-versioning", "Number of versioning authorities."),
  2839. DOC("status/version/num-concurring",
  2840. "Number of versioning authorities agreeing on the status of the "
  2841. "current version"),
  2842. ITEM("address", misc, "IP address of this Tor host, if we can guess it."),
  2843. ITEM("traffic/read", misc,"Bytes read since the process was started."),
  2844. ITEM("traffic/written", misc,
  2845. "Bytes written since the process was started."),
  2846. ITEM("process/pid", misc, "Process id belonging to the main tor process."),
  2847. ITEM("process/uid", misc, "User id running the tor process."),
  2848. ITEM("process/user", misc,
  2849. "Username under which the tor process is running."),
  2850. ITEM("process/descriptor-limit", misc, "File descriptor limit."),
  2851. ITEM("limits/max-mem-in-queues", misc, "Actual limit on memory in queues"),
  2852. PREFIX("desc-annotations/id/", dir, "Router annotations by hexdigest."),
  2853. PREFIX("dir/server/", dir,"Router descriptors as retrieved from a DirPort."),
  2854. PREFIX("dir/status/", dir,
  2855. "v2 networkstatus docs as retrieved from a DirPort."),
  2856. ITEM("dir/status-vote/current/consensus", dir,
  2857. "v3 Networkstatus consensus as retrieved from a DirPort."),
  2858. ITEM("exit-policy/default", policies,
  2859. "The default value appended to the configured exit policy."),
  2860. ITEM("exit-policy/reject-private/default", policies,
  2861. "The default rules appended to the configured exit policy by"
  2862. " ExitPolicyRejectPrivate."),
  2863. ITEM("exit-policy/reject-private/relay", policies,
  2864. "The relay-specific rules appended to the configured exit policy by"
  2865. " ExitPolicyRejectPrivate and/or ExitPolicyRejectLocalInterfaces."),
  2866. ITEM("exit-policy/full", policies, "The entire exit policy of onion router"),
  2867. ITEM("exit-policy/ipv4", policies, "IPv4 parts of exit policy"),
  2868. ITEM("exit-policy/ipv6", policies, "IPv6 parts of exit policy"),
  2869. PREFIX("ip-to-country/", geoip, "Perform a GEOIP lookup"),
  2870. ITEM("onions/current", onions,
  2871. "Onion services owned by the current control connection."),
  2872. ITEM("onions/detached", onions,
  2873. "Onion services detached from the control connection."),
  2874. ITEM("sr/current", sr, "Get current shared random value."),
  2875. ITEM("sr/previous", sr, "Get previous shared random value."),
  2876. { NULL, NULL, NULL, 0 }
  2877. };
  2878. /** Allocate and return a list of recognized GETINFO options. */
  2879. static char *
  2880. list_getinfo_options(void)
  2881. {
  2882. int i;
  2883. smartlist_t *lines = smartlist_new();
  2884. char *ans;
  2885. for (i = 0; getinfo_items[i].varname; ++i) {
  2886. if (!getinfo_items[i].desc)
  2887. continue;
  2888. smartlist_add_asprintf(lines, "%s%s -- %s\n",
  2889. getinfo_items[i].varname,
  2890. getinfo_items[i].is_prefix ? "*" : "",
  2891. getinfo_items[i].desc);
  2892. }
  2893. smartlist_sort_strings(lines);
  2894. ans = smartlist_join_strings(lines, "", 0, NULL);
  2895. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  2896. smartlist_free(lines);
  2897. return ans;
  2898. }
  2899. /** Lookup the 'getinfo' entry <b>question</b>, and return
  2900. * the answer in <b>*answer</b> (or NULL if key not recognized).
  2901. * Return 0 if success or unrecognized, or -1 if recognized but
  2902. * internal error. */
  2903. static int
  2904. handle_getinfo_helper(control_connection_t *control_conn,
  2905. const char *question, char **answer,
  2906. const char **err_out)
  2907. {
  2908. int i;
  2909. *answer = NULL; /* unrecognized key by default */
  2910. for (i = 0; getinfo_items[i].varname; ++i) {
  2911. int match;
  2912. if (getinfo_items[i].is_prefix)
  2913. match = !strcmpstart(question, getinfo_items[i].varname);
  2914. else
  2915. match = !strcmp(question, getinfo_items[i].varname);
  2916. if (match) {
  2917. tor_assert(getinfo_items[i].fn);
  2918. return getinfo_items[i].fn(control_conn, question, answer, err_out);
  2919. }
  2920. }
  2921. return 0; /* unrecognized */
  2922. }
  2923. /** Called when we receive a GETINFO command. Try to fetch all requested
  2924. * information, and reply with information or error message. */
  2925. static int
  2926. handle_control_getinfo(control_connection_t *conn, uint32_t len,
  2927. const char *body)
  2928. {
  2929. smartlist_t *questions = smartlist_new();
  2930. smartlist_t *answers = smartlist_new();
  2931. smartlist_t *unrecognized = smartlist_new();
  2932. char *ans = NULL;
  2933. int i;
  2934. (void) len; /* body is NUL-terminated, so it's safe to ignore the length. */
  2935. smartlist_split_string(questions, body, " ",
  2936. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  2937. SMARTLIST_FOREACH_BEGIN(questions, const char *, q) {
  2938. const char *errmsg = NULL;
  2939. if (handle_getinfo_helper(conn, q, &ans, &errmsg) < 0) {
  2940. if (!errmsg)
  2941. errmsg = "Internal error";
  2942. connection_printf_to_buf(conn, "551 %s\r\n", errmsg);
  2943. goto done;
  2944. }
  2945. if (!ans) {
  2946. if (errmsg) /* use provided error message */
  2947. smartlist_add_strdup(unrecognized, errmsg);
  2948. else /* use default error message */
  2949. smartlist_add_asprintf(unrecognized, "Unrecognized key \"%s\"", q);
  2950. } else {
  2951. smartlist_add_strdup(answers, q);
  2952. smartlist_add(answers, ans);
  2953. }
  2954. } SMARTLIST_FOREACH_END(q);
  2955. if (smartlist_len(unrecognized)) {
  2956. /* control-spec section 2.3, mid-reply '-' or end of reply ' ' */
  2957. for (i=0; i < smartlist_len(unrecognized)-1; ++i)
  2958. connection_printf_to_buf(conn,
  2959. "552-%s\r\n",
  2960. (char *)smartlist_get(unrecognized, i));
  2961. connection_printf_to_buf(conn,
  2962. "552 %s\r\n",
  2963. (char *)smartlist_get(unrecognized, i));
  2964. goto done;
  2965. }
  2966. for (i = 0; i < smartlist_len(answers); i += 2) {
  2967. char *k = smartlist_get(answers, i);
  2968. char *v = smartlist_get(answers, i+1);
  2969. if (!strchr(v, '\n') && !strchr(v, '\r')) {
  2970. connection_printf_to_buf(conn, "250-%s=", k);
  2971. connection_write_str_to_buf(v, conn);
  2972. connection_write_str_to_buf("\r\n", conn);
  2973. } else {
  2974. char *esc = NULL;
  2975. size_t esc_len;
  2976. esc_len = write_escaped_data(v, strlen(v), &esc);
  2977. connection_printf_to_buf(conn, "250+%s=\r\n", k);
  2978. connection_buf_add(esc, esc_len, TO_CONN(conn));
  2979. tor_free(esc);
  2980. }
  2981. }
  2982. connection_write_str_to_buf("250 OK\r\n", conn);
  2983. done:
  2984. SMARTLIST_FOREACH(answers, char *, cp, tor_free(cp));
  2985. smartlist_free(answers);
  2986. SMARTLIST_FOREACH(questions, char *, cp, tor_free(cp));
  2987. smartlist_free(questions);
  2988. SMARTLIST_FOREACH(unrecognized, char *, cp, tor_free(cp));
  2989. smartlist_free(unrecognized);
  2990. return 0;
  2991. }
  2992. /** Given a string, convert it to a circuit purpose. */
  2993. static uint8_t
  2994. circuit_purpose_from_string(const char *string)
  2995. {
  2996. if (!strcasecmpstart(string, "purpose="))
  2997. string += strlen("purpose=");
  2998. if (!strcasecmp(string, "general"))
  2999. return CIRCUIT_PURPOSE_C_GENERAL;
  3000. else if (!strcasecmp(string, "controller"))
  3001. return CIRCUIT_PURPOSE_CONTROLLER;
  3002. else
  3003. return CIRCUIT_PURPOSE_UNKNOWN;
  3004. }
  3005. /** Return a newly allocated smartlist containing the arguments to the command
  3006. * waiting in <b>body</b>. If there are fewer than <b>min_args</b> arguments,
  3007. * or if <b>max_args</b> is nonnegative and there are more than
  3008. * <b>max_args</b> arguments, send a 512 error to the controller, using
  3009. * <b>command</b> as the command name in the error message. */
  3010. static smartlist_t *
  3011. getargs_helper(const char *command, control_connection_t *conn,
  3012. const char *body, int min_args, int max_args)
  3013. {
  3014. smartlist_t *args = smartlist_new();
  3015. smartlist_split_string(args, body, " ",
  3016. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3017. if (smartlist_len(args) < min_args) {
  3018. connection_printf_to_buf(conn, "512 Missing argument to %s\r\n",command);
  3019. goto err;
  3020. } else if (max_args >= 0 && smartlist_len(args) > max_args) {
  3021. connection_printf_to_buf(conn, "512 Too many arguments to %s\r\n",command);
  3022. goto err;
  3023. }
  3024. return args;
  3025. err:
  3026. SMARTLIST_FOREACH(args, char *, s, tor_free(s));
  3027. smartlist_free(args);
  3028. return NULL;
  3029. }
  3030. /** Helper. Return the first element of <b>sl</b> at index <b>start_at</b> or
  3031. * higher that starts with <b>prefix</b>, case-insensitive. Return NULL if no
  3032. * such element exists. */
  3033. static const char *
  3034. find_element_starting_with(smartlist_t *sl, int start_at, const char *prefix)
  3035. {
  3036. int i;
  3037. for (i = start_at; i < smartlist_len(sl); ++i) {
  3038. const char *elt = smartlist_get(sl, i);
  3039. if (!strcasecmpstart(elt, prefix))
  3040. return elt;
  3041. }
  3042. return NULL;
  3043. }
  3044. /** Helper. Return true iff s is an argument that we should treat as a
  3045. * key-value pair. */
  3046. static int
  3047. is_keyval_pair(const char *s)
  3048. {
  3049. /* An argument is a key-value pair if it has an =, and it isn't of the form
  3050. * $fingeprint=name */
  3051. return strchr(s, '=') && s[0] != '$';
  3052. }
  3053. /** Called when we get an EXTENDCIRCUIT message. Try to extend the listed
  3054. * circuit, and report success or failure. */
  3055. static int
  3056. handle_control_extendcircuit(control_connection_t *conn, uint32_t len,
  3057. const char *body)
  3058. {
  3059. smartlist_t *router_nicknames=NULL, *nodes=NULL;
  3060. origin_circuit_t *circ = NULL;
  3061. int zero_circ;
  3062. uint8_t intended_purpose = CIRCUIT_PURPOSE_C_GENERAL;
  3063. smartlist_t *args;
  3064. (void) len;
  3065. router_nicknames = smartlist_new();
  3066. args = getargs_helper("EXTENDCIRCUIT", conn, body, 1, -1);
  3067. if (!args)
  3068. goto done;
  3069. zero_circ = !strcmp("0", (char*)smartlist_get(args,0));
  3070. if (zero_circ) {
  3071. const char *purp = find_element_starting_with(args, 1, "PURPOSE=");
  3072. if (purp) {
  3073. intended_purpose = circuit_purpose_from_string(purp);
  3074. if (intended_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
  3075. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n", purp);
  3076. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3077. smartlist_free(args);
  3078. goto done;
  3079. }
  3080. }
  3081. if ((smartlist_len(args) == 1) ||
  3082. (smartlist_len(args) >= 2 && is_keyval_pair(smartlist_get(args, 1)))) {
  3083. // "EXTENDCIRCUIT 0" || EXTENDCIRCUIT 0 foo=bar"
  3084. circ = circuit_launch(intended_purpose, CIRCLAUNCH_NEED_CAPACITY);
  3085. if (!circ) {
  3086. connection_write_str_to_buf("551 Couldn't start circuit\r\n", conn);
  3087. } else {
  3088. connection_printf_to_buf(conn, "250 EXTENDED %lu\r\n",
  3089. (unsigned long)circ->global_identifier);
  3090. }
  3091. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3092. smartlist_free(args);
  3093. goto done;
  3094. }
  3095. // "EXTENDCIRCUIT 0 router1,router2" ||
  3096. // "EXTENDCIRCUIT 0 router1,router2 PURPOSE=foo"
  3097. }
  3098. if (!zero_circ && !(circ = get_circ(smartlist_get(args,0)))) {
  3099. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  3100. (char*)smartlist_get(args, 0));
  3101. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3102. smartlist_free(args);
  3103. goto done;
  3104. }
  3105. if (smartlist_len(args) < 2) {
  3106. connection_printf_to_buf(conn,
  3107. "512 syntax error: not enough arguments.\r\n");
  3108. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3109. smartlist_free(args);
  3110. goto done;
  3111. }
  3112. smartlist_split_string(router_nicknames, smartlist_get(args,1), ",", 0, 0);
  3113. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3114. smartlist_free(args);
  3115. nodes = smartlist_new();
  3116. SMARTLIST_FOREACH_BEGIN(router_nicknames, const char *, n) {
  3117. const node_t *node = node_get_by_nickname(n, 0);
  3118. if (!node) {
  3119. connection_printf_to_buf(conn, "552 No such router \"%s\"\r\n", n);
  3120. goto done;
  3121. }
  3122. if (!node_has_descriptor(node)) {
  3123. connection_printf_to_buf(conn, "552 No descriptor for \"%s\"\r\n", n);
  3124. goto done;
  3125. }
  3126. smartlist_add(nodes, (void*)node);
  3127. } SMARTLIST_FOREACH_END(n);
  3128. if (!smartlist_len(nodes)) {
  3129. connection_write_str_to_buf("512 No router names provided\r\n", conn);
  3130. goto done;
  3131. }
  3132. if (zero_circ) {
  3133. /* start a new circuit */
  3134. circ = origin_circuit_init(intended_purpose, 0);
  3135. }
  3136. /* now circ refers to something that is ready to be extended */
  3137. int first_node = zero_circ;
  3138. SMARTLIST_FOREACH(nodes, const node_t *, node,
  3139. {
  3140. extend_info_t *info = extend_info_from_node(node, first_node);
  3141. if (!info) {
  3142. tor_assert_nonfatal(first_node);
  3143. log_warn(LD_CONTROL,
  3144. "controller tried to connect to a node that doesn't have any "
  3145. "addresses that are allowed by the firewall configuration; "
  3146. "circuit marked for closing.");
  3147. circuit_mark_for_close(TO_CIRCUIT(circ), -END_CIRC_REASON_CONNECTFAILED);
  3148. connection_write_str_to_buf("551 Couldn't start circuit\r\n", conn);
  3149. goto done;
  3150. }
  3151. circuit_append_new_exit(circ, info);
  3152. extend_info_free(info);
  3153. first_node = 0;
  3154. });
  3155. /* now that we've populated the cpath, start extending */
  3156. if (zero_circ) {
  3157. int err_reason = 0;
  3158. if ((err_reason = circuit_handle_first_hop(circ)) < 0) {
  3159. circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
  3160. connection_write_str_to_buf("551 Couldn't start circuit\r\n", conn);
  3161. goto done;
  3162. }
  3163. } else {
  3164. if (circ->base_.state == CIRCUIT_STATE_OPEN ||
  3165. circ->base_.state == CIRCUIT_STATE_GUARD_WAIT) {
  3166. int err_reason = 0;
  3167. circuit_set_state(TO_CIRCUIT(circ), CIRCUIT_STATE_BUILDING);
  3168. if ((err_reason = circuit_send_next_onion_skin(circ)) < 0) {
  3169. log_info(LD_CONTROL,
  3170. "send_next_onion_skin failed; circuit marked for closing.");
  3171. circuit_mark_for_close(TO_CIRCUIT(circ), -err_reason);
  3172. connection_write_str_to_buf("551 Couldn't send onion skin\r\n", conn);
  3173. goto done;
  3174. }
  3175. }
  3176. }
  3177. connection_printf_to_buf(conn, "250 EXTENDED %lu\r\n",
  3178. (unsigned long)circ->global_identifier);
  3179. if (zero_circ) /* send a 'launched' event, for completeness */
  3180. control_event_circuit_status(circ, CIRC_EVENT_LAUNCHED, 0);
  3181. done:
  3182. SMARTLIST_FOREACH(router_nicknames, char *, n, tor_free(n));
  3183. smartlist_free(router_nicknames);
  3184. smartlist_free(nodes);
  3185. return 0;
  3186. }
  3187. /** Called when we get a SETCIRCUITPURPOSE message. If we can find the
  3188. * circuit and it's a valid purpose, change it. */
  3189. static int
  3190. handle_control_setcircuitpurpose(control_connection_t *conn,
  3191. uint32_t len, const char *body)
  3192. {
  3193. origin_circuit_t *circ = NULL;
  3194. uint8_t new_purpose;
  3195. smartlist_t *args;
  3196. (void) len; /* body is NUL-terminated, so it's safe to ignore the length. */
  3197. args = getargs_helper("SETCIRCUITPURPOSE", conn, body, 2, -1);
  3198. if (!args)
  3199. goto done;
  3200. if (!(circ = get_circ(smartlist_get(args,0)))) {
  3201. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  3202. (char*)smartlist_get(args, 0));
  3203. goto done;
  3204. }
  3205. {
  3206. const char *purp = find_element_starting_with(args,1,"PURPOSE=");
  3207. if (!purp) {
  3208. connection_write_str_to_buf("552 No purpose given\r\n", conn);
  3209. goto done;
  3210. }
  3211. new_purpose = circuit_purpose_from_string(purp);
  3212. if (new_purpose == CIRCUIT_PURPOSE_UNKNOWN) {
  3213. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n", purp);
  3214. goto done;
  3215. }
  3216. }
  3217. circuit_change_purpose(TO_CIRCUIT(circ), new_purpose);
  3218. connection_write_str_to_buf("250 OK\r\n", conn);
  3219. done:
  3220. if (args) {
  3221. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3222. smartlist_free(args);
  3223. }
  3224. return 0;
  3225. }
  3226. /** Called when we get an ATTACHSTREAM message. Try to attach the requested
  3227. * stream, and report success or failure. */
  3228. static int
  3229. handle_control_attachstream(control_connection_t *conn, uint32_t len,
  3230. const char *body)
  3231. {
  3232. entry_connection_t *ap_conn = NULL;
  3233. origin_circuit_t *circ = NULL;
  3234. int zero_circ;
  3235. smartlist_t *args;
  3236. crypt_path_t *cpath=NULL;
  3237. int hop=0, hop_line_ok=1;
  3238. (void) len;
  3239. args = getargs_helper("ATTACHSTREAM", conn, body, 2, -1);
  3240. if (!args)
  3241. return 0;
  3242. zero_circ = !strcmp("0", (char*)smartlist_get(args,1));
  3243. if (!(ap_conn = get_stream(smartlist_get(args, 0)))) {
  3244. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  3245. (char*)smartlist_get(args, 0));
  3246. } else if (!zero_circ && !(circ = get_circ(smartlist_get(args, 1)))) {
  3247. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  3248. (char*)smartlist_get(args, 1));
  3249. } else if (circ) {
  3250. const char *hopstring = find_element_starting_with(args,2,"HOP=");
  3251. if (hopstring) {
  3252. hopstring += strlen("HOP=");
  3253. hop = (int) tor_parse_ulong(hopstring, 10, 0, INT_MAX,
  3254. &hop_line_ok, NULL);
  3255. if (!hop_line_ok) { /* broken hop line */
  3256. connection_printf_to_buf(conn, "552 Bad value hop=%s\r\n", hopstring);
  3257. }
  3258. }
  3259. }
  3260. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3261. smartlist_free(args);
  3262. if (!ap_conn || (!zero_circ && !circ) || !hop_line_ok)
  3263. return 0;
  3264. if (ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONTROLLER_WAIT &&
  3265. ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONNECT_WAIT &&
  3266. ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_RESOLVE_WAIT) {
  3267. connection_write_str_to_buf(
  3268. "555 Connection is not managed by controller.\r\n",
  3269. conn);
  3270. return 0;
  3271. }
  3272. /* Do we need to detach it first? */
  3273. if (ENTRY_TO_CONN(ap_conn)->state != AP_CONN_STATE_CONTROLLER_WAIT) {
  3274. edge_connection_t *edge_conn = ENTRY_TO_EDGE_CONN(ap_conn);
  3275. circuit_t *tmpcirc = circuit_get_by_edge_conn(edge_conn);
  3276. connection_edge_end(edge_conn, END_STREAM_REASON_TIMEOUT);
  3277. /* Un-mark it as ending, since we're going to reuse it. */
  3278. edge_conn->edge_has_sent_end = 0;
  3279. edge_conn->end_reason = 0;
  3280. if (tmpcirc)
  3281. circuit_detach_stream(tmpcirc, edge_conn);
  3282. CONNECTION_AP_EXPECT_NONPENDING(ap_conn);
  3283. TO_CONN(edge_conn)->state = AP_CONN_STATE_CONTROLLER_WAIT;
  3284. }
  3285. if (circ && (circ->base_.state != CIRCUIT_STATE_OPEN)) {
  3286. connection_write_str_to_buf(
  3287. "551 Can't attach stream to non-open origin circuit\r\n",
  3288. conn);
  3289. return 0;
  3290. }
  3291. /* Is this a single hop circuit? */
  3292. if (circ && (circuit_get_cpath_len(circ)<2 || hop==1)) {
  3293. connection_write_str_to_buf(
  3294. "551 Can't attach stream to this one-hop circuit.\r\n", conn);
  3295. return 0;
  3296. }
  3297. if (circ && hop>0) {
  3298. /* find this hop in the circuit, and set cpath */
  3299. cpath = circuit_get_cpath_hop(circ, hop);
  3300. if (!cpath) {
  3301. connection_printf_to_buf(conn,
  3302. "551 Circuit doesn't have %d hops.\r\n", hop);
  3303. return 0;
  3304. }
  3305. }
  3306. if (connection_ap_handshake_rewrite_and_attach(ap_conn, circ, cpath) < 0) {
  3307. connection_write_str_to_buf("551 Unable to attach stream\r\n", conn);
  3308. return 0;
  3309. }
  3310. send_control_done(conn);
  3311. return 0;
  3312. }
  3313. /** Called when we get a POSTDESCRIPTOR message. Try to learn the provided
  3314. * descriptor, and report success or failure. */
  3315. static int
  3316. handle_control_postdescriptor(control_connection_t *conn, uint32_t len,
  3317. const char *body)
  3318. {
  3319. char *desc;
  3320. const char *msg=NULL;
  3321. uint8_t purpose = ROUTER_PURPOSE_GENERAL;
  3322. int cache = 0; /* eventually, we may switch this to 1 */
  3323. const char *cp = memchr(body, '\n', len);
  3324. if (cp == NULL) {
  3325. connection_printf_to_buf(conn, "251 Empty body\r\n");
  3326. return 0;
  3327. }
  3328. ++cp;
  3329. char *cmdline = tor_memdup_nulterm(body, cp-body);
  3330. smartlist_t *args = smartlist_new();
  3331. smartlist_split_string(args, cmdline, " ",
  3332. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3333. SMARTLIST_FOREACH_BEGIN(args, char *, option) {
  3334. if (!strcasecmpstart(option, "purpose=")) {
  3335. option += strlen("purpose=");
  3336. purpose = router_purpose_from_string(option);
  3337. if (purpose == ROUTER_PURPOSE_UNKNOWN) {
  3338. connection_printf_to_buf(conn, "552 Unknown purpose \"%s\"\r\n",
  3339. option);
  3340. goto done;
  3341. }
  3342. } else if (!strcasecmpstart(option, "cache=")) {
  3343. option += strlen("cache=");
  3344. if (!strcasecmp(option, "no"))
  3345. cache = 0;
  3346. else if (!strcasecmp(option, "yes"))
  3347. cache = 1;
  3348. else {
  3349. connection_printf_to_buf(conn, "552 Unknown cache request \"%s\"\r\n",
  3350. option);
  3351. goto done;
  3352. }
  3353. } else { /* unrecognized argument? */
  3354. connection_printf_to_buf(conn,
  3355. "512 Unexpected argument \"%s\" to postdescriptor\r\n", option);
  3356. goto done;
  3357. }
  3358. } SMARTLIST_FOREACH_END(option);
  3359. read_escaped_data(cp, len-(cp-body), &desc);
  3360. switch (router_load_single_router(desc, purpose, cache, &msg)) {
  3361. case -1:
  3362. if (!msg) msg = "Could not parse descriptor";
  3363. connection_printf_to_buf(conn, "554 %s\r\n", msg);
  3364. break;
  3365. case 0:
  3366. if (!msg) msg = "Descriptor not added";
  3367. connection_printf_to_buf(conn, "251 %s\r\n",msg);
  3368. break;
  3369. case 1:
  3370. send_control_done(conn);
  3371. break;
  3372. }
  3373. tor_free(desc);
  3374. done:
  3375. SMARTLIST_FOREACH(args, char *, arg, tor_free(arg));
  3376. smartlist_free(args);
  3377. tor_free(cmdline);
  3378. return 0;
  3379. }
  3380. /** Called when we receive a REDIRECTSTERAM command. Try to change the target
  3381. * address of the named AP stream, and report success or failure. */
  3382. static int
  3383. handle_control_redirectstream(control_connection_t *conn, uint32_t len,
  3384. const char *body)
  3385. {
  3386. entry_connection_t *ap_conn = NULL;
  3387. char *new_addr = NULL;
  3388. uint16_t new_port = 0;
  3389. smartlist_t *args;
  3390. (void) len;
  3391. args = getargs_helper("REDIRECTSTREAM", conn, body, 2, -1);
  3392. if (!args)
  3393. return 0;
  3394. if (!(ap_conn = get_stream(smartlist_get(args, 0)))
  3395. || !ap_conn->socks_request) {
  3396. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  3397. (char*)smartlist_get(args, 0));
  3398. } else {
  3399. int ok = 1;
  3400. if (smartlist_len(args) > 2) { /* they included a port too */
  3401. new_port = (uint16_t) tor_parse_ulong(smartlist_get(args, 2),
  3402. 10, 1, 65535, &ok, NULL);
  3403. }
  3404. if (!ok) {
  3405. connection_printf_to_buf(conn, "512 Cannot parse port \"%s\"\r\n",
  3406. (char*)smartlist_get(args, 2));
  3407. } else {
  3408. new_addr = tor_strdup(smartlist_get(args, 1));
  3409. }
  3410. }
  3411. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3412. smartlist_free(args);
  3413. if (!new_addr)
  3414. return 0;
  3415. strlcpy(ap_conn->socks_request->address, new_addr,
  3416. sizeof(ap_conn->socks_request->address));
  3417. if (new_port)
  3418. ap_conn->socks_request->port = new_port;
  3419. tor_free(new_addr);
  3420. send_control_done(conn);
  3421. return 0;
  3422. }
  3423. /** Called when we get a CLOSESTREAM command; try to close the named stream
  3424. * and report success or failure. */
  3425. static int
  3426. handle_control_closestream(control_connection_t *conn, uint32_t len,
  3427. const char *body)
  3428. {
  3429. entry_connection_t *ap_conn=NULL;
  3430. uint8_t reason=0;
  3431. smartlist_t *args;
  3432. int ok;
  3433. (void) len;
  3434. args = getargs_helper("CLOSESTREAM", conn, body, 2, -1);
  3435. if (!args)
  3436. return 0;
  3437. else if (!(ap_conn = get_stream(smartlist_get(args, 0))))
  3438. connection_printf_to_buf(conn, "552 Unknown stream \"%s\"\r\n",
  3439. (char*)smartlist_get(args, 0));
  3440. else {
  3441. reason = (uint8_t) tor_parse_ulong(smartlist_get(args,1), 10, 0, 255,
  3442. &ok, NULL);
  3443. if (!ok) {
  3444. connection_printf_to_buf(conn, "552 Unrecognized reason \"%s\"\r\n",
  3445. (char*)smartlist_get(args, 1));
  3446. ap_conn = NULL;
  3447. }
  3448. }
  3449. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3450. smartlist_free(args);
  3451. if (!ap_conn)
  3452. return 0;
  3453. connection_mark_unattached_ap(ap_conn, reason);
  3454. send_control_done(conn);
  3455. return 0;
  3456. }
  3457. /** Called when we get a CLOSECIRCUIT command; try to close the named circuit
  3458. * and report success or failure. */
  3459. static int
  3460. handle_control_closecircuit(control_connection_t *conn, uint32_t len,
  3461. const char *body)
  3462. {
  3463. origin_circuit_t *circ = NULL;
  3464. int safe = 0;
  3465. smartlist_t *args;
  3466. (void) len;
  3467. args = getargs_helper("CLOSECIRCUIT", conn, body, 1, -1);
  3468. if (!args)
  3469. return 0;
  3470. if (!(circ=get_circ(smartlist_get(args, 0))))
  3471. connection_printf_to_buf(conn, "552 Unknown circuit \"%s\"\r\n",
  3472. (char*)smartlist_get(args, 0));
  3473. else {
  3474. int i;
  3475. for (i=1; i < smartlist_len(args); ++i) {
  3476. if (!strcasecmp(smartlist_get(args, i), "IfUnused"))
  3477. safe = 1;
  3478. else
  3479. log_info(LD_CONTROL, "Skipping unknown option %s",
  3480. (char*)smartlist_get(args,i));
  3481. }
  3482. }
  3483. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3484. smartlist_free(args);
  3485. if (!circ)
  3486. return 0;
  3487. if (!safe || !circ->p_streams) {
  3488. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_REQUESTED);
  3489. }
  3490. send_control_done(conn);
  3491. return 0;
  3492. }
  3493. /** Called when we get a RESOLVE command: start trying to resolve
  3494. * the listed addresses. */
  3495. static int
  3496. handle_control_resolve(control_connection_t *conn, uint32_t len,
  3497. const char *body)
  3498. {
  3499. smartlist_t *args, *failed;
  3500. int is_reverse = 0;
  3501. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  3502. if (!(conn->event_mask & (((event_mask_t)1)<<EVENT_ADDRMAP))) {
  3503. log_warn(LD_CONTROL, "Controller asked us to resolve an address, but "
  3504. "isn't listening for ADDRMAP events. It probably won't see "
  3505. "the answer.");
  3506. }
  3507. args = smartlist_new();
  3508. smartlist_split_string(args, body, " ",
  3509. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3510. {
  3511. const char *modearg = find_element_starting_with(args, 0, "mode=");
  3512. if (modearg && !strcasecmp(modearg, "mode=reverse"))
  3513. is_reverse = 1;
  3514. }
  3515. failed = smartlist_new();
  3516. SMARTLIST_FOREACH(args, const char *, arg, {
  3517. if (!is_keyval_pair(arg)) {
  3518. if (dnsserv_launch_request(arg, is_reverse, conn)<0)
  3519. smartlist_add(failed, (char*)arg);
  3520. }
  3521. });
  3522. send_control_done(conn);
  3523. SMARTLIST_FOREACH(failed, const char *, arg, {
  3524. control_event_address_mapped(arg, arg, time(NULL),
  3525. "internal", 0);
  3526. });
  3527. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3528. smartlist_free(args);
  3529. smartlist_free(failed);
  3530. return 0;
  3531. }
  3532. /** Called when we get a PROTOCOLINFO command: send back a reply. */
  3533. static int
  3534. handle_control_protocolinfo(control_connection_t *conn, uint32_t len,
  3535. const char *body)
  3536. {
  3537. const char *bad_arg = NULL;
  3538. smartlist_t *args;
  3539. (void)len;
  3540. conn->have_sent_protocolinfo = 1;
  3541. args = smartlist_new();
  3542. smartlist_split_string(args, body, " ",
  3543. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3544. SMARTLIST_FOREACH(args, const char *, arg, {
  3545. int ok;
  3546. tor_parse_long(arg, 10, 0, LONG_MAX, &ok, NULL);
  3547. if (!ok) {
  3548. bad_arg = arg;
  3549. break;
  3550. }
  3551. });
  3552. if (bad_arg) {
  3553. connection_printf_to_buf(conn, "513 No such version %s\r\n",
  3554. escaped(bad_arg));
  3555. /* Don't tolerate bad arguments when not authenticated. */
  3556. if (!STATE_IS_OPEN(TO_CONN(conn)->state))
  3557. connection_mark_for_close(TO_CONN(conn));
  3558. goto done;
  3559. } else {
  3560. const or_options_t *options = get_options();
  3561. int cookies = options->CookieAuthentication;
  3562. char *cfile = get_controller_cookie_file_name();
  3563. char *abs_cfile;
  3564. char *esc_cfile;
  3565. char *methods;
  3566. abs_cfile = make_path_absolute(cfile);
  3567. esc_cfile = esc_for_log(abs_cfile);
  3568. {
  3569. int passwd = (options->HashedControlPassword != NULL ||
  3570. options->HashedControlSessionPassword != NULL);
  3571. smartlist_t *mlist = smartlist_new();
  3572. if (cookies) {
  3573. smartlist_add(mlist, (char*)"COOKIE");
  3574. smartlist_add(mlist, (char*)"SAFECOOKIE");
  3575. }
  3576. if (passwd)
  3577. smartlist_add(mlist, (char*)"HASHEDPASSWORD");
  3578. if (!cookies && !passwd)
  3579. smartlist_add(mlist, (char*)"NULL");
  3580. methods = smartlist_join_strings(mlist, ",", 0, NULL);
  3581. smartlist_free(mlist);
  3582. }
  3583. connection_printf_to_buf(conn,
  3584. "250-PROTOCOLINFO 1\r\n"
  3585. "250-AUTH METHODS=%s%s%s\r\n"
  3586. "250-VERSION Tor=%s\r\n"
  3587. "250 OK\r\n",
  3588. methods,
  3589. cookies?" COOKIEFILE=":"",
  3590. cookies?esc_cfile:"",
  3591. escaped(VERSION));
  3592. tor_free(methods);
  3593. tor_free(cfile);
  3594. tor_free(abs_cfile);
  3595. tor_free(esc_cfile);
  3596. }
  3597. done:
  3598. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3599. smartlist_free(args);
  3600. return 0;
  3601. }
  3602. /** Called when we get an AUTHCHALLENGE command. */
  3603. static int
  3604. handle_control_authchallenge(control_connection_t *conn, uint32_t len,
  3605. const char *body)
  3606. {
  3607. const char *cp = body;
  3608. char *client_nonce;
  3609. size_t client_nonce_len;
  3610. char server_hash[DIGEST256_LEN];
  3611. char server_hash_encoded[HEX_DIGEST256_LEN+1];
  3612. char server_nonce[SAFECOOKIE_SERVER_NONCE_LEN];
  3613. char server_nonce_encoded[(2*SAFECOOKIE_SERVER_NONCE_LEN) + 1];
  3614. cp += strspn(cp, " \t\n\r");
  3615. if (!strcasecmpstart(cp, "SAFECOOKIE")) {
  3616. cp += strlen("SAFECOOKIE");
  3617. } else {
  3618. connection_write_str_to_buf("513 AUTHCHALLENGE only supports SAFECOOKIE "
  3619. "authentication\r\n", conn);
  3620. connection_mark_for_close(TO_CONN(conn));
  3621. return -1;
  3622. }
  3623. if (!authentication_cookie_is_set) {
  3624. connection_write_str_to_buf("515 Cookie authentication is disabled\r\n",
  3625. conn);
  3626. connection_mark_for_close(TO_CONN(conn));
  3627. return -1;
  3628. }
  3629. cp += strspn(cp, " \t\n\r");
  3630. if (*cp == '"') {
  3631. const char *newcp =
  3632. decode_escaped_string(cp, len - (cp - body),
  3633. &client_nonce, &client_nonce_len);
  3634. if (newcp == NULL) {
  3635. connection_write_str_to_buf("513 Invalid quoted client nonce\r\n",
  3636. conn);
  3637. connection_mark_for_close(TO_CONN(conn));
  3638. return -1;
  3639. }
  3640. cp = newcp;
  3641. } else {
  3642. size_t client_nonce_encoded_len = strspn(cp, "0123456789ABCDEFabcdef");
  3643. client_nonce_len = client_nonce_encoded_len / 2;
  3644. client_nonce = tor_malloc_zero(client_nonce_len);
  3645. if (base16_decode(client_nonce, client_nonce_len,
  3646. cp, client_nonce_encoded_len)
  3647. != (int) client_nonce_len) {
  3648. connection_write_str_to_buf("513 Invalid base16 client nonce\r\n",
  3649. conn);
  3650. connection_mark_for_close(TO_CONN(conn));
  3651. tor_free(client_nonce);
  3652. return -1;
  3653. }
  3654. cp += client_nonce_encoded_len;
  3655. }
  3656. cp += strspn(cp, " \t\n\r");
  3657. if (*cp != '\0' ||
  3658. cp != body + len) {
  3659. connection_write_str_to_buf("513 Junk at end of AUTHCHALLENGE command\r\n",
  3660. conn);
  3661. connection_mark_for_close(TO_CONN(conn));
  3662. tor_free(client_nonce);
  3663. return -1;
  3664. }
  3665. crypto_rand(server_nonce, SAFECOOKIE_SERVER_NONCE_LEN);
  3666. /* Now compute and send the server-to-controller response, and the
  3667. * server's nonce. */
  3668. tor_assert(authentication_cookie != NULL);
  3669. {
  3670. size_t tmp_len = (AUTHENTICATION_COOKIE_LEN +
  3671. client_nonce_len +
  3672. SAFECOOKIE_SERVER_NONCE_LEN);
  3673. char *tmp = tor_malloc_zero(tmp_len);
  3674. char *client_hash = tor_malloc_zero(DIGEST256_LEN);
  3675. memcpy(tmp, authentication_cookie, AUTHENTICATION_COOKIE_LEN);
  3676. memcpy(tmp + AUTHENTICATION_COOKIE_LEN, client_nonce, client_nonce_len);
  3677. memcpy(tmp + AUTHENTICATION_COOKIE_LEN + client_nonce_len,
  3678. server_nonce, SAFECOOKIE_SERVER_NONCE_LEN);
  3679. crypto_hmac_sha256(server_hash,
  3680. SAFECOOKIE_SERVER_TO_CONTROLLER_CONSTANT,
  3681. strlen(SAFECOOKIE_SERVER_TO_CONTROLLER_CONSTANT),
  3682. tmp,
  3683. tmp_len);
  3684. crypto_hmac_sha256(client_hash,
  3685. SAFECOOKIE_CONTROLLER_TO_SERVER_CONSTANT,
  3686. strlen(SAFECOOKIE_CONTROLLER_TO_SERVER_CONSTANT),
  3687. tmp,
  3688. tmp_len);
  3689. conn->safecookie_client_hash = client_hash;
  3690. tor_free(tmp);
  3691. }
  3692. base16_encode(server_hash_encoded, sizeof(server_hash_encoded),
  3693. server_hash, sizeof(server_hash));
  3694. base16_encode(server_nonce_encoded, sizeof(server_nonce_encoded),
  3695. server_nonce, sizeof(server_nonce));
  3696. connection_printf_to_buf(conn,
  3697. "250 AUTHCHALLENGE SERVERHASH=%s "
  3698. "SERVERNONCE=%s\r\n",
  3699. server_hash_encoded,
  3700. server_nonce_encoded);
  3701. tor_free(client_nonce);
  3702. return 0;
  3703. }
  3704. /** Called when we get a USEFEATURE command: parse the feature list, and
  3705. * set up the control_connection's options properly. */
  3706. static int
  3707. handle_control_usefeature(control_connection_t *conn,
  3708. uint32_t len,
  3709. const char *body)
  3710. {
  3711. smartlist_t *args;
  3712. int bad = 0;
  3713. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  3714. args = smartlist_new();
  3715. smartlist_split_string(args, body, " ",
  3716. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3717. SMARTLIST_FOREACH_BEGIN(args, const char *, arg) {
  3718. if (!strcasecmp(arg, "VERBOSE_NAMES"))
  3719. ;
  3720. else if (!strcasecmp(arg, "EXTENDED_EVENTS"))
  3721. ;
  3722. else {
  3723. connection_printf_to_buf(conn, "552 Unrecognized feature \"%s\"\r\n",
  3724. arg);
  3725. bad = 1;
  3726. break;
  3727. }
  3728. } SMARTLIST_FOREACH_END(arg);
  3729. if (!bad) {
  3730. send_control_done(conn);
  3731. }
  3732. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3733. smartlist_free(args);
  3734. return 0;
  3735. }
  3736. /** Implementation for the DROPGUARDS command. */
  3737. static int
  3738. handle_control_dropguards(control_connection_t *conn,
  3739. uint32_t len,
  3740. const char *body)
  3741. {
  3742. smartlist_t *args;
  3743. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  3744. args = smartlist_new();
  3745. smartlist_split_string(args, body, " ",
  3746. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3747. static int have_warned = 0;
  3748. if (! have_warned) {
  3749. log_warn(LD_CONTROL, "DROPGUARDS is dangerous; make sure you understand "
  3750. "the risks before using it. It may be removed in a future "
  3751. "version of Tor.");
  3752. have_warned = 1;
  3753. }
  3754. if (smartlist_len(args)) {
  3755. connection_printf_to_buf(conn, "512 Too many arguments to DROPGUARDS\r\n");
  3756. } else {
  3757. remove_all_entry_guards();
  3758. send_control_done(conn);
  3759. }
  3760. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3761. smartlist_free(args);
  3762. return 0;
  3763. }
  3764. /** Implementation for the HSFETCH command. */
  3765. static int
  3766. handle_control_hsfetch(control_connection_t *conn, uint32_t len,
  3767. const char *body)
  3768. {
  3769. int i;
  3770. char digest[DIGEST_LEN], *hsaddress = NULL, *arg1 = NULL, *desc_id = NULL;
  3771. smartlist_t *args = NULL, *hsdirs = NULL;
  3772. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  3773. static const char *hsfetch_command = "HSFETCH";
  3774. static const char *v2_str = "v2-";
  3775. const size_t v2_str_len = strlen(v2_str);
  3776. rend_data_t *rend_query = NULL;
  3777. /* Make sure we have at least one argument, the HSAddress. */
  3778. args = getargs_helper(hsfetch_command, conn, body, 1, -1);
  3779. if (!args) {
  3780. goto exit;
  3781. }
  3782. /* Extract the first argument (either HSAddress or DescID). */
  3783. arg1 = smartlist_get(args, 0);
  3784. /* Test if it's an HS address without the .onion part. */
  3785. if (rend_valid_v2_service_id(arg1)) {
  3786. hsaddress = arg1;
  3787. } else if (strcmpstart(arg1, v2_str) == 0 &&
  3788. rend_valid_descriptor_id(arg1 + v2_str_len) &&
  3789. base32_decode(digest, sizeof(digest), arg1 + v2_str_len,
  3790. REND_DESC_ID_V2_LEN_BASE32) == 0) {
  3791. /* We have a well formed version 2 descriptor ID. Keep the decoded value
  3792. * of the id. */
  3793. desc_id = digest;
  3794. } else {
  3795. connection_printf_to_buf(conn, "513 Invalid argument \"%s\"\r\n",
  3796. arg1);
  3797. goto done;
  3798. }
  3799. static const char *opt_server = "SERVER=";
  3800. /* Skip first argument because it's the HSAddress or DescID. */
  3801. for (i = 1; i < smartlist_len(args); ++i) {
  3802. const char *arg = smartlist_get(args, i);
  3803. const node_t *node;
  3804. if (!strcasecmpstart(arg, opt_server)) {
  3805. const char *server;
  3806. server = arg + strlen(opt_server);
  3807. node = node_get_by_hex_id(server, 0);
  3808. if (!node) {
  3809. connection_printf_to_buf(conn, "552 Server \"%s\" not found\r\n",
  3810. server);
  3811. goto done;
  3812. }
  3813. if (!hsdirs) {
  3814. /* Stores routerstatus_t object for each specified server. */
  3815. hsdirs = smartlist_new();
  3816. }
  3817. /* Valid server, add it to our local list. */
  3818. smartlist_add(hsdirs, node->rs);
  3819. } else {
  3820. connection_printf_to_buf(conn, "513 Unexpected argument \"%s\"\r\n",
  3821. arg);
  3822. goto done;
  3823. }
  3824. }
  3825. rend_query = rend_data_client_create(hsaddress, desc_id, NULL,
  3826. REND_NO_AUTH);
  3827. if (rend_query == NULL) {
  3828. connection_printf_to_buf(conn, "551 Error creating the HS query\r\n");
  3829. goto done;
  3830. }
  3831. /* Using a descriptor ID, we force the user to provide at least one
  3832. * hsdir server using the SERVER= option. */
  3833. if (desc_id && (!hsdirs || !smartlist_len(hsdirs))) {
  3834. connection_printf_to_buf(conn, "512 %s option is required\r\n",
  3835. opt_server);
  3836. goto done;
  3837. }
  3838. /* We are about to trigger HSDir fetch so send the OK now because after
  3839. * that 650 event(s) are possible so better to have the 250 OK before them
  3840. * to avoid out of order replies. */
  3841. send_control_done(conn);
  3842. /* Trigger the fetch using the built rend query and possibly a list of HS
  3843. * directory to use. This function ignores the client cache thus this will
  3844. * always send a fetch command. */
  3845. rend_client_fetch_v2_desc(rend_query, hsdirs);
  3846. done:
  3847. SMARTLIST_FOREACH(args, char *, cp, tor_free(cp));
  3848. smartlist_free(args);
  3849. /* Contains data pointer that we don't own thus no cleanup. */
  3850. smartlist_free(hsdirs);
  3851. rend_data_free(rend_query);
  3852. exit:
  3853. return 0;
  3854. }
  3855. /** Implementation for the HSPOST command. */
  3856. static int
  3857. handle_control_hspost(control_connection_t *conn,
  3858. uint32_t len,
  3859. const char *body)
  3860. {
  3861. static const char *opt_server = "SERVER=";
  3862. smartlist_t *hs_dirs = NULL;
  3863. const char *encoded_desc = body;
  3864. size_t encoded_desc_len = len;
  3865. char *cp = memchr(body, '\n', len);
  3866. if (cp == NULL) {
  3867. connection_printf_to_buf(conn, "251 Empty body\r\n");
  3868. return 0;
  3869. }
  3870. char *argline = tor_strndup(body, cp-body);
  3871. smartlist_t *args = smartlist_new();
  3872. /* If any SERVER= options were specified, try parse the options line */
  3873. if (!strcasecmpstart(argline, opt_server)) {
  3874. /* encoded_desc begins after a newline character */
  3875. cp = cp + 1;
  3876. encoded_desc = cp;
  3877. encoded_desc_len = len-(cp-body);
  3878. smartlist_split_string(args, argline, " ",
  3879. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 0);
  3880. SMARTLIST_FOREACH_BEGIN(args, const char *, arg) {
  3881. if (!strcasecmpstart(arg, opt_server)) {
  3882. const char *server = arg + strlen(opt_server);
  3883. const node_t *node = node_get_by_hex_id(server, 0);
  3884. if (!node || !node->rs) {
  3885. connection_printf_to_buf(conn, "552 Server \"%s\" not found\r\n",
  3886. server);
  3887. goto done;
  3888. }
  3889. if (!node->rs->is_hs_dir) {
  3890. connection_printf_to_buf(conn, "552 Server \"%s\" is not a HSDir"
  3891. "\r\n", server);
  3892. goto done;
  3893. }
  3894. /* Valid server, add it to our local list. */
  3895. if (!hs_dirs)
  3896. hs_dirs = smartlist_new();
  3897. smartlist_add(hs_dirs, node->rs);
  3898. } else {
  3899. connection_printf_to_buf(conn, "512 Unexpected argument \"%s\"\r\n",
  3900. arg);
  3901. goto done;
  3902. }
  3903. } SMARTLIST_FOREACH_END(arg);
  3904. }
  3905. /* Read the dot encoded descriptor, and parse it. */
  3906. rend_encoded_v2_service_descriptor_t *desc =
  3907. tor_malloc_zero(sizeof(rend_encoded_v2_service_descriptor_t));
  3908. read_escaped_data(encoded_desc, encoded_desc_len, &desc->desc_str);
  3909. rend_service_descriptor_t *parsed = NULL;
  3910. char *intro_content = NULL;
  3911. size_t intro_size;
  3912. size_t encoded_size;
  3913. const char *next_desc;
  3914. if (!rend_parse_v2_service_descriptor(&parsed, desc->desc_id, &intro_content,
  3915. &intro_size, &encoded_size,
  3916. &next_desc, desc->desc_str, 1)) {
  3917. /* Post the descriptor. */
  3918. char serviceid[REND_SERVICE_ID_LEN_BASE32+1];
  3919. if (!rend_get_service_id(parsed->pk, serviceid)) {
  3920. smartlist_t *descs = smartlist_new();
  3921. smartlist_add(descs, desc);
  3922. /* We are about to trigger HS descriptor upload so send the OK now
  3923. * because after that 650 event(s) are possible so better to have the
  3924. * 250 OK before them to avoid out of order replies. */
  3925. send_control_done(conn);
  3926. /* Trigger the descriptor upload */
  3927. directory_post_to_hs_dir(parsed, descs, hs_dirs, serviceid, 0);
  3928. smartlist_free(descs);
  3929. }
  3930. rend_service_descriptor_free(parsed);
  3931. } else {
  3932. connection_printf_to_buf(conn, "554 Invalid descriptor\r\n");
  3933. }
  3934. tor_free(intro_content);
  3935. rend_encoded_v2_service_descriptor_free(desc);
  3936. done:
  3937. tor_free(argline);
  3938. smartlist_free(hs_dirs); /* Contents belong to the rend service code. */
  3939. SMARTLIST_FOREACH(args, char *, arg, tor_free(arg));
  3940. smartlist_free(args);
  3941. return 0;
  3942. }
  3943. /** Called when we get a ADD_ONION command; parse the body, and set up
  3944. * the new ephemeral Onion Service. */
  3945. static int
  3946. handle_control_add_onion(control_connection_t *conn,
  3947. uint32_t len,
  3948. const char *body)
  3949. {
  3950. smartlist_t *args;
  3951. size_t arg_len;
  3952. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  3953. args = getargs_helper("ADD_ONION", conn, body, 2, -1);
  3954. if (!args)
  3955. return 0;
  3956. arg_len = smartlist_len(args);
  3957. /* Parse all of the arguments that do not involve handling cryptographic
  3958. * material first, since there's no reason to touch that at all if any of
  3959. * the other arguments are malformed.
  3960. */
  3961. smartlist_t *port_cfgs = smartlist_new();
  3962. smartlist_t *auth_clients = NULL;
  3963. smartlist_t *auth_created_clients = NULL;
  3964. int discard_pk = 0;
  3965. int detach = 0;
  3966. int max_streams = 0;
  3967. int max_streams_close_circuit = 0;
  3968. rend_auth_type_t auth_type = REND_NO_AUTH;
  3969. /* Default to adding an anonymous hidden service if no flag is given */
  3970. int non_anonymous = 0;
  3971. for (size_t i = 1; i < arg_len; i++) {
  3972. static const char *port_prefix = "Port=";
  3973. static const char *flags_prefix = "Flags=";
  3974. static const char *max_s_prefix = "MaxStreams=";
  3975. static const char *auth_prefix = "ClientAuth=";
  3976. const char *arg = smartlist_get(args, i);
  3977. if (!strcasecmpstart(arg, port_prefix)) {
  3978. /* "Port=VIRTPORT[,TARGET]". */
  3979. const char *port_str = arg + strlen(port_prefix);
  3980. rend_service_port_config_t *cfg =
  3981. rend_service_parse_port_config(port_str, ",", NULL);
  3982. if (!cfg) {
  3983. connection_printf_to_buf(conn, "512 Invalid VIRTPORT/TARGET\r\n");
  3984. goto out;
  3985. }
  3986. smartlist_add(port_cfgs, cfg);
  3987. } else if (!strcasecmpstart(arg, max_s_prefix)) {
  3988. /* "MaxStreams=[0..65535]". */
  3989. const char *max_s_str = arg + strlen(max_s_prefix);
  3990. int ok = 0;
  3991. max_streams = (int)tor_parse_long(max_s_str, 10, 0, 65535, &ok, NULL);
  3992. if (!ok) {
  3993. connection_printf_to_buf(conn, "512 Invalid MaxStreams\r\n");
  3994. goto out;
  3995. }
  3996. } else if (!strcasecmpstart(arg, flags_prefix)) {
  3997. /* "Flags=Flag[,Flag]", where Flag can be:
  3998. * * 'DiscardPK' - If tor generates the keypair, do not include it in
  3999. * the response.
  4000. * * 'Detach' - Do not tie this onion service to any particular control
  4001. * connection.
  4002. * * 'MaxStreamsCloseCircuit' - Close the circuit if MaxStreams is
  4003. * exceeded.
  4004. * * 'BasicAuth' - Client authorization using the 'basic' method.
  4005. * * 'NonAnonymous' - Add a non-anonymous Single Onion Service. If this
  4006. * flag is present, tor must be in non-anonymous
  4007. * hidden service mode. If this flag is absent,
  4008. * tor must be in anonymous hidden service mode.
  4009. */
  4010. static const char *discard_flag = "DiscardPK";
  4011. static const char *detach_flag = "Detach";
  4012. static const char *max_s_close_flag = "MaxStreamsCloseCircuit";
  4013. static const char *basicauth_flag = "BasicAuth";
  4014. static const char *non_anonymous_flag = "NonAnonymous";
  4015. smartlist_t *flags = smartlist_new();
  4016. int bad = 0;
  4017. smartlist_split_string(flags, arg + strlen(flags_prefix), ",",
  4018. SPLIT_IGNORE_BLANK, 0);
  4019. if (smartlist_len(flags) < 1) {
  4020. connection_printf_to_buf(conn, "512 Invalid 'Flags' argument\r\n");
  4021. bad = 1;
  4022. }
  4023. SMARTLIST_FOREACH_BEGIN(flags, const char *, flag)
  4024. {
  4025. if (!strcasecmp(flag, discard_flag)) {
  4026. discard_pk = 1;
  4027. } else if (!strcasecmp(flag, detach_flag)) {
  4028. detach = 1;
  4029. } else if (!strcasecmp(flag, max_s_close_flag)) {
  4030. max_streams_close_circuit = 1;
  4031. } else if (!strcasecmp(flag, basicauth_flag)) {
  4032. auth_type = REND_BASIC_AUTH;
  4033. } else if (!strcasecmp(flag, non_anonymous_flag)) {
  4034. non_anonymous = 1;
  4035. } else {
  4036. connection_printf_to_buf(conn,
  4037. "512 Invalid 'Flags' argument: %s\r\n",
  4038. escaped(flag));
  4039. bad = 1;
  4040. break;
  4041. }
  4042. } SMARTLIST_FOREACH_END(flag);
  4043. SMARTLIST_FOREACH(flags, char *, cp, tor_free(cp));
  4044. smartlist_free(flags);
  4045. if (bad)
  4046. goto out;
  4047. } else if (!strcasecmpstart(arg, auth_prefix)) {
  4048. char *err_msg = NULL;
  4049. int created = 0;
  4050. rend_authorized_client_t *client =
  4051. add_onion_helper_clientauth(arg + strlen(auth_prefix),
  4052. &created, &err_msg);
  4053. if (!client) {
  4054. if (err_msg) {
  4055. connection_write_str_to_buf(err_msg, conn);
  4056. tor_free(err_msg);
  4057. }
  4058. goto out;
  4059. }
  4060. if (auth_clients != NULL) {
  4061. int bad = 0;
  4062. SMARTLIST_FOREACH_BEGIN(auth_clients, rend_authorized_client_t *, ac) {
  4063. if (strcmp(ac->client_name, client->client_name) == 0) {
  4064. bad = 1;
  4065. break;
  4066. }
  4067. } SMARTLIST_FOREACH_END(ac);
  4068. if (bad) {
  4069. connection_printf_to_buf(conn,
  4070. "512 Duplicate name in ClientAuth\r\n");
  4071. rend_authorized_client_free(client);
  4072. goto out;
  4073. }
  4074. } else {
  4075. auth_clients = smartlist_new();
  4076. auth_created_clients = smartlist_new();
  4077. }
  4078. smartlist_add(auth_clients, client);
  4079. if (created) {
  4080. smartlist_add(auth_created_clients, client);
  4081. }
  4082. } else {
  4083. connection_printf_to_buf(conn, "513 Invalid argument\r\n");
  4084. goto out;
  4085. }
  4086. }
  4087. if (smartlist_len(port_cfgs) == 0) {
  4088. connection_printf_to_buf(conn, "512 Missing 'Port' argument\r\n");
  4089. goto out;
  4090. } else if (auth_type == REND_NO_AUTH && auth_clients != NULL) {
  4091. connection_printf_to_buf(conn, "512 No auth type specified\r\n");
  4092. goto out;
  4093. } else if (auth_type != REND_NO_AUTH && auth_clients == NULL) {
  4094. connection_printf_to_buf(conn, "512 No auth clients specified\r\n");
  4095. goto out;
  4096. } else if ((auth_type == REND_BASIC_AUTH &&
  4097. smartlist_len(auth_clients) > 512) ||
  4098. (auth_type == REND_STEALTH_AUTH &&
  4099. smartlist_len(auth_clients) > 16)) {
  4100. connection_printf_to_buf(conn, "512 Too many auth clients\r\n");
  4101. goto out;
  4102. } else if (non_anonymous != rend_service_non_anonymous_mode_enabled(
  4103. get_options())) {
  4104. /* If we failed, and the non-anonymous flag is set, Tor must be in
  4105. * anonymous hidden service mode.
  4106. * The error message changes based on the current Tor config:
  4107. * 512 Tor is in anonymous hidden service mode
  4108. * 512 Tor is in non-anonymous hidden service mode
  4109. * (I've deliberately written them out in full here to aid searchability.)
  4110. */
  4111. connection_printf_to_buf(conn, "512 Tor is in %sanonymous hidden service "
  4112. "mode\r\n",
  4113. non_anonymous ? "" : "non-");
  4114. goto out;
  4115. }
  4116. /* Parse the "keytype:keyblob" argument. */
  4117. crypto_pk_t *pk = NULL;
  4118. const char *key_new_alg = NULL;
  4119. char *key_new_blob = NULL;
  4120. char *err_msg = NULL;
  4121. pk = add_onion_helper_keyarg(smartlist_get(args, 0), discard_pk,
  4122. &key_new_alg, &key_new_blob,
  4123. &err_msg);
  4124. if (!pk) {
  4125. if (err_msg) {
  4126. connection_write_str_to_buf(err_msg, conn);
  4127. tor_free(err_msg);
  4128. }
  4129. goto out;
  4130. }
  4131. tor_assert(!err_msg);
  4132. /* Create the HS, using private key pk, client authentication auth_type,
  4133. * the list of auth_clients, and port config port_cfg.
  4134. * rend_service_add_ephemeral() will take ownership of pk and port_cfg,
  4135. * regardless of success/failure.
  4136. */
  4137. char *service_id = NULL;
  4138. int ret = rend_service_add_ephemeral(pk, port_cfgs, max_streams,
  4139. max_streams_close_circuit,
  4140. auth_type, auth_clients,
  4141. &service_id);
  4142. port_cfgs = NULL; /* port_cfgs is now owned by the rendservice code. */
  4143. auth_clients = NULL; /* so is auth_clients */
  4144. switch (ret) {
  4145. case RSAE_OKAY:
  4146. {
  4147. if (detach) {
  4148. if (!detached_onion_services)
  4149. detached_onion_services = smartlist_new();
  4150. smartlist_add(detached_onion_services, service_id);
  4151. } else {
  4152. if (!conn->ephemeral_onion_services)
  4153. conn->ephemeral_onion_services = smartlist_new();
  4154. smartlist_add(conn->ephemeral_onion_services, service_id);
  4155. }
  4156. tor_assert(service_id);
  4157. connection_printf_to_buf(conn, "250-ServiceID=%s\r\n", service_id);
  4158. if (key_new_alg) {
  4159. tor_assert(key_new_blob);
  4160. connection_printf_to_buf(conn, "250-PrivateKey=%s:%s\r\n",
  4161. key_new_alg, key_new_blob);
  4162. }
  4163. if (auth_created_clients) {
  4164. SMARTLIST_FOREACH(auth_created_clients, rend_authorized_client_t *, ac, {
  4165. char *encoded = rend_auth_encode_cookie(ac->descriptor_cookie,
  4166. auth_type);
  4167. tor_assert(encoded);
  4168. connection_printf_to_buf(conn, "250-ClientAuth=%s:%s\r\n",
  4169. ac->client_name, encoded);
  4170. memwipe(encoded, 0, strlen(encoded));
  4171. tor_free(encoded);
  4172. });
  4173. }
  4174. connection_printf_to_buf(conn, "250 OK\r\n");
  4175. break;
  4176. }
  4177. case RSAE_BADPRIVKEY:
  4178. connection_printf_to_buf(conn, "551 Failed to generate onion address\r\n");
  4179. break;
  4180. case RSAE_ADDREXISTS:
  4181. connection_printf_to_buf(conn, "550 Onion address collision\r\n");
  4182. break;
  4183. case RSAE_BADVIRTPORT:
  4184. connection_printf_to_buf(conn, "512 Invalid VIRTPORT/TARGET\r\n");
  4185. break;
  4186. case RSAE_BADAUTH:
  4187. connection_printf_to_buf(conn, "512 Invalid client authorization\r\n");
  4188. break;
  4189. case RSAE_INTERNAL: /* FALLSTHROUGH */
  4190. default:
  4191. connection_printf_to_buf(conn, "551 Failed to add Onion Service\r\n");
  4192. }
  4193. if (key_new_blob) {
  4194. memwipe(key_new_blob, 0, strlen(key_new_blob));
  4195. tor_free(key_new_blob);
  4196. }
  4197. out:
  4198. if (port_cfgs) {
  4199. SMARTLIST_FOREACH(port_cfgs, rend_service_port_config_t*, p,
  4200. rend_service_port_config_free(p));
  4201. smartlist_free(port_cfgs);
  4202. }
  4203. if (auth_clients) {
  4204. SMARTLIST_FOREACH(auth_clients, rend_authorized_client_t *, ac,
  4205. rend_authorized_client_free(ac));
  4206. smartlist_free(auth_clients);
  4207. }
  4208. if (auth_created_clients) {
  4209. // Do not free entries; they are the same as auth_clients
  4210. smartlist_free(auth_created_clients);
  4211. }
  4212. SMARTLIST_FOREACH(args, char *, cp, {
  4213. memwipe(cp, 0, strlen(cp));
  4214. tor_free(cp);
  4215. });
  4216. smartlist_free(args);
  4217. return 0;
  4218. }
  4219. /** Helper function to handle parsing the KeyType:KeyBlob argument to the
  4220. * ADD_ONION command. Return a new crypto_pk_t and if a new key was generated
  4221. * and the private key not discarded, the algorithm and serialized private key,
  4222. * or NULL and an optional control protocol error message on failure. The
  4223. * caller is responsible for freeing the returned key_new_blob and err_msg.
  4224. *
  4225. * Note: The error messages returned are deliberately vague to avoid echoing
  4226. * key material.
  4227. */
  4228. STATIC crypto_pk_t *
  4229. add_onion_helper_keyarg(const char *arg, int discard_pk,
  4230. const char **key_new_alg_out, char **key_new_blob_out,
  4231. char **err_msg_out)
  4232. {
  4233. smartlist_t *key_args = smartlist_new();
  4234. crypto_pk_t *pk = NULL;
  4235. const char *key_new_alg = NULL;
  4236. char *key_new_blob = NULL;
  4237. char *err_msg = NULL;
  4238. int ok = 0;
  4239. smartlist_split_string(key_args, arg, ":", SPLIT_IGNORE_BLANK, 0);
  4240. if (smartlist_len(key_args) != 2) {
  4241. err_msg = tor_strdup("512 Invalid key type/blob\r\n");
  4242. goto err;
  4243. }
  4244. /* The format is "KeyType:KeyBlob". */
  4245. static const char *key_type_new = "NEW";
  4246. static const char *key_type_best = "BEST";
  4247. static const char *key_type_rsa1024 = "RSA1024";
  4248. const char *key_type = smartlist_get(key_args, 0);
  4249. const char *key_blob = smartlist_get(key_args, 1);
  4250. if (!strcasecmp(key_type_rsa1024, key_type)) {
  4251. /* "RSA:<Base64 Blob>" - Loading a pre-existing RSA1024 key. */
  4252. pk = crypto_pk_base64_decode(key_blob, strlen(key_blob));
  4253. if (!pk) {
  4254. err_msg = tor_strdup("512 Failed to decode RSA key\r\n");
  4255. goto err;
  4256. }
  4257. if (crypto_pk_num_bits(pk) != PK_BYTES*8) {
  4258. err_msg = tor_strdup("512 Invalid RSA key size\r\n");
  4259. goto err;
  4260. }
  4261. } else if (!strcasecmp(key_type_new, key_type)) {
  4262. /* "NEW:<Algorithm>" - Generating a new key, blob as algorithm. */
  4263. if (!strcasecmp(key_type_rsa1024, key_blob) ||
  4264. !strcasecmp(key_type_best, key_blob)) {
  4265. /* "RSA1024", RSA 1024 bit, also currently "BEST" by default. */
  4266. pk = crypto_pk_new();
  4267. if (crypto_pk_generate_key(pk)) {
  4268. tor_asprintf(&err_msg, "551 Failed to generate %s key\r\n",
  4269. key_type_rsa1024);
  4270. goto err;
  4271. }
  4272. if (!discard_pk) {
  4273. if (crypto_pk_base64_encode(pk, &key_new_blob)) {
  4274. tor_asprintf(&err_msg, "551 Failed to encode %s key\r\n",
  4275. key_type_rsa1024);
  4276. goto err;
  4277. }
  4278. key_new_alg = key_type_rsa1024;
  4279. }
  4280. } else {
  4281. err_msg = tor_strdup("513 Invalid key type\r\n");
  4282. goto err;
  4283. }
  4284. } else {
  4285. err_msg = tor_strdup("513 Invalid key type\r\n");
  4286. goto err;
  4287. }
  4288. /* Succeded in loading or generating a private key. */
  4289. tor_assert(pk);
  4290. ok = 1;
  4291. err:
  4292. SMARTLIST_FOREACH(key_args, char *, cp, {
  4293. memwipe(cp, 0, strlen(cp));
  4294. tor_free(cp);
  4295. });
  4296. smartlist_free(key_args);
  4297. if (!ok) {
  4298. crypto_pk_free(pk);
  4299. pk = NULL;
  4300. }
  4301. if (err_msg_out) {
  4302. *err_msg_out = err_msg;
  4303. } else {
  4304. tor_free(err_msg);
  4305. }
  4306. *key_new_alg_out = key_new_alg;
  4307. *key_new_blob_out = key_new_blob;
  4308. return pk;
  4309. }
  4310. /** Helper function to handle parsing a ClientAuth argument to the
  4311. * ADD_ONION command. Return a new rend_authorized_client_t, or NULL
  4312. * and an optional control protocol error message on failure. The
  4313. * caller is responsible for freeing the returned auth_client and err_msg.
  4314. *
  4315. * If 'created' is specified, it will be set to 1 when a new cookie has
  4316. * been generated.
  4317. */
  4318. STATIC rend_authorized_client_t *
  4319. add_onion_helper_clientauth(const char *arg, int *created, char **err_msg)
  4320. {
  4321. int ok = 0;
  4322. tor_assert(arg);
  4323. tor_assert(created);
  4324. tor_assert(err_msg);
  4325. *err_msg = NULL;
  4326. smartlist_t *auth_args = smartlist_new();
  4327. rend_authorized_client_t *client =
  4328. tor_malloc_zero(sizeof(rend_authorized_client_t));
  4329. smartlist_split_string(auth_args, arg, ":", 0, 0);
  4330. if (smartlist_len(auth_args) < 1 || smartlist_len(auth_args) > 2) {
  4331. *err_msg = tor_strdup("512 Invalid ClientAuth syntax\r\n");
  4332. goto err;
  4333. }
  4334. client->client_name = tor_strdup(smartlist_get(auth_args, 0));
  4335. if (smartlist_len(auth_args) == 2) {
  4336. char *decode_err_msg = NULL;
  4337. if (rend_auth_decode_cookie(smartlist_get(auth_args, 1),
  4338. client->descriptor_cookie,
  4339. NULL, &decode_err_msg) < 0) {
  4340. tor_assert(decode_err_msg);
  4341. tor_asprintf(err_msg, "512 %s\r\n", decode_err_msg);
  4342. tor_free(decode_err_msg);
  4343. goto err;
  4344. }
  4345. *created = 0;
  4346. } else {
  4347. crypto_rand((char *) client->descriptor_cookie, REND_DESC_COOKIE_LEN);
  4348. *created = 1;
  4349. }
  4350. if (!rend_valid_client_name(client->client_name)) {
  4351. *err_msg = tor_strdup("512 Invalid name in ClientAuth\r\n");
  4352. goto err;
  4353. }
  4354. ok = 1;
  4355. err:
  4356. SMARTLIST_FOREACH(auth_args, char *, item, tor_free(item));
  4357. smartlist_free(auth_args);
  4358. if (!ok) {
  4359. rend_authorized_client_free(client);
  4360. client = NULL;
  4361. }
  4362. return client;
  4363. }
  4364. /** Called when we get a DEL_ONION command; parse the body, and remove
  4365. * the existing ephemeral Onion Service. */
  4366. static int
  4367. handle_control_del_onion(control_connection_t *conn,
  4368. uint32_t len,
  4369. const char *body)
  4370. {
  4371. smartlist_t *args;
  4372. (void) len; /* body is nul-terminated; it's safe to ignore the length */
  4373. args = getargs_helper("DEL_ONION", conn, body, 1, 1);
  4374. if (!args)
  4375. return 0;
  4376. const char *service_id = smartlist_get(args, 0);
  4377. if (!rend_valid_v2_service_id(service_id)) {
  4378. connection_printf_to_buf(conn, "512 Malformed Onion Service id\r\n");
  4379. goto out;
  4380. }
  4381. /* Determine if the onion service belongs to this particular control
  4382. * connection, or if it is in the global list of detached services. If it
  4383. * is in neither, either the service ID is invalid in some way, or it
  4384. * explicitly belongs to a different control connection, and an error
  4385. * should be returned.
  4386. */
  4387. smartlist_t *services[2] = {
  4388. conn->ephemeral_onion_services,
  4389. detached_onion_services
  4390. };
  4391. smartlist_t *onion_services = NULL;
  4392. int idx = -1;
  4393. for (size_t i = 0; i < ARRAY_LENGTH(services); i++) {
  4394. idx = smartlist_string_pos(services[i], service_id);
  4395. if (idx != -1) {
  4396. onion_services = services[i];
  4397. break;
  4398. }
  4399. }
  4400. if (onion_services == NULL) {
  4401. connection_printf_to_buf(conn, "552 Unknown Onion Service id\r\n");
  4402. } else {
  4403. int ret = rend_service_del_ephemeral(service_id);
  4404. if (ret) {
  4405. /* This should *NEVER* fail, since the service is on either the
  4406. * per-control connection list, or the global one.
  4407. */
  4408. log_warn(LD_BUG, "Failed to remove Onion Service %s.",
  4409. escaped(service_id));
  4410. tor_fragile_assert();
  4411. }
  4412. /* Remove/scrub the service_id from the appropriate list. */
  4413. char *cp = smartlist_get(onion_services, idx);
  4414. smartlist_del(onion_services, idx);
  4415. memwipe(cp, 0, strlen(cp));
  4416. tor_free(cp);
  4417. send_control_done(conn);
  4418. }
  4419. out:
  4420. SMARTLIST_FOREACH(args, char *, cp, {
  4421. memwipe(cp, 0, strlen(cp));
  4422. tor_free(cp);
  4423. });
  4424. smartlist_free(args);
  4425. return 0;
  4426. }
  4427. /** Called when <b>conn</b> has no more bytes left on its outbuf. */
  4428. int
  4429. connection_control_finished_flushing(control_connection_t *conn)
  4430. {
  4431. tor_assert(conn);
  4432. return 0;
  4433. }
  4434. /** Called when <b>conn</b> has gotten its socket closed. */
  4435. int
  4436. connection_control_reached_eof(control_connection_t *conn)
  4437. {
  4438. tor_assert(conn);
  4439. log_info(LD_CONTROL,"Control connection reached EOF. Closing.");
  4440. connection_mark_for_close(TO_CONN(conn));
  4441. return 0;
  4442. }
  4443. /** Shut down this Tor instance in the same way that SIGINT would, but
  4444. * with a log message appropriate for the loss of an owning controller. */
  4445. static void
  4446. lost_owning_controller(const char *owner_type, const char *loss_manner)
  4447. {
  4448. log_notice(LD_CONTROL, "Owning controller %s has %s -- exiting now.",
  4449. owner_type, loss_manner);
  4450. activate_signal(SIGTERM);
  4451. }
  4452. /** Called when <b>conn</b> is being freed. */
  4453. void
  4454. connection_control_closed(control_connection_t *conn)
  4455. {
  4456. tor_assert(conn);
  4457. conn->event_mask = 0;
  4458. control_update_global_event_mask();
  4459. /* Close all ephemeral Onion Services if any.
  4460. * The list and it's contents are scrubbed/freed in connection_free_.
  4461. */
  4462. if (conn->ephemeral_onion_services) {
  4463. SMARTLIST_FOREACH(conn->ephemeral_onion_services, char *, cp, {
  4464. rend_service_del_ephemeral(cp);
  4465. });
  4466. }
  4467. if (conn->is_owning_control_connection) {
  4468. lost_owning_controller("connection", "closed");
  4469. }
  4470. }
  4471. /** Return true iff <b>cmd</b> is allowable (or at least forgivable) at this
  4472. * stage of the protocol. */
  4473. static int
  4474. is_valid_initial_command(control_connection_t *conn, const char *cmd)
  4475. {
  4476. if (conn->base_.state == CONTROL_CONN_STATE_OPEN)
  4477. return 1;
  4478. if (!strcasecmp(cmd, "PROTOCOLINFO"))
  4479. return (!conn->have_sent_protocolinfo &&
  4480. conn->safecookie_client_hash == NULL);
  4481. if (!strcasecmp(cmd, "AUTHCHALLENGE"))
  4482. return (conn->safecookie_client_hash == NULL);
  4483. if (!strcasecmp(cmd, "AUTHENTICATE") ||
  4484. !strcasecmp(cmd, "QUIT"))
  4485. return 1;
  4486. return 0;
  4487. }
  4488. /** Do not accept any control command of more than 1MB in length. Anything
  4489. * that needs to be anywhere near this long probably means that one of our
  4490. * interfaces is broken. */
  4491. #define MAX_COMMAND_LINE_LENGTH (1024*1024)
  4492. /** Wrapper around peek_buf_has_control0 command: presents the same
  4493. * interface as that underlying functions, but takes a connection_t intead of
  4494. * a buf_t.
  4495. */
  4496. static int
  4497. peek_connection_has_control0_command(connection_t *conn)
  4498. {
  4499. return peek_buf_has_control0_command(conn->inbuf);
  4500. }
  4501. static int
  4502. peek_connection_has_http_command(connection_t *conn)
  4503. {
  4504. return peek_buf_has_http_command(conn->inbuf);
  4505. }
  4506. static const char CONTROLPORT_IS_NOT_AN_HTTP_PROXY_MSG[] =
  4507. "HTTP/1.0 501 Tor ControlPort is not an HTTP proxy"
  4508. "\r\nContent-Type: text/html; charset=iso-8859-1\r\n\r\n"
  4509. "<html>\n"
  4510. "<head>\n"
  4511. "<title>Tor's ControlPort is not an HTTP proxy</title>\n"
  4512. "</head>\n"
  4513. "<body>\n"
  4514. "<h1>Tor's ControlPort is not an HTTP proxy</h1>\n"
  4515. "<p>\n"
  4516. "It appears you have configured your web browser to use Tor's control port"
  4517. " as an HTTP proxy.\n"
  4518. "This is not correct: Tor's default SOCKS proxy port is 9050.\n"
  4519. "Please configure your client accordingly.\n"
  4520. "</p>\n"
  4521. "<p>\n"
  4522. "See <a href=\"https://www.torproject.org/documentation.html\">"
  4523. "https://www.torproject.org/documentation.html</a> for more "
  4524. "information.\n"
  4525. "<!-- Plus this comment, to make the body response more than 512 bytes, so "
  4526. " IE will be willing to display it. Comment comment comment comment "
  4527. " comment comment comment comment comment comment comment comment.-->\n"
  4528. "</p>\n"
  4529. "</body>\n"
  4530. "</html>\n";
  4531. /** Called when data has arrived on a v1 control connection: Try to fetch
  4532. * commands from conn->inbuf, and execute them.
  4533. */
  4534. int
  4535. connection_control_process_inbuf(control_connection_t *conn)
  4536. {
  4537. size_t data_len;
  4538. uint32_t cmd_data_len;
  4539. int cmd_len;
  4540. char *args;
  4541. tor_assert(conn);
  4542. tor_assert(conn->base_.state == CONTROL_CONN_STATE_OPEN ||
  4543. conn->base_.state == CONTROL_CONN_STATE_NEEDAUTH);
  4544. if (!conn->incoming_cmd) {
  4545. conn->incoming_cmd = tor_malloc(1024);
  4546. conn->incoming_cmd_len = 1024;
  4547. conn->incoming_cmd_cur_len = 0;
  4548. }
  4549. if (conn->base_.state == CONTROL_CONN_STATE_NEEDAUTH &&
  4550. peek_connection_has_control0_command(TO_CONN(conn))) {
  4551. /* Detect v0 commands and send a "no more v0" message. */
  4552. size_t body_len;
  4553. char buf[128];
  4554. set_uint16(buf+2, htons(0x0000)); /* type == error */
  4555. set_uint16(buf+4, htons(0x0001)); /* code == internal error */
  4556. strlcpy(buf+6, "The v0 control protocol is not supported by Tor 0.1.2.17 "
  4557. "and later; upgrade your controller.",
  4558. sizeof(buf)-6);
  4559. body_len = 2+strlen(buf+6)+2; /* code, msg, nul. */
  4560. set_uint16(buf+0, htons(body_len));
  4561. connection_buf_add(buf, 4+body_len, TO_CONN(conn));
  4562. connection_mark_and_flush(TO_CONN(conn));
  4563. return 0;
  4564. }
  4565. /* If the user has the HTTP proxy port and the control port confused. */
  4566. if (conn->base_.state == CONTROL_CONN_STATE_NEEDAUTH &&
  4567. peek_connection_has_http_command(TO_CONN(conn))) {
  4568. connection_write_str_to_buf(CONTROLPORT_IS_NOT_AN_HTTP_PROXY_MSG, conn);
  4569. log_notice(LD_CONTROL, "Received HTTP request on ControlPort");
  4570. connection_mark_and_flush(TO_CONN(conn));
  4571. return 0;
  4572. }
  4573. again:
  4574. while (1) {
  4575. size_t last_idx;
  4576. int r;
  4577. /* First, fetch a line. */
  4578. do {
  4579. data_len = conn->incoming_cmd_len - conn->incoming_cmd_cur_len;
  4580. r = connection_buf_get_line(TO_CONN(conn),
  4581. conn->incoming_cmd+conn->incoming_cmd_cur_len,
  4582. &data_len);
  4583. if (r == 0)
  4584. /* Line not all here yet. Wait. */
  4585. return 0;
  4586. else if (r == -1) {
  4587. if (data_len + conn->incoming_cmd_cur_len > MAX_COMMAND_LINE_LENGTH) {
  4588. connection_write_str_to_buf("500 Line too long.\r\n", conn);
  4589. connection_stop_reading(TO_CONN(conn));
  4590. connection_mark_and_flush(TO_CONN(conn));
  4591. }
  4592. while (conn->incoming_cmd_len < data_len+conn->incoming_cmd_cur_len)
  4593. conn->incoming_cmd_len *= 2;
  4594. conn->incoming_cmd = tor_realloc(conn->incoming_cmd,
  4595. conn->incoming_cmd_len);
  4596. }
  4597. } while (r != 1);
  4598. tor_assert(data_len);
  4599. last_idx = conn->incoming_cmd_cur_len;
  4600. conn->incoming_cmd_cur_len += (int)data_len;
  4601. /* We have appended a line to incoming_cmd. Is the command done? */
  4602. if (last_idx == 0 && *conn->incoming_cmd != '+')
  4603. /* One line command, didn't start with '+'. */
  4604. break;
  4605. /* XXXX this code duplication is kind of dumb. */
  4606. if (last_idx+3 == conn->incoming_cmd_cur_len &&
  4607. tor_memeq(conn->incoming_cmd + last_idx, ".\r\n", 3)) {
  4608. /* Just appended ".\r\n"; we're done. Remove it. */
  4609. conn->incoming_cmd[last_idx] = '\0';
  4610. conn->incoming_cmd_cur_len -= 3;
  4611. break;
  4612. } else if (last_idx+2 == conn->incoming_cmd_cur_len &&
  4613. tor_memeq(conn->incoming_cmd + last_idx, ".\n", 2)) {
  4614. /* Just appended ".\n"; we're done. Remove it. */
  4615. conn->incoming_cmd[last_idx] = '\0';
  4616. conn->incoming_cmd_cur_len -= 2;
  4617. break;
  4618. }
  4619. /* Otherwise, read another line. */
  4620. }
  4621. data_len = conn->incoming_cmd_cur_len;
  4622. /* Okay, we now have a command sitting on conn->incoming_cmd. See if we
  4623. * recognize it.
  4624. */
  4625. cmd_len = 0;
  4626. while ((size_t)cmd_len < data_len
  4627. && !TOR_ISSPACE(conn->incoming_cmd[cmd_len]))
  4628. ++cmd_len;
  4629. conn->incoming_cmd[cmd_len]='\0';
  4630. args = conn->incoming_cmd+cmd_len+1;
  4631. tor_assert(data_len>(size_t)cmd_len);
  4632. data_len -= (cmd_len+1); /* skip the command and NUL we added after it */
  4633. while (TOR_ISSPACE(*args)) {
  4634. ++args;
  4635. --data_len;
  4636. }
  4637. /* If the connection is already closing, ignore further commands */
  4638. if (TO_CONN(conn)->marked_for_close) {
  4639. return 0;
  4640. }
  4641. /* Otherwise, Quit is always valid. */
  4642. if (!strcasecmp(conn->incoming_cmd, "QUIT")) {
  4643. connection_write_str_to_buf("250 closing connection\r\n", conn);
  4644. connection_mark_and_flush(TO_CONN(conn));
  4645. return 0;
  4646. }
  4647. if (conn->base_.state == CONTROL_CONN_STATE_NEEDAUTH &&
  4648. !is_valid_initial_command(conn, conn->incoming_cmd)) {
  4649. connection_write_str_to_buf("514 Authentication required.\r\n", conn);
  4650. connection_mark_for_close(TO_CONN(conn));
  4651. return 0;
  4652. }
  4653. if (data_len >= UINT32_MAX) {
  4654. connection_write_str_to_buf("500 A 4GB command? Nice try.\r\n", conn);
  4655. connection_mark_for_close(TO_CONN(conn));
  4656. return 0;
  4657. }
  4658. /* XXXX Why is this not implemented as a table like the GETINFO
  4659. * items are? Even handling the plus signs at the beginnings of
  4660. * commands wouldn't be very hard with proper macros. */
  4661. cmd_data_len = (uint32_t)data_len;
  4662. if (!strcasecmp(conn->incoming_cmd, "SETCONF")) {
  4663. if (handle_control_setconf(conn, cmd_data_len, args))
  4664. return -1;
  4665. } else if (!strcasecmp(conn->incoming_cmd, "RESETCONF")) {
  4666. if (handle_control_resetconf(conn, cmd_data_len, args))
  4667. return -1;
  4668. } else if (!strcasecmp(conn->incoming_cmd, "GETCONF")) {
  4669. if (handle_control_getconf(conn, cmd_data_len, args))
  4670. return -1;
  4671. } else if (!strcasecmp(conn->incoming_cmd, "+LOADCONF")) {
  4672. if (handle_control_loadconf(conn, cmd_data_len, args))
  4673. return -1;
  4674. } else if (!strcasecmp(conn->incoming_cmd, "SETEVENTS")) {
  4675. if (handle_control_setevents(conn, cmd_data_len, args))
  4676. return -1;
  4677. } else if (!strcasecmp(conn->incoming_cmd, "AUTHENTICATE")) {
  4678. if (handle_control_authenticate(conn, cmd_data_len, args))
  4679. return -1;
  4680. } else if (!strcasecmp(conn->incoming_cmd, "SAVECONF")) {
  4681. if (handle_control_saveconf(conn, cmd_data_len, args))
  4682. return -1;
  4683. } else if (!strcasecmp(conn->incoming_cmd, "SIGNAL")) {
  4684. if (handle_control_signal(conn, cmd_data_len, args))
  4685. return -1;
  4686. } else if (!strcasecmp(conn->incoming_cmd, "TAKEOWNERSHIP")) {
  4687. if (handle_control_takeownership(conn, cmd_data_len, args))
  4688. return -1;
  4689. } else if (!strcasecmp(conn->incoming_cmd, "MAPADDRESS")) {
  4690. if (handle_control_mapaddress(conn, cmd_data_len, args))
  4691. return -1;
  4692. } else if (!strcasecmp(conn->incoming_cmd, "GETINFO")) {
  4693. if (handle_control_getinfo(conn, cmd_data_len, args))
  4694. return -1;
  4695. } else if (!strcasecmp(conn->incoming_cmd, "EXTENDCIRCUIT")) {
  4696. if (handle_control_extendcircuit(conn, cmd_data_len, args))
  4697. return -1;
  4698. } else if (!strcasecmp(conn->incoming_cmd, "SETCIRCUITPURPOSE")) {
  4699. if (handle_control_setcircuitpurpose(conn, cmd_data_len, args))
  4700. return -1;
  4701. } else if (!strcasecmp(conn->incoming_cmd, "SETROUTERPURPOSE")) {
  4702. connection_write_str_to_buf("511 SETROUTERPURPOSE is obsolete.\r\n", conn);
  4703. } else if (!strcasecmp(conn->incoming_cmd, "ATTACHSTREAM")) {
  4704. if (handle_control_attachstream(conn, cmd_data_len, args))
  4705. return -1;
  4706. } else if (!strcasecmp(conn->incoming_cmd, "+POSTDESCRIPTOR")) {
  4707. if (handle_control_postdescriptor(conn, cmd_data_len, args))
  4708. return -1;
  4709. } else if (!strcasecmp(conn->incoming_cmd, "REDIRECTSTREAM")) {
  4710. if (handle_control_redirectstream(conn, cmd_data_len, args))
  4711. return -1;
  4712. } else if (!strcasecmp(conn->incoming_cmd, "CLOSESTREAM")) {
  4713. if (handle_control_closestream(conn, cmd_data_len, args))
  4714. return -1;
  4715. } else if (!strcasecmp(conn->incoming_cmd, "CLOSECIRCUIT")) {
  4716. if (handle_control_closecircuit(conn, cmd_data_len, args))
  4717. return -1;
  4718. } else if (!strcasecmp(conn->incoming_cmd, "USEFEATURE")) {
  4719. if (handle_control_usefeature(conn, cmd_data_len, args))
  4720. return -1;
  4721. } else if (!strcasecmp(conn->incoming_cmd, "RESOLVE")) {
  4722. if (handle_control_resolve(conn, cmd_data_len, args))
  4723. return -1;
  4724. } else if (!strcasecmp(conn->incoming_cmd, "PROTOCOLINFO")) {
  4725. if (handle_control_protocolinfo(conn, cmd_data_len, args))
  4726. return -1;
  4727. } else if (!strcasecmp(conn->incoming_cmd, "AUTHCHALLENGE")) {
  4728. if (handle_control_authchallenge(conn, cmd_data_len, args))
  4729. return -1;
  4730. } else if (!strcasecmp(conn->incoming_cmd, "DROPGUARDS")) {
  4731. if (handle_control_dropguards(conn, cmd_data_len, args))
  4732. return -1;
  4733. } else if (!strcasecmp(conn->incoming_cmd, "HSFETCH")) {
  4734. if (handle_control_hsfetch(conn, cmd_data_len, args))
  4735. return -1;
  4736. } else if (!strcasecmp(conn->incoming_cmd, "+HSPOST")) {
  4737. if (handle_control_hspost(conn, cmd_data_len, args))
  4738. return -1;
  4739. } else if (!strcasecmp(conn->incoming_cmd, "ADD_ONION")) {
  4740. int ret = handle_control_add_onion(conn, cmd_data_len, args);
  4741. memwipe(args, 0, cmd_data_len); /* Scrub the private key. */
  4742. if (ret)
  4743. return -1;
  4744. } else if (!strcasecmp(conn->incoming_cmd, "DEL_ONION")) {
  4745. int ret = handle_control_del_onion(conn, cmd_data_len, args);
  4746. memwipe(args, 0, cmd_data_len); /* Scrub the service id/pk. */
  4747. if (ret)
  4748. return -1;
  4749. } else {
  4750. connection_printf_to_buf(conn, "510 Unrecognized command \"%s\"\r\n",
  4751. conn->incoming_cmd);
  4752. }
  4753. conn->incoming_cmd_cur_len = 0;
  4754. goto again;
  4755. }
  4756. /** Something major has happened to circuit <b>circ</b>: tell any
  4757. * interested control connections. */
  4758. int
  4759. control_event_circuit_status(origin_circuit_t *circ, circuit_status_event_t tp,
  4760. int reason_code)
  4761. {
  4762. const char *status;
  4763. char reasons[64] = "";
  4764. if (!EVENT_IS_INTERESTING(EVENT_CIRCUIT_STATUS))
  4765. return 0;
  4766. tor_assert(circ);
  4767. switch (tp)
  4768. {
  4769. case CIRC_EVENT_LAUNCHED: status = "LAUNCHED"; break;
  4770. case CIRC_EVENT_BUILT: status = "BUILT"; break;
  4771. case CIRC_EVENT_EXTENDED: status = "EXTENDED"; break;
  4772. case CIRC_EVENT_FAILED: status = "FAILED"; break;
  4773. case CIRC_EVENT_CLOSED: status = "CLOSED"; break;
  4774. default:
  4775. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  4776. tor_fragile_assert();
  4777. return 0;
  4778. }
  4779. if (tp == CIRC_EVENT_FAILED || tp == CIRC_EVENT_CLOSED) {
  4780. const char *reason_str = circuit_end_reason_to_control_string(reason_code);
  4781. char unk_reason_buf[16];
  4782. if (!reason_str) {
  4783. tor_snprintf(unk_reason_buf, 16, "UNKNOWN_%d", reason_code);
  4784. reason_str = unk_reason_buf;
  4785. }
  4786. if (reason_code > 0 && reason_code & END_CIRC_REASON_FLAG_REMOTE) {
  4787. tor_snprintf(reasons, sizeof(reasons),
  4788. " REASON=DESTROYED REMOTE_REASON=%s", reason_str);
  4789. } else {
  4790. tor_snprintf(reasons, sizeof(reasons),
  4791. " REASON=%s", reason_str);
  4792. }
  4793. }
  4794. {
  4795. char *circdesc = circuit_describe_status_for_controller(circ);
  4796. const char *sp = strlen(circdesc) ? " " : "";
  4797. send_control_event(EVENT_CIRCUIT_STATUS,
  4798. "650 CIRC %lu %s%s%s%s\r\n",
  4799. (unsigned long)circ->global_identifier,
  4800. status, sp,
  4801. circdesc,
  4802. reasons);
  4803. tor_free(circdesc);
  4804. }
  4805. return 0;
  4806. }
  4807. /** Something minor has happened to circuit <b>circ</b>: tell any
  4808. * interested control connections. */
  4809. static int
  4810. control_event_circuit_status_minor(origin_circuit_t *circ,
  4811. circuit_status_minor_event_t e,
  4812. int purpose, const struct timeval *tv)
  4813. {
  4814. const char *event_desc;
  4815. char event_tail[160] = "";
  4816. if (!EVENT_IS_INTERESTING(EVENT_CIRCUIT_STATUS_MINOR))
  4817. return 0;
  4818. tor_assert(circ);
  4819. switch (e)
  4820. {
  4821. case CIRC_MINOR_EVENT_PURPOSE_CHANGED:
  4822. event_desc = "PURPOSE_CHANGED";
  4823. {
  4824. /* event_tail can currently be up to 68 chars long */
  4825. const char *hs_state_str =
  4826. circuit_purpose_to_controller_hs_state_string(purpose);
  4827. tor_snprintf(event_tail, sizeof(event_tail),
  4828. " OLD_PURPOSE=%s%s%s",
  4829. circuit_purpose_to_controller_string(purpose),
  4830. (hs_state_str != NULL) ? " OLD_HS_STATE=" : "",
  4831. (hs_state_str != NULL) ? hs_state_str : "");
  4832. }
  4833. break;
  4834. case CIRC_MINOR_EVENT_CANNIBALIZED:
  4835. event_desc = "CANNIBALIZED";
  4836. {
  4837. /* event_tail can currently be up to 130 chars long */
  4838. const char *hs_state_str =
  4839. circuit_purpose_to_controller_hs_state_string(purpose);
  4840. const struct timeval *old_timestamp_began = tv;
  4841. char tbuf[ISO_TIME_USEC_LEN+1];
  4842. format_iso_time_nospace_usec(tbuf, old_timestamp_began);
  4843. tor_snprintf(event_tail, sizeof(event_tail),
  4844. " OLD_PURPOSE=%s%s%s OLD_TIME_CREATED=%s",
  4845. circuit_purpose_to_controller_string(purpose),
  4846. (hs_state_str != NULL) ? " OLD_HS_STATE=" : "",
  4847. (hs_state_str != NULL) ? hs_state_str : "",
  4848. tbuf);
  4849. }
  4850. break;
  4851. default:
  4852. log_warn(LD_BUG, "Unrecognized status code %d", (int)e);
  4853. tor_fragile_assert();
  4854. return 0;
  4855. }
  4856. {
  4857. char *circdesc = circuit_describe_status_for_controller(circ);
  4858. const char *sp = strlen(circdesc) ? " " : "";
  4859. send_control_event(EVENT_CIRCUIT_STATUS_MINOR,
  4860. "650 CIRC_MINOR %lu %s%s%s%s\r\n",
  4861. (unsigned long)circ->global_identifier,
  4862. event_desc, sp,
  4863. circdesc,
  4864. event_tail);
  4865. tor_free(circdesc);
  4866. }
  4867. return 0;
  4868. }
  4869. /**
  4870. * <b>circ</b> has changed its purpose from <b>old_purpose</b>: tell any
  4871. * interested controllers.
  4872. */
  4873. int
  4874. control_event_circuit_purpose_changed(origin_circuit_t *circ,
  4875. int old_purpose)
  4876. {
  4877. return control_event_circuit_status_minor(circ,
  4878. CIRC_MINOR_EVENT_PURPOSE_CHANGED,
  4879. old_purpose,
  4880. NULL);
  4881. }
  4882. /**
  4883. * <b>circ</b> has changed its purpose from <b>old_purpose</b>, and its
  4884. * created-time from <b>old_tv_created</b>: tell any interested controllers.
  4885. */
  4886. int
  4887. control_event_circuit_cannibalized(origin_circuit_t *circ,
  4888. int old_purpose,
  4889. const struct timeval *old_tv_created)
  4890. {
  4891. return control_event_circuit_status_minor(circ,
  4892. CIRC_MINOR_EVENT_CANNIBALIZED,
  4893. old_purpose,
  4894. old_tv_created);
  4895. }
  4896. /** Given an AP connection <b>conn</b> and a <b>len</b>-character buffer
  4897. * <b>buf</b>, determine the address:port combination requested on
  4898. * <b>conn</b>, and write it to <b>buf</b>. Return 0 on success, -1 on
  4899. * failure. */
  4900. static int
  4901. write_stream_target_to_buf(entry_connection_t *conn, char *buf, size_t len)
  4902. {
  4903. char buf2[256];
  4904. if (conn->chosen_exit_name)
  4905. if (tor_snprintf(buf2, sizeof(buf2), ".%s.exit", conn->chosen_exit_name)<0)
  4906. return -1;
  4907. if (!conn->socks_request)
  4908. return -1;
  4909. if (tor_snprintf(buf, len, "%s%s%s:%d",
  4910. conn->socks_request->address,
  4911. conn->chosen_exit_name ? buf2 : "",
  4912. !conn->chosen_exit_name && connection_edge_is_rendezvous_stream(
  4913. ENTRY_TO_EDGE_CONN(conn)) ? ".onion" : "",
  4914. conn->socks_request->port)<0)
  4915. return -1;
  4916. return 0;
  4917. }
  4918. /** Something has happened to the stream associated with AP connection
  4919. * <b>conn</b>: tell any interested control connections. */
  4920. int
  4921. control_event_stream_status(entry_connection_t *conn, stream_status_event_t tp,
  4922. int reason_code)
  4923. {
  4924. char reason_buf[64];
  4925. char addrport_buf[64];
  4926. const char *status;
  4927. circuit_t *circ;
  4928. origin_circuit_t *origin_circ = NULL;
  4929. char buf[256];
  4930. const char *purpose = "";
  4931. tor_assert(conn->socks_request);
  4932. if (!EVENT_IS_INTERESTING(EVENT_STREAM_STATUS))
  4933. return 0;
  4934. if (tp == STREAM_EVENT_CLOSED &&
  4935. (reason_code & END_STREAM_REASON_FLAG_ALREADY_SENT_CLOSED))
  4936. return 0;
  4937. write_stream_target_to_buf(conn, buf, sizeof(buf));
  4938. reason_buf[0] = '\0';
  4939. switch (tp)
  4940. {
  4941. case STREAM_EVENT_SENT_CONNECT: status = "SENTCONNECT"; break;
  4942. case STREAM_EVENT_SENT_RESOLVE: status = "SENTRESOLVE"; break;
  4943. case STREAM_EVENT_SUCCEEDED: status = "SUCCEEDED"; break;
  4944. case STREAM_EVENT_FAILED: status = "FAILED"; break;
  4945. case STREAM_EVENT_CLOSED: status = "CLOSED"; break;
  4946. case STREAM_EVENT_NEW: status = "NEW"; break;
  4947. case STREAM_EVENT_NEW_RESOLVE: status = "NEWRESOLVE"; break;
  4948. case STREAM_EVENT_FAILED_RETRIABLE: status = "DETACHED"; break;
  4949. case STREAM_EVENT_REMAP: status = "REMAP"; break;
  4950. default:
  4951. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  4952. return 0;
  4953. }
  4954. if (reason_code && (tp == STREAM_EVENT_FAILED ||
  4955. tp == STREAM_EVENT_CLOSED ||
  4956. tp == STREAM_EVENT_FAILED_RETRIABLE)) {
  4957. const char *reason_str = stream_end_reason_to_control_string(reason_code);
  4958. char *r = NULL;
  4959. if (!reason_str) {
  4960. tor_asprintf(&r, " UNKNOWN_%d", reason_code);
  4961. reason_str = r;
  4962. }
  4963. if (reason_code & END_STREAM_REASON_FLAG_REMOTE)
  4964. tor_snprintf(reason_buf, sizeof(reason_buf),
  4965. " REASON=END REMOTE_REASON=%s", reason_str);
  4966. else
  4967. tor_snprintf(reason_buf, sizeof(reason_buf),
  4968. " REASON=%s", reason_str);
  4969. tor_free(r);
  4970. } else if (reason_code && tp == STREAM_EVENT_REMAP) {
  4971. switch (reason_code) {
  4972. case REMAP_STREAM_SOURCE_CACHE:
  4973. strlcpy(reason_buf, " SOURCE=CACHE", sizeof(reason_buf));
  4974. break;
  4975. case REMAP_STREAM_SOURCE_EXIT:
  4976. strlcpy(reason_buf, " SOURCE=EXIT", sizeof(reason_buf));
  4977. break;
  4978. default:
  4979. tor_snprintf(reason_buf, sizeof(reason_buf), " REASON=UNKNOWN_%d",
  4980. reason_code);
  4981. /* XXX do we want SOURCE=UNKNOWN_%d above instead? -RD */
  4982. break;
  4983. }
  4984. }
  4985. if (tp == STREAM_EVENT_NEW || tp == STREAM_EVENT_NEW_RESOLVE) {
  4986. /*
  4987. * When the control conn is an AF_UNIX socket and we have no address,
  4988. * it gets set to "(Tor_internal)"; see dnsserv_launch_request() in
  4989. * dnsserv.c.
  4990. */
  4991. if (strcmp(ENTRY_TO_CONN(conn)->address, "(Tor_internal)") != 0) {
  4992. tor_snprintf(addrport_buf,sizeof(addrport_buf), " SOURCE_ADDR=%s:%d",
  4993. ENTRY_TO_CONN(conn)->address, ENTRY_TO_CONN(conn)->port);
  4994. } else {
  4995. /*
  4996. * else leave it blank so control on AF_UNIX doesn't need to make
  4997. * something up.
  4998. */
  4999. addrport_buf[0] = '\0';
  5000. }
  5001. } else {
  5002. addrport_buf[0] = '\0';
  5003. }
  5004. if (tp == STREAM_EVENT_NEW_RESOLVE) {
  5005. purpose = " PURPOSE=DNS_REQUEST";
  5006. } else if (tp == STREAM_EVENT_NEW) {
  5007. if (conn->use_begindir) {
  5008. connection_t *linked = ENTRY_TO_CONN(conn)->linked_conn;
  5009. int linked_dir_purpose = -1;
  5010. if (linked && linked->type == CONN_TYPE_DIR)
  5011. linked_dir_purpose = linked->purpose;
  5012. if (DIR_PURPOSE_IS_UPLOAD(linked_dir_purpose))
  5013. purpose = " PURPOSE=DIR_UPLOAD";
  5014. else
  5015. purpose = " PURPOSE=DIR_FETCH";
  5016. } else
  5017. purpose = " PURPOSE=USER";
  5018. }
  5019. circ = circuit_get_by_edge_conn(ENTRY_TO_EDGE_CONN(conn));
  5020. if (circ && CIRCUIT_IS_ORIGIN(circ))
  5021. origin_circ = TO_ORIGIN_CIRCUIT(circ);
  5022. send_control_event(EVENT_STREAM_STATUS,
  5023. "650 STREAM "U64_FORMAT" %s %lu %s%s%s%s\r\n",
  5024. U64_PRINTF_ARG(ENTRY_TO_CONN(conn)->global_identifier),
  5025. status,
  5026. origin_circ?
  5027. (unsigned long)origin_circ->global_identifier : 0ul,
  5028. buf, reason_buf, addrport_buf, purpose);
  5029. /* XXX need to specify its intended exit, etc? */
  5030. return 0;
  5031. }
  5032. /** Figure out the best name for the target router of an OR connection
  5033. * <b>conn</b>, and write it into the <b>len</b>-character buffer
  5034. * <b>name</b>. */
  5035. static void
  5036. orconn_target_get_name(char *name, size_t len, or_connection_t *conn)
  5037. {
  5038. const node_t *node = node_get_by_id(conn->identity_digest);
  5039. if (node) {
  5040. tor_assert(len > MAX_VERBOSE_NICKNAME_LEN);
  5041. node_get_verbose_nickname(node, name);
  5042. } else if (! tor_digest_is_zero(conn->identity_digest)) {
  5043. name[0] = '$';
  5044. base16_encode(name+1, len-1, conn->identity_digest,
  5045. DIGEST_LEN);
  5046. } else {
  5047. tor_snprintf(name, len, "%s:%d",
  5048. conn->base_.address, conn->base_.port);
  5049. }
  5050. }
  5051. /** Called when the status of an OR connection <b>conn</b> changes: tell any
  5052. * interested control connections. <b>tp</b> is the new status for the
  5053. * connection. If <b>conn</b> has just closed or failed, then <b>reason</b>
  5054. * may be the reason why.
  5055. */
  5056. int
  5057. control_event_or_conn_status(or_connection_t *conn, or_conn_status_event_t tp,
  5058. int reason)
  5059. {
  5060. int ncircs = 0;
  5061. const char *status;
  5062. char name[128];
  5063. char ncircs_buf[32] = {0}; /* > 8 + log10(2^32)=10 + 2 */
  5064. if (!EVENT_IS_INTERESTING(EVENT_OR_CONN_STATUS))
  5065. return 0;
  5066. switch (tp)
  5067. {
  5068. case OR_CONN_EVENT_LAUNCHED: status = "LAUNCHED"; break;
  5069. case OR_CONN_EVENT_CONNECTED: status = "CONNECTED"; break;
  5070. case OR_CONN_EVENT_FAILED: status = "FAILED"; break;
  5071. case OR_CONN_EVENT_CLOSED: status = "CLOSED"; break;
  5072. case OR_CONN_EVENT_NEW: status = "NEW"; break;
  5073. default:
  5074. log_warn(LD_BUG, "Unrecognized status code %d", (int)tp);
  5075. return 0;
  5076. }
  5077. if (conn->chan) {
  5078. ncircs = circuit_count_pending_on_channel(TLS_CHAN_TO_BASE(conn->chan));
  5079. } else {
  5080. ncircs = 0;
  5081. }
  5082. ncircs += connection_or_get_num_circuits(conn);
  5083. if (ncircs && (tp == OR_CONN_EVENT_FAILED || tp == OR_CONN_EVENT_CLOSED)) {
  5084. tor_snprintf(ncircs_buf, sizeof(ncircs_buf), " NCIRCS=%d", ncircs);
  5085. }
  5086. orconn_target_get_name(name, sizeof(name), conn);
  5087. send_control_event(EVENT_OR_CONN_STATUS,
  5088. "650 ORCONN %s %s%s%s%s ID="U64_FORMAT"\r\n",
  5089. name, status,
  5090. reason ? " REASON=" : "",
  5091. orconn_end_reason_to_control_string(reason),
  5092. ncircs_buf,
  5093. U64_PRINTF_ARG(conn->base_.global_identifier));
  5094. return 0;
  5095. }
  5096. /**
  5097. * Print out STREAM_BW event for a single conn
  5098. */
  5099. int
  5100. control_event_stream_bandwidth(edge_connection_t *edge_conn)
  5101. {
  5102. circuit_t *circ;
  5103. origin_circuit_t *ocirc;
  5104. struct timeval now;
  5105. char tbuf[ISO_TIME_USEC_LEN+1];
  5106. if (EVENT_IS_INTERESTING(EVENT_STREAM_BANDWIDTH_USED)) {
  5107. if (!edge_conn->n_read && !edge_conn->n_written)
  5108. return 0;
  5109. tor_gettimeofday(&now);
  5110. format_iso_time_nospace_usec(tbuf, &now);
  5111. send_control_event(EVENT_STREAM_BANDWIDTH_USED,
  5112. "650 STREAM_BW "U64_FORMAT" %lu %lu %s\r\n",
  5113. U64_PRINTF_ARG(edge_conn->base_.global_identifier),
  5114. (unsigned long)edge_conn->n_read,
  5115. (unsigned long)edge_conn->n_written,
  5116. tbuf);
  5117. circ = circuit_get_by_edge_conn(edge_conn);
  5118. if (circ && CIRCUIT_IS_ORIGIN(circ)) {
  5119. ocirc = TO_ORIGIN_CIRCUIT(circ);
  5120. ocirc->n_read_circ_bw += edge_conn->n_read;
  5121. ocirc->n_written_circ_bw += edge_conn->n_written;
  5122. }
  5123. edge_conn->n_written = edge_conn->n_read = 0;
  5124. }
  5125. return 0;
  5126. }
  5127. /** A second or more has elapsed: tell any interested control
  5128. * connections how much bandwidth streams have used. */
  5129. int
  5130. control_event_stream_bandwidth_used(void)
  5131. {
  5132. if (EVENT_IS_INTERESTING(EVENT_STREAM_BANDWIDTH_USED)) {
  5133. smartlist_t *conns = get_connection_array();
  5134. edge_connection_t *edge_conn;
  5135. struct timeval now;
  5136. char tbuf[ISO_TIME_USEC_LEN+1];
  5137. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, conn)
  5138. {
  5139. if (conn->type != CONN_TYPE_AP)
  5140. continue;
  5141. edge_conn = TO_EDGE_CONN(conn);
  5142. if (!edge_conn->n_read && !edge_conn->n_written)
  5143. continue;
  5144. tor_gettimeofday(&now);
  5145. format_iso_time_nospace_usec(tbuf, &now);
  5146. send_control_event(EVENT_STREAM_BANDWIDTH_USED,
  5147. "650 STREAM_BW "U64_FORMAT" %lu %lu %s\r\n",
  5148. U64_PRINTF_ARG(edge_conn->base_.global_identifier),
  5149. (unsigned long)edge_conn->n_read,
  5150. (unsigned long)edge_conn->n_written,
  5151. tbuf);
  5152. edge_conn->n_written = edge_conn->n_read = 0;
  5153. }
  5154. SMARTLIST_FOREACH_END(conn);
  5155. }
  5156. return 0;
  5157. }
  5158. /** A second or more has elapsed: tell any interested control connections
  5159. * how much bandwidth origin circuits have used. */
  5160. int
  5161. control_event_circ_bandwidth_used(void)
  5162. {
  5163. origin_circuit_t *ocirc;
  5164. struct timeval now;
  5165. char tbuf[ISO_TIME_USEC_LEN+1];
  5166. if (!EVENT_IS_INTERESTING(EVENT_CIRC_BANDWIDTH_USED))
  5167. return 0;
  5168. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  5169. if (!CIRCUIT_IS_ORIGIN(circ))
  5170. continue;
  5171. ocirc = TO_ORIGIN_CIRCUIT(circ);
  5172. if (!ocirc->n_read_circ_bw && !ocirc->n_written_circ_bw)
  5173. continue;
  5174. tor_gettimeofday(&now);
  5175. format_iso_time_nospace_usec(tbuf, &now);
  5176. send_control_event(EVENT_CIRC_BANDWIDTH_USED,
  5177. "650 CIRC_BW ID=%d READ=%lu WRITTEN=%lu "
  5178. "TIME=%s\r\n",
  5179. ocirc->global_identifier,
  5180. (unsigned long)ocirc->n_read_circ_bw,
  5181. (unsigned long)ocirc->n_written_circ_bw,
  5182. tbuf);
  5183. ocirc->n_written_circ_bw = ocirc->n_read_circ_bw = 0;
  5184. }
  5185. SMARTLIST_FOREACH_END(circ);
  5186. return 0;
  5187. }
  5188. /** Print out CONN_BW event for a single OR/DIR/EXIT <b>conn</b> and reset
  5189. * bandwidth counters. */
  5190. int
  5191. control_event_conn_bandwidth(connection_t *conn)
  5192. {
  5193. const char *conn_type_str;
  5194. if (!get_options()->TestingEnableConnBwEvent ||
  5195. !EVENT_IS_INTERESTING(EVENT_CONN_BW))
  5196. return 0;
  5197. if (!conn->n_read_conn_bw && !conn->n_written_conn_bw)
  5198. return 0;
  5199. switch (conn->type) {
  5200. case CONN_TYPE_OR:
  5201. conn_type_str = "OR";
  5202. break;
  5203. case CONN_TYPE_DIR:
  5204. conn_type_str = "DIR";
  5205. break;
  5206. case CONN_TYPE_EXIT:
  5207. conn_type_str = "EXIT";
  5208. break;
  5209. default:
  5210. return 0;
  5211. }
  5212. send_control_event(EVENT_CONN_BW,
  5213. "650 CONN_BW ID="U64_FORMAT" TYPE=%s "
  5214. "READ=%lu WRITTEN=%lu\r\n",
  5215. U64_PRINTF_ARG(conn->global_identifier),
  5216. conn_type_str,
  5217. (unsigned long)conn->n_read_conn_bw,
  5218. (unsigned long)conn->n_written_conn_bw);
  5219. conn->n_written_conn_bw = conn->n_read_conn_bw = 0;
  5220. return 0;
  5221. }
  5222. /** A second or more has elapsed: tell any interested control
  5223. * connections how much bandwidth connections have used. */
  5224. int
  5225. control_event_conn_bandwidth_used(void)
  5226. {
  5227. if (get_options()->TestingEnableConnBwEvent &&
  5228. EVENT_IS_INTERESTING(EVENT_CONN_BW)) {
  5229. SMARTLIST_FOREACH(get_connection_array(), connection_t *, conn,
  5230. control_event_conn_bandwidth(conn));
  5231. }
  5232. return 0;
  5233. }
  5234. /** Helper: iterate over cell statistics of <b>circ</b> and sum up added
  5235. * cells, removed cells, and waiting times by cell command and direction.
  5236. * Store results in <b>cell_stats</b>. Free cell statistics of the
  5237. * circuit afterwards. */
  5238. void
  5239. sum_up_cell_stats_by_command(circuit_t *circ, cell_stats_t *cell_stats)
  5240. {
  5241. memset(cell_stats, 0, sizeof(cell_stats_t));
  5242. SMARTLIST_FOREACH_BEGIN(circ->testing_cell_stats,
  5243. const testing_cell_stats_entry_t *, ent) {
  5244. tor_assert(ent->command <= CELL_COMMAND_MAX_);
  5245. if (!ent->removed && !ent->exitward) {
  5246. cell_stats->added_cells_appward[ent->command] += 1;
  5247. } else if (!ent->removed && ent->exitward) {
  5248. cell_stats->added_cells_exitward[ent->command] += 1;
  5249. } else if (!ent->exitward) {
  5250. cell_stats->removed_cells_appward[ent->command] += 1;
  5251. cell_stats->total_time_appward[ent->command] += ent->waiting_time * 10;
  5252. } else {
  5253. cell_stats->removed_cells_exitward[ent->command] += 1;
  5254. cell_stats->total_time_exitward[ent->command] += ent->waiting_time * 10;
  5255. }
  5256. } SMARTLIST_FOREACH_END(ent);
  5257. circuit_clear_testing_cell_stats(circ);
  5258. }
  5259. /** Helper: append a cell statistics string to <code>event_parts</code>,
  5260. * prefixed with <code>key</code>=. Statistics consist of comma-separated
  5261. * key:value pairs with lower-case command strings as keys and cell
  5262. * numbers or total waiting times as values. A key:value pair is included
  5263. * if the entry in <code>include_if_non_zero</code> is not zero, but with
  5264. * the (possibly zero) entry from <code>number_to_include</code>. Both
  5265. * arrays are expected to have a length of CELL_COMMAND_MAX_ + 1. If no
  5266. * entry in <code>include_if_non_zero</code> is positive, no string will
  5267. * be added to <code>event_parts</code>. */
  5268. void
  5269. append_cell_stats_by_command(smartlist_t *event_parts, const char *key,
  5270. const uint64_t *include_if_non_zero,
  5271. const uint64_t *number_to_include)
  5272. {
  5273. smartlist_t *key_value_strings = smartlist_new();
  5274. int i;
  5275. for (i = 0; i <= CELL_COMMAND_MAX_; i++) {
  5276. if (include_if_non_zero[i] > 0) {
  5277. smartlist_add_asprintf(key_value_strings, "%s:"U64_FORMAT,
  5278. cell_command_to_string(i),
  5279. U64_PRINTF_ARG(number_to_include[i]));
  5280. }
  5281. }
  5282. if (smartlist_len(key_value_strings) > 0) {
  5283. char *joined = smartlist_join_strings(key_value_strings, ",", 0, NULL);
  5284. smartlist_add_asprintf(event_parts, "%s=%s", key, joined);
  5285. SMARTLIST_FOREACH(key_value_strings, char *, cp, tor_free(cp));
  5286. tor_free(joined);
  5287. }
  5288. smartlist_free(key_value_strings);
  5289. }
  5290. /** Helper: format <b>cell_stats</b> for <b>circ</b> for inclusion in a
  5291. * CELL_STATS event and write result string to <b>event_string</b>. */
  5292. void
  5293. format_cell_stats(char **event_string, circuit_t *circ,
  5294. cell_stats_t *cell_stats)
  5295. {
  5296. smartlist_t *event_parts = smartlist_new();
  5297. if (CIRCUIT_IS_ORIGIN(circ)) {
  5298. origin_circuit_t *ocirc = TO_ORIGIN_CIRCUIT(circ);
  5299. smartlist_add_asprintf(event_parts, "ID=%lu",
  5300. (unsigned long)ocirc->global_identifier);
  5301. } else if (TO_OR_CIRCUIT(circ)->p_chan) {
  5302. or_circuit_t *or_circ = TO_OR_CIRCUIT(circ);
  5303. smartlist_add_asprintf(event_parts, "InboundQueue=%lu",
  5304. (unsigned long)or_circ->p_circ_id);
  5305. smartlist_add_asprintf(event_parts, "InboundConn="U64_FORMAT,
  5306. U64_PRINTF_ARG(or_circ->p_chan->global_identifier));
  5307. append_cell_stats_by_command(event_parts, "InboundAdded",
  5308. cell_stats->added_cells_appward,
  5309. cell_stats->added_cells_appward);
  5310. append_cell_stats_by_command(event_parts, "InboundRemoved",
  5311. cell_stats->removed_cells_appward,
  5312. cell_stats->removed_cells_appward);
  5313. append_cell_stats_by_command(event_parts, "InboundTime",
  5314. cell_stats->removed_cells_appward,
  5315. cell_stats->total_time_appward);
  5316. }
  5317. if (circ->n_chan) {
  5318. smartlist_add_asprintf(event_parts, "OutboundQueue=%lu",
  5319. (unsigned long)circ->n_circ_id);
  5320. smartlist_add_asprintf(event_parts, "OutboundConn="U64_FORMAT,
  5321. U64_PRINTF_ARG(circ->n_chan->global_identifier));
  5322. append_cell_stats_by_command(event_parts, "OutboundAdded",
  5323. cell_stats->added_cells_exitward,
  5324. cell_stats->added_cells_exitward);
  5325. append_cell_stats_by_command(event_parts, "OutboundRemoved",
  5326. cell_stats->removed_cells_exitward,
  5327. cell_stats->removed_cells_exitward);
  5328. append_cell_stats_by_command(event_parts, "OutboundTime",
  5329. cell_stats->removed_cells_exitward,
  5330. cell_stats->total_time_exitward);
  5331. }
  5332. *event_string = smartlist_join_strings(event_parts, " ", 0, NULL);
  5333. SMARTLIST_FOREACH(event_parts, char *, cp, tor_free(cp));
  5334. smartlist_free(event_parts);
  5335. }
  5336. /** A second or more has elapsed: tell any interested control connection
  5337. * how many cells have been processed for a given circuit. */
  5338. int
  5339. control_event_circuit_cell_stats(void)
  5340. {
  5341. cell_stats_t *cell_stats;
  5342. char *event_string;
  5343. if (!get_options()->TestingEnableCellStatsEvent ||
  5344. !EVENT_IS_INTERESTING(EVENT_CELL_STATS))
  5345. return 0;
  5346. cell_stats = tor_malloc(sizeof(cell_stats_t));
  5347. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, circ) {
  5348. if (!circ->testing_cell_stats)
  5349. continue;
  5350. sum_up_cell_stats_by_command(circ, cell_stats);
  5351. format_cell_stats(&event_string, circ, cell_stats);
  5352. send_control_event(EVENT_CELL_STATS,
  5353. "650 CELL_STATS %s\r\n", event_string);
  5354. tor_free(event_string);
  5355. }
  5356. SMARTLIST_FOREACH_END(circ);
  5357. tor_free(cell_stats);
  5358. return 0;
  5359. }
  5360. /** Tokens in <b>bucket</b> have been refilled: the read bucket was empty
  5361. * for <b>read_empty_time</b> millis, the write bucket was empty for
  5362. * <b>write_empty_time</b> millis, and buckets were last refilled
  5363. * <b>milliseconds_elapsed</b> millis ago. Only emit TB_EMPTY event if
  5364. * either read or write bucket have been empty before. */
  5365. int
  5366. control_event_tb_empty(const char *bucket, uint32_t read_empty_time,
  5367. uint32_t write_empty_time,
  5368. int milliseconds_elapsed)
  5369. {
  5370. if (get_options()->TestingEnableTbEmptyEvent &&
  5371. EVENT_IS_INTERESTING(EVENT_TB_EMPTY) &&
  5372. (read_empty_time > 0 || write_empty_time > 0)) {
  5373. send_control_event(EVENT_TB_EMPTY,
  5374. "650 TB_EMPTY %s READ=%d WRITTEN=%d "
  5375. "LAST=%d\r\n",
  5376. bucket, read_empty_time, write_empty_time,
  5377. milliseconds_elapsed);
  5378. }
  5379. return 0;
  5380. }
  5381. /* about 5 minutes worth. */
  5382. #define N_BW_EVENTS_TO_CACHE 300
  5383. /* Index into cached_bw_events to next write. */
  5384. static int next_measurement_idx = 0;
  5385. /* number of entries set in n_measurements */
  5386. static int n_measurements = 0;
  5387. static struct cached_bw_event_s {
  5388. uint32_t n_read;
  5389. uint32_t n_written;
  5390. } cached_bw_events[N_BW_EVENTS_TO_CACHE];
  5391. /** A second or more has elapsed: tell any interested control
  5392. * connections how much bandwidth we used. */
  5393. int
  5394. control_event_bandwidth_used(uint32_t n_read, uint32_t n_written)
  5395. {
  5396. cached_bw_events[next_measurement_idx].n_read = n_read;
  5397. cached_bw_events[next_measurement_idx].n_written = n_written;
  5398. if (++next_measurement_idx == N_BW_EVENTS_TO_CACHE)
  5399. next_measurement_idx = 0;
  5400. if (n_measurements < N_BW_EVENTS_TO_CACHE)
  5401. ++n_measurements;
  5402. if (EVENT_IS_INTERESTING(EVENT_BANDWIDTH_USED)) {
  5403. send_control_event(EVENT_BANDWIDTH_USED,
  5404. "650 BW %lu %lu\r\n",
  5405. (unsigned long)n_read,
  5406. (unsigned long)n_written);
  5407. }
  5408. return 0;
  5409. }
  5410. STATIC char *
  5411. get_bw_samples(void)
  5412. {
  5413. int i;
  5414. int idx = (next_measurement_idx + N_BW_EVENTS_TO_CACHE - n_measurements)
  5415. % N_BW_EVENTS_TO_CACHE;
  5416. tor_assert(0 <= idx && idx < N_BW_EVENTS_TO_CACHE);
  5417. smartlist_t *elements = smartlist_new();
  5418. for (i = 0; i < n_measurements; ++i) {
  5419. tor_assert(0 <= idx && idx < N_BW_EVENTS_TO_CACHE);
  5420. const struct cached_bw_event_s *bwe = &cached_bw_events[idx];
  5421. smartlist_add_asprintf(elements, "%u,%u",
  5422. (unsigned)bwe->n_read,
  5423. (unsigned)bwe->n_written);
  5424. idx = (idx + 1) % N_BW_EVENTS_TO_CACHE;
  5425. }
  5426. char *result = smartlist_join_strings(elements, " ", 0, NULL);
  5427. SMARTLIST_FOREACH(elements, char *, cp, tor_free(cp));
  5428. smartlist_free(elements);
  5429. return result;
  5430. }
  5431. /** Called when we are sending a log message to the controllers: suspend
  5432. * sending further log messages to the controllers until we're done. Used by
  5433. * CONN_LOG_PROTECT. */
  5434. void
  5435. disable_control_logging(void)
  5436. {
  5437. ++disable_log_messages;
  5438. }
  5439. /** We're done sending a log message to the controllers: re-enable controller
  5440. * logging. Used by CONN_LOG_PROTECT. */
  5441. void
  5442. enable_control_logging(void)
  5443. {
  5444. if (--disable_log_messages < 0)
  5445. tor_assert(0);
  5446. }
  5447. /** We got a log message: tell any interested control connections. */
  5448. void
  5449. control_event_logmsg(int severity, uint32_t domain, const char *msg)
  5450. {
  5451. int event;
  5452. /* Don't even think of trying to add stuff to a buffer from a cpuworker
  5453. * thread. */
  5454. if (! in_main_thread())
  5455. return;
  5456. if (disable_log_messages)
  5457. return;
  5458. if (domain == LD_BUG && EVENT_IS_INTERESTING(EVENT_STATUS_GENERAL) &&
  5459. severity <= LOG_NOTICE) {
  5460. char *esc = esc_for_log(msg);
  5461. ++disable_log_messages;
  5462. control_event_general_status(severity, "BUG REASON=%s", esc);
  5463. --disable_log_messages;
  5464. tor_free(esc);
  5465. }
  5466. event = log_severity_to_event(severity);
  5467. if (event >= 0 && EVENT_IS_INTERESTING(event)) {
  5468. char *b = NULL;
  5469. const char *s;
  5470. if (strchr(msg, '\n')) {
  5471. char *cp;
  5472. b = tor_strdup(msg);
  5473. for (cp = b; *cp; ++cp)
  5474. if (*cp == '\r' || *cp == '\n')
  5475. *cp = ' ';
  5476. }
  5477. switch (severity) {
  5478. case LOG_DEBUG: s = "DEBUG"; break;
  5479. case LOG_INFO: s = "INFO"; break;
  5480. case LOG_NOTICE: s = "NOTICE"; break;
  5481. case LOG_WARN: s = "WARN"; break;
  5482. case LOG_ERR: s = "ERR"; break;
  5483. default: s = "UnknownLogSeverity"; break;
  5484. }
  5485. ++disable_log_messages;
  5486. send_control_event(event, "650 %s %s\r\n", s, b?b:msg);
  5487. if (severity == LOG_ERR) {
  5488. /* Force a flush, since we may be about to die horribly */
  5489. queued_events_flush_all(1);
  5490. }
  5491. --disable_log_messages;
  5492. tor_free(b);
  5493. }
  5494. }
  5495. /** Called whenever we receive new router descriptors: tell any
  5496. * interested control connections. <b>routers</b> is a list of
  5497. * routerinfo_t's.
  5498. */
  5499. int
  5500. control_event_descriptors_changed(smartlist_t *routers)
  5501. {
  5502. char *msg;
  5503. if (!EVENT_IS_INTERESTING(EVENT_NEW_DESC))
  5504. return 0;
  5505. {
  5506. smartlist_t *names = smartlist_new();
  5507. char *ids;
  5508. SMARTLIST_FOREACH(routers, routerinfo_t *, ri, {
  5509. char *b = tor_malloc(MAX_VERBOSE_NICKNAME_LEN+1);
  5510. router_get_verbose_nickname(b, ri);
  5511. smartlist_add(names, b);
  5512. });
  5513. ids = smartlist_join_strings(names, " ", 0, NULL);
  5514. tor_asprintf(&msg, "650 NEWDESC %s\r\n", ids);
  5515. send_control_event_string(EVENT_NEW_DESC, msg);
  5516. tor_free(ids);
  5517. tor_free(msg);
  5518. SMARTLIST_FOREACH(names, char *, cp, tor_free(cp));
  5519. smartlist_free(names);
  5520. }
  5521. return 0;
  5522. }
  5523. /** Called when an address mapping on <b>from</b> from changes to <b>to</b>.
  5524. * <b>expires</b> values less than 3 are special; see connection_edge.c. If
  5525. * <b>error</b> is non-NULL, it is an error code describing the failure
  5526. * mode of the mapping.
  5527. */
  5528. int
  5529. control_event_address_mapped(const char *from, const char *to, time_t expires,
  5530. const char *error, const int cached)
  5531. {
  5532. if (!EVENT_IS_INTERESTING(EVENT_ADDRMAP))
  5533. return 0;
  5534. if (expires < 3 || expires == TIME_MAX)
  5535. send_control_event(EVENT_ADDRMAP,
  5536. "650 ADDRMAP %s %s NEVER %s%s"
  5537. "CACHED=\"%s\"\r\n",
  5538. from, to, error?error:"", error?" ":"",
  5539. cached?"YES":"NO");
  5540. else {
  5541. char buf[ISO_TIME_LEN+1];
  5542. char buf2[ISO_TIME_LEN+1];
  5543. format_local_iso_time(buf,expires);
  5544. format_iso_time(buf2,expires);
  5545. send_control_event(EVENT_ADDRMAP,
  5546. "650 ADDRMAP %s %s \"%s\""
  5547. " %s%sEXPIRES=\"%s\" CACHED=\"%s\"\r\n",
  5548. from, to, buf,
  5549. error?error:"", error?" ":"",
  5550. buf2, cached?"YES":"NO");
  5551. }
  5552. return 0;
  5553. }
  5554. /** Cached liveness for network liveness events and GETINFO
  5555. */
  5556. static int network_is_live = 0;
  5557. static int
  5558. get_cached_network_liveness(void)
  5559. {
  5560. return network_is_live;
  5561. }
  5562. static void
  5563. set_cached_network_liveness(int liveness)
  5564. {
  5565. network_is_live = liveness;
  5566. }
  5567. /** The network liveness has changed; this is called from circuitstats.c
  5568. * whenever we receive a cell, or when timeout expires and we assume the
  5569. * network is down. */
  5570. int
  5571. control_event_network_liveness_update(int liveness)
  5572. {
  5573. if (liveness > 0) {
  5574. if (get_cached_network_liveness() <= 0) {
  5575. /* Update cached liveness */
  5576. set_cached_network_liveness(1);
  5577. log_debug(LD_CONTROL, "Sending NETWORK_LIVENESS UP");
  5578. send_control_event_string(EVENT_NETWORK_LIVENESS,
  5579. "650 NETWORK_LIVENESS UP\r\n");
  5580. }
  5581. /* else was already live, no-op */
  5582. } else {
  5583. if (get_cached_network_liveness() > 0) {
  5584. /* Update cached liveness */
  5585. set_cached_network_liveness(0);
  5586. log_debug(LD_CONTROL, "Sending NETWORK_LIVENESS DOWN");
  5587. send_control_event_string(EVENT_NETWORK_LIVENESS,
  5588. "650 NETWORK_LIVENESS DOWN\r\n");
  5589. }
  5590. /* else was already dead, no-op */
  5591. }
  5592. return 0;
  5593. }
  5594. /** Helper function for NS-style events. Constructs and sends an event
  5595. * of type <b>event</b> with string <b>event_string</b> out of the set of
  5596. * networkstatuses <b>statuses</b>. Currently it is used for NS events
  5597. * and NEWCONSENSUS events. */
  5598. static int
  5599. control_event_networkstatus_changed_helper(smartlist_t *statuses,
  5600. uint16_t event,
  5601. const char *event_string)
  5602. {
  5603. smartlist_t *strs;
  5604. char *s, *esc = NULL;
  5605. if (!EVENT_IS_INTERESTING(event) || !smartlist_len(statuses))
  5606. return 0;
  5607. strs = smartlist_new();
  5608. smartlist_add_strdup(strs, "650+");
  5609. smartlist_add_strdup(strs, event_string);
  5610. smartlist_add_strdup(strs, "\r\n");
  5611. SMARTLIST_FOREACH(statuses, const routerstatus_t *, rs,
  5612. {
  5613. s = networkstatus_getinfo_helper_single(rs);
  5614. if (!s) continue;
  5615. smartlist_add(strs, s);
  5616. });
  5617. s = smartlist_join_strings(strs, "", 0, NULL);
  5618. write_escaped_data(s, strlen(s), &esc);
  5619. SMARTLIST_FOREACH(strs, char *, cp, tor_free(cp));
  5620. smartlist_free(strs);
  5621. tor_free(s);
  5622. send_control_event_string(event, esc);
  5623. send_control_event_string(event,
  5624. "650 OK\r\n");
  5625. tor_free(esc);
  5626. return 0;
  5627. }
  5628. /** Called when the routerstatus_ts <b>statuses</b> have changed: sends
  5629. * an NS event to any controller that cares. */
  5630. int
  5631. control_event_networkstatus_changed(smartlist_t *statuses)
  5632. {
  5633. return control_event_networkstatus_changed_helper(statuses, EVENT_NS, "NS");
  5634. }
  5635. /** Called when we get a new consensus networkstatus. Sends a NEWCONSENSUS
  5636. * event consisting of an NS-style line for each relay in the consensus. */
  5637. int
  5638. control_event_newconsensus(const networkstatus_t *consensus)
  5639. {
  5640. if (!control_event_is_interesting(EVENT_NEWCONSENSUS))
  5641. return 0;
  5642. return control_event_networkstatus_changed_helper(
  5643. consensus->routerstatus_list, EVENT_NEWCONSENSUS, "NEWCONSENSUS");
  5644. }
  5645. /** Called when we compute a new circuitbuildtimeout */
  5646. int
  5647. control_event_buildtimeout_set(buildtimeout_set_event_t type,
  5648. const char *args)
  5649. {
  5650. const char *type_string = NULL;
  5651. if (!control_event_is_interesting(EVENT_BUILDTIMEOUT_SET))
  5652. return 0;
  5653. switch (type) {
  5654. case BUILDTIMEOUT_SET_EVENT_COMPUTED:
  5655. type_string = "COMPUTED";
  5656. break;
  5657. case BUILDTIMEOUT_SET_EVENT_RESET:
  5658. type_string = "RESET";
  5659. break;
  5660. case BUILDTIMEOUT_SET_EVENT_SUSPENDED:
  5661. type_string = "SUSPENDED";
  5662. break;
  5663. case BUILDTIMEOUT_SET_EVENT_DISCARD:
  5664. type_string = "DISCARD";
  5665. break;
  5666. case BUILDTIMEOUT_SET_EVENT_RESUME:
  5667. type_string = "RESUME";
  5668. break;
  5669. default:
  5670. type_string = "UNKNOWN";
  5671. break;
  5672. }
  5673. send_control_event(EVENT_BUILDTIMEOUT_SET,
  5674. "650 BUILDTIMEOUT_SET %s %s\r\n",
  5675. type_string, args);
  5676. return 0;
  5677. }
  5678. /** Called when a signal has been processed from signal_callback */
  5679. int
  5680. control_event_signal(uintptr_t signal_num)
  5681. {
  5682. const char *signal_string = NULL;
  5683. if (!control_event_is_interesting(EVENT_GOT_SIGNAL))
  5684. return 0;
  5685. switch (signal_num) {
  5686. case SIGHUP:
  5687. signal_string = "RELOAD";
  5688. break;
  5689. case SIGUSR1:
  5690. signal_string = "DUMP";
  5691. break;
  5692. case SIGUSR2:
  5693. signal_string = "DEBUG";
  5694. break;
  5695. case SIGNEWNYM:
  5696. signal_string = "NEWNYM";
  5697. break;
  5698. case SIGCLEARDNSCACHE:
  5699. signal_string = "CLEARDNSCACHE";
  5700. break;
  5701. case SIGHEARTBEAT:
  5702. signal_string = "HEARTBEAT";
  5703. break;
  5704. default:
  5705. log_warn(LD_BUG, "Unrecognized signal %lu in control_event_signal",
  5706. (unsigned long)signal_num);
  5707. return -1;
  5708. }
  5709. send_control_event(EVENT_GOT_SIGNAL, "650 SIGNAL %s\r\n",
  5710. signal_string);
  5711. return 0;
  5712. }
  5713. /** Called when a single local_routerstatus_t has changed: Sends an NS event
  5714. * to any controller that cares. */
  5715. int
  5716. control_event_networkstatus_changed_single(const routerstatus_t *rs)
  5717. {
  5718. smartlist_t *statuses;
  5719. int r;
  5720. if (!EVENT_IS_INTERESTING(EVENT_NS))
  5721. return 0;
  5722. statuses = smartlist_new();
  5723. smartlist_add(statuses, (void*)rs);
  5724. r = control_event_networkstatus_changed(statuses);
  5725. smartlist_free(statuses);
  5726. return r;
  5727. }
  5728. /** Our own router descriptor has changed; tell any controllers that care.
  5729. */
  5730. int
  5731. control_event_my_descriptor_changed(void)
  5732. {
  5733. send_control_event(EVENT_DESCCHANGED, "650 DESCCHANGED\r\n");
  5734. return 0;
  5735. }
  5736. /** Helper: sends a status event where <b>type</b> is one of
  5737. * EVENT_STATUS_{GENERAL,CLIENT,SERVER}, where <b>severity</b> is one of
  5738. * LOG_{NOTICE,WARN,ERR}, and where <b>format</b> is a printf-style format
  5739. * string corresponding to <b>args</b>. */
  5740. static int
  5741. control_event_status(int type, int severity, const char *format, va_list args)
  5742. {
  5743. char *user_buf = NULL;
  5744. char format_buf[160];
  5745. const char *status, *sev;
  5746. switch (type) {
  5747. case EVENT_STATUS_GENERAL:
  5748. status = "STATUS_GENERAL";
  5749. break;
  5750. case EVENT_STATUS_CLIENT:
  5751. status = "STATUS_CLIENT";
  5752. break;
  5753. case EVENT_STATUS_SERVER:
  5754. status = "STATUS_SERVER";
  5755. break;
  5756. default:
  5757. log_warn(LD_BUG, "Unrecognized status type %d", type);
  5758. return -1;
  5759. }
  5760. switch (severity) {
  5761. case LOG_NOTICE:
  5762. sev = "NOTICE";
  5763. break;
  5764. case LOG_WARN:
  5765. sev = "WARN";
  5766. break;
  5767. case LOG_ERR:
  5768. sev = "ERR";
  5769. break;
  5770. default:
  5771. log_warn(LD_BUG, "Unrecognized status severity %d", severity);
  5772. return -1;
  5773. }
  5774. if (tor_snprintf(format_buf, sizeof(format_buf), "650 %s %s",
  5775. status, sev)<0) {
  5776. log_warn(LD_BUG, "Format string too long.");
  5777. return -1;
  5778. }
  5779. tor_vasprintf(&user_buf, format, args);
  5780. send_control_event(type, "%s %s\r\n", format_buf, user_buf);
  5781. tor_free(user_buf);
  5782. return 0;
  5783. }
  5784. #define CONTROL_EVENT_STATUS_BODY(event, sev) \
  5785. int r; \
  5786. do { \
  5787. va_list ap; \
  5788. if (!EVENT_IS_INTERESTING(event)) \
  5789. return 0; \
  5790. \
  5791. va_start(ap, format); \
  5792. r = control_event_status((event), (sev), format, ap); \
  5793. va_end(ap); \
  5794. } while (0)
  5795. /** Format and send an EVENT_STATUS_GENERAL event whose main text is obtained
  5796. * by formatting the arguments using the printf-style <b>format</b>. */
  5797. int
  5798. control_event_general_status(int severity, const char *format, ...)
  5799. {
  5800. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_GENERAL, severity);
  5801. return r;
  5802. }
  5803. /** Format and send an EVENT_STATUS_GENERAL LOG_ERR event, and flush it to the
  5804. * controller(s) immediately. */
  5805. int
  5806. control_event_general_error(const char *format, ...)
  5807. {
  5808. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_GENERAL, LOG_ERR);
  5809. /* Force a flush, since we may be about to die horribly */
  5810. queued_events_flush_all(1);
  5811. return r;
  5812. }
  5813. /** Format and send an EVENT_STATUS_CLIENT event whose main text is obtained
  5814. * by formatting the arguments using the printf-style <b>format</b>. */
  5815. int
  5816. control_event_client_status(int severity, const char *format, ...)
  5817. {
  5818. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_CLIENT, severity);
  5819. return r;
  5820. }
  5821. /** Format and send an EVENT_STATUS_CLIENT LOG_ERR event, and flush it to the
  5822. * controller(s) immediately. */
  5823. int
  5824. control_event_client_error(const char *format, ...)
  5825. {
  5826. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_CLIENT, LOG_ERR);
  5827. /* Force a flush, since we may be about to die horribly */
  5828. queued_events_flush_all(1);
  5829. return r;
  5830. }
  5831. /** Format and send an EVENT_STATUS_SERVER event whose main text is obtained
  5832. * by formatting the arguments using the printf-style <b>format</b>. */
  5833. int
  5834. control_event_server_status(int severity, const char *format, ...)
  5835. {
  5836. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_SERVER, severity);
  5837. return r;
  5838. }
  5839. /** Format and send an EVENT_STATUS_SERVER LOG_ERR event, and flush it to the
  5840. * controller(s) immediately. */
  5841. int
  5842. control_event_server_error(const char *format, ...)
  5843. {
  5844. CONTROL_EVENT_STATUS_BODY(EVENT_STATUS_SERVER, LOG_ERR);
  5845. /* Force a flush, since we may be about to die horribly */
  5846. queued_events_flush_all(1);
  5847. return r;
  5848. }
  5849. /** Called when the status of an entry guard with the given <b>nickname</b>
  5850. * and identity <b>digest</b> has changed to <b>status</b>: tells any
  5851. * controllers that care. */
  5852. int
  5853. control_event_guard(const char *nickname, const char *digest,
  5854. const char *status)
  5855. {
  5856. char hbuf[HEX_DIGEST_LEN+1];
  5857. base16_encode(hbuf, sizeof(hbuf), digest, DIGEST_LEN);
  5858. if (!EVENT_IS_INTERESTING(EVENT_GUARD))
  5859. return 0;
  5860. {
  5861. char buf[MAX_VERBOSE_NICKNAME_LEN+1];
  5862. const node_t *node = node_get_by_id(digest);
  5863. if (node) {
  5864. node_get_verbose_nickname(node, buf);
  5865. } else {
  5866. tor_snprintf(buf, sizeof(buf), "$%s~%s", hbuf, nickname);
  5867. }
  5868. send_control_event(EVENT_GUARD,
  5869. "650 GUARD ENTRY %s %s\r\n", buf, status);
  5870. }
  5871. return 0;
  5872. }
  5873. /** Called when a configuration option changes. This is generally triggered
  5874. * by SETCONF requests and RELOAD/SIGHUP signals. The <b>elements</b> is
  5875. * a smartlist_t containing (key, value, ...) pairs in sequence.
  5876. * <b>value</b> can be NULL. */
  5877. int
  5878. control_event_conf_changed(const smartlist_t *elements)
  5879. {
  5880. int i;
  5881. char *result;
  5882. smartlist_t *lines;
  5883. if (!EVENT_IS_INTERESTING(EVENT_CONF_CHANGED) ||
  5884. smartlist_len(elements) == 0) {
  5885. return 0;
  5886. }
  5887. lines = smartlist_new();
  5888. for (i = 0; i < smartlist_len(elements); i += 2) {
  5889. char *k = smartlist_get(elements, i);
  5890. char *v = smartlist_get(elements, i+1);
  5891. if (v == NULL) {
  5892. smartlist_add_asprintf(lines, "650-%s", k);
  5893. } else {
  5894. smartlist_add_asprintf(lines, "650-%s=%s", k, v);
  5895. }
  5896. }
  5897. result = smartlist_join_strings(lines, "\r\n", 0, NULL);
  5898. send_control_event(EVENT_CONF_CHANGED,
  5899. "650-CONF_CHANGED\r\n%s\r\n650 OK\r\n", result);
  5900. tor_free(result);
  5901. SMARTLIST_FOREACH(lines, char *, cp, tor_free(cp));
  5902. smartlist_free(lines);
  5903. return 0;
  5904. }
  5905. /** Helper: Return a newly allocated string containing a path to the
  5906. * file where we store our authentication cookie. */
  5907. char *
  5908. get_controller_cookie_file_name(void)
  5909. {
  5910. const or_options_t *options = get_options();
  5911. if (options->CookieAuthFile && strlen(options->CookieAuthFile)) {
  5912. return tor_strdup(options->CookieAuthFile);
  5913. } else {
  5914. return get_datadir_fname("control_auth_cookie");
  5915. }
  5916. }
  5917. /* Initialize the cookie-based authentication system of the
  5918. * ControlPort. If <b>enabled</b> is 0, then disable the cookie
  5919. * authentication system. */
  5920. int
  5921. init_control_cookie_authentication(int enabled)
  5922. {
  5923. char *fname = NULL;
  5924. int retval;
  5925. if (!enabled) {
  5926. authentication_cookie_is_set = 0;
  5927. return 0;
  5928. }
  5929. fname = get_controller_cookie_file_name();
  5930. retval = init_cookie_authentication(fname, "", /* no header */
  5931. AUTHENTICATION_COOKIE_LEN,
  5932. get_options()->CookieAuthFileGroupReadable,
  5933. &authentication_cookie,
  5934. &authentication_cookie_is_set);
  5935. tor_free(fname);
  5936. return retval;
  5937. }
  5938. /** A copy of the process specifier of Tor's owning controller, or
  5939. * NULL if this Tor instance is not currently owned by a process. */
  5940. static char *owning_controller_process_spec = NULL;
  5941. /** A process-termination monitor for Tor's owning controller, or NULL
  5942. * if this Tor instance is not currently owned by a process. */
  5943. static tor_process_monitor_t *owning_controller_process_monitor = NULL;
  5944. /** Process-termination monitor callback for Tor's owning controller
  5945. * process. */
  5946. static void
  5947. owning_controller_procmon_cb(void *unused)
  5948. {
  5949. (void)unused;
  5950. lost_owning_controller("process", "vanished");
  5951. }
  5952. /** Set <b>process_spec</b> as Tor's owning controller process.
  5953. * Exit on failure. */
  5954. void
  5955. monitor_owning_controller_process(const char *process_spec)
  5956. {
  5957. const char *msg;
  5958. tor_assert((owning_controller_process_spec == NULL) ==
  5959. (owning_controller_process_monitor == NULL));
  5960. if (owning_controller_process_spec != NULL) {
  5961. if ((process_spec != NULL) && !strcmp(process_spec,
  5962. owning_controller_process_spec)) {
  5963. /* Same process -- return now, instead of disposing of and
  5964. * recreating the process-termination monitor. */
  5965. return;
  5966. }
  5967. /* We are currently owned by a process, and we should no longer be
  5968. * owned by it. Free the process-termination monitor. */
  5969. tor_process_monitor_free(owning_controller_process_monitor);
  5970. owning_controller_process_monitor = NULL;
  5971. tor_free(owning_controller_process_spec);
  5972. owning_controller_process_spec = NULL;
  5973. }
  5974. tor_assert((owning_controller_process_spec == NULL) &&
  5975. (owning_controller_process_monitor == NULL));
  5976. if (process_spec == NULL)
  5977. return;
  5978. owning_controller_process_spec = tor_strdup(process_spec);
  5979. owning_controller_process_monitor =
  5980. tor_process_monitor_new(tor_libevent_get_base(),
  5981. owning_controller_process_spec,
  5982. LD_CONTROL,
  5983. owning_controller_procmon_cb, NULL,
  5984. &msg);
  5985. if (owning_controller_process_monitor == NULL) {
  5986. log_err(LD_BUG, "Couldn't create process-termination monitor for "
  5987. "owning controller: %s. Exiting.",
  5988. msg);
  5989. owning_controller_process_spec = NULL;
  5990. tor_cleanup();
  5991. exit(1);
  5992. }
  5993. }
  5994. /** Convert the name of a bootstrapping phase <b>s</b> into strings
  5995. * <b>tag</b> and <b>summary</b> suitable for display by the controller. */
  5996. static int
  5997. bootstrap_status_to_string(bootstrap_status_t s, const char **tag,
  5998. const char **summary)
  5999. {
  6000. switch (s) {
  6001. case BOOTSTRAP_STATUS_UNDEF:
  6002. *tag = "undef";
  6003. *summary = "Undefined";
  6004. break;
  6005. case BOOTSTRAP_STATUS_STARTING:
  6006. *tag = "starting";
  6007. *summary = "Starting";
  6008. break;
  6009. case BOOTSTRAP_STATUS_CONN_DIR:
  6010. *tag = "conn_dir";
  6011. *summary = "Connecting to directory server";
  6012. break;
  6013. case BOOTSTRAP_STATUS_HANDSHAKE:
  6014. *tag = "status_handshake";
  6015. *summary = "Finishing handshake";
  6016. break;
  6017. case BOOTSTRAP_STATUS_HANDSHAKE_DIR:
  6018. *tag = "handshake_dir";
  6019. *summary = "Finishing handshake with directory server";
  6020. break;
  6021. case BOOTSTRAP_STATUS_ONEHOP_CREATE:
  6022. *tag = "onehop_create";
  6023. *summary = "Establishing an encrypted directory connection";
  6024. break;
  6025. case BOOTSTRAP_STATUS_REQUESTING_STATUS:
  6026. *tag = "requesting_status";
  6027. *summary = "Asking for networkstatus consensus";
  6028. break;
  6029. case BOOTSTRAP_STATUS_LOADING_STATUS:
  6030. *tag = "loading_status";
  6031. *summary = "Loading networkstatus consensus";
  6032. break;
  6033. case BOOTSTRAP_STATUS_LOADING_KEYS:
  6034. *tag = "loading_keys";
  6035. *summary = "Loading authority key certs";
  6036. break;
  6037. case BOOTSTRAP_STATUS_REQUESTING_DESCRIPTORS:
  6038. *tag = "requesting_descriptors";
  6039. /* XXXX this appears to incorrectly report internal on most loads */
  6040. *summary = router_have_consensus_path() == CONSENSUS_PATH_INTERNAL ?
  6041. "Asking for relay descriptors for internal paths" :
  6042. "Asking for relay descriptors";
  6043. break;
  6044. /* If we're sure there are no exits in the consensus,
  6045. * inform the controller by adding "internal"
  6046. * to the status summaries.
  6047. * (We only check this while loading descriptors,
  6048. * so we may not know in the earlier stages.)
  6049. * But if there are exits, we can't be sure whether
  6050. * we're creating internal or exit paths/circuits.
  6051. * XXXX Or should be use different tags or statuses
  6052. * for internal and exit/all? */
  6053. case BOOTSTRAP_STATUS_LOADING_DESCRIPTORS:
  6054. *tag = "loading_descriptors";
  6055. *summary = router_have_consensus_path() == CONSENSUS_PATH_INTERNAL ?
  6056. "Loading relay descriptors for internal paths" :
  6057. "Loading relay descriptors";
  6058. break;
  6059. case BOOTSTRAP_STATUS_CONN_OR:
  6060. *tag = "conn_or";
  6061. *summary = router_have_consensus_path() == CONSENSUS_PATH_INTERNAL ?
  6062. "Connecting to the Tor network internally" :
  6063. "Connecting to the Tor network";
  6064. break;
  6065. case BOOTSTRAP_STATUS_HANDSHAKE_OR:
  6066. *tag = "handshake_or";
  6067. *summary = router_have_consensus_path() == CONSENSUS_PATH_INTERNAL ?
  6068. "Finishing handshake with first hop of internal circuit" :
  6069. "Finishing handshake with first hop";
  6070. break;
  6071. case BOOTSTRAP_STATUS_CIRCUIT_CREATE:
  6072. *tag = "circuit_create";
  6073. *summary = router_have_consensus_path() == CONSENSUS_PATH_INTERNAL ?
  6074. "Establishing an internal Tor circuit" :
  6075. "Establishing a Tor circuit";
  6076. break;
  6077. case BOOTSTRAP_STATUS_DONE:
  6078. *tag = "done";
  6079. *summary = "Done";
  6080. break;
  6081. default:
  6082. // log_warn(LD_BUG, "Unrecognized bootstrap status code %d", s);
  6083. *tag = *summary = "unknown";
  6084. return -1;
  6085. }
  6086. return 0;
  6087. }
  6088. /** What percentage through the bootstrap process are we? We remember
  6089. * this so we can avoid sending redundant bootstrap status events, and
  6090. * so we can guess context for the bootstrap messages which are
  6091. * ambiguous. It starts at 'undef', but gets set to 'starting' while
  6092. * Tor initializes. */
  6093. static int bootstrap_percent = BOOTSTRAP_STATUS_UNDEF;
  6094. /** As bootstrap_percent, but holds the bootstrapping level at which we last
  6095. * logged a NOTICE-level message. We use this, plus BOOTSTRAP_PCT_INCREMENT,
  6096. * to avoid flooding the log with a new message every time we get a few more
  6097. * microdescriptors */
  6098. static int notice_bootstrap_percent = 0;
  6099. /** How many problems have we had getting to the next bootstrapping phase?
  6100. * These include failure to establish a connection to a Tor relay,
  6101. * failures to finish the TLS handshake, failures to validate the
  6102. * consensus document, etc. */
  6103. static int bootstrap_problems = 0;
  6104. /** We only tell the controller once we've hit a threshold of problems
  6105. * for the current phase. */
  6106. #define BOOTSTRAP_PROBLEM_THRESHOLD 10
  6107. /** When our bootstrapping progress level changes, but our bootstrapping
  6108. * status has not advanced, we only log at NOTICE when we have made at least
  6109. * this much progress.
  6110. */
  6111. #define BOOTSTRAP_PCT_INCREMENT 5
  6112. /** Called when Tor has made progress at bootstrapping its directory
  6113. * information and initial circuits.
  6114. *
  6115. * <b>status</b> is the new status, that is, what task we will be doing
  6116. * next. <b>progress</b> is zero if we just started this task, else it
  6117. * represents progress on the task.
  6118. *
  6119. * Return true if we logged a message at level NOTICE, and false otherwise.
  6120. */
  6121. int
  6122. control_event_bootstrap(bootstrap_status_t status, int progress)
  6123. {
  6124. const char *tag, *summary;
  6125. char buf[BOOTSTRAP_MSG_LEN];
  6126. if (bootstrap_percent == BOOTSTRAP_STATUS_DONE)
  6127. return 0; /* already bootstrapped; nothing to be done here. */
  6128. /* special case for handshaking status, since our TLS handshaking code
  6129. * can't distinguish what the connection is going to be for. */
  6130. if (status == BOOTSTRAP_STATUS_HANDSHAKE) {
  6131. if (bootstrap_percent < BOOTSTRAP_STATUS_CONN_OR) {
  6132. status = BOOTSTRAP_STATUS_HANDSHAKE_DIR;
  6133. } else {
  6134. status = BOOTSTRAP_STATUS_HANDSHAKE_OR;
  6135. }
  6136. }
  6137. if (status > bootstrap_percent ||
  6138. (progress && progress > bootstrap_percent)) {
  6139. int loglevel = LOG_NOTICE;
  6140. bootstrap_status_to_string(status, &tag, &summary);
  6141. if (status <= bootstrap_percent &&
  6142. (progress < notice_bootstrap_percent + BOOTSTRAP_PCT_INCREMENT)) {
  6143. /* We log the message at info if the status hasn't advanced, and if less
  6144. * than BOOTSTRAP_PCT_INCREMENT progress has been made.
  6145. */
  6146. loglevel = LOG_INFO;
  6147. }
  6148. tor_log(loglevel, LD_CONTROL,
  6149. "Bootstrapped %d%%: %s", progress ? progress : status, summary);
  6150. tor_snprintf(buf, sizeof(buf),
  6151. "BOOTSTRAP PROGRESS=%d TAG=%s SUMMARY=\"%s\"",
  6152. progress ? progress : status, tag, summary);
  6153. tor_snprintf(last_sent_bootstrap_message,
  6154. sizeof(last_sent_bootstrap_message),
  6155. "NOTICE %s", buf);
  6156. control_event_client_status(LOG_NOTICE, "%s", buf);
  6157. if (status > bootstrap_percent) {
  6158. bootstrap_percent = status; /* new milestone reached */
  6159. }
  6160. if (progress > bootstrap_percent) {
  6161. /* incremental progress within a milestone */
  6162. bootstrap_percent = progress;
  6163. bootstrap_problems = 0; /* Progress! Reset our problem counter. */
  6164. }
  6165. if (loglevel == LOG_NOTICE &&
  6166. bootstrap_percent > notice_bootstrap_percent) {
  6167. /* Remember that we gave a notice at this level. */
  6168. notice_bootstrap_percent = bootstrap_percent;
  6169. }
  6170. return loglevel == LOG_NOTICE;
  6171. }
  6172. return 0;
  6173. }
  6174. /** Called when Tor has failed to make bootstrapping progress in a way
  6175. * that indicates a problem. <b>warn</b> gives a human-readable hint
  6176. * as to why, and <b>reason</b> provides a controller-facing short
  6177. * tag. <b>conn</b> is the connection that caused this problem and
  6178. * can be NULL if a connection cannot be easily identified.
  6179. */
  6180. void
  6181. control_event_bootstrap_problem(const char *warn, const char *reason,
  6182. const connection_t *conn, int dowarn)
  6183. {
  6184. int status = bootstrap_percent;
  6185. const char *tag = "", *summary = "";
  6186. char buf[BOOTSTRAP_MSG_LEN];
  6187. const char *recommendation = "ignore";
  6188. int severity;
  6189. char *or_id = NULL, *hostaddr = NULL;
  6190. or_connection_t *or_conn = NULL;
  6191. /* bootstrap_percent must not be in "undefined" state here. */
  6192. tor_assert(status >= 0);
  6193. if (bootstrap_percent == 100)
  6194. return; /* already bootstrapped; nothing to be done here. */
  6195. bootstrap_problems++;
  6196. if (bootstrap_problems >= BOOTSTRAP_PROBLEM_THRESHOLD)
  6197. dowarn = 1;
  6198. if (we_are_hibernating())
  6199. dowarn = 0;
  6200. while (status>=0 && bootstrap_status_to_string(status, &tag, &summary) < 0)
  6201. status--; /* find a recognized status string based on current progress */
  6202. status = bootstrap_percent; /* set status back to the actual number */
  6203. severity = dowarn ? LOG_WARN : LOG_INFO;
  6204. if (dowarn)
  6205. recommendation = "warn";
  6206. if (conn && conn->type == CONN_TYPE_OR) {
  6207. /* XXX TO_OR_CONN can't deal with const */
  6208. or_conn = TO_OR_CONN((connection_t *)conn);
  6209. or_id = tor_strdup(hex_str(or_conn->identity_digest, DIGEST_LEN));
  6210. } else {
  6211. or_id = tor_strdup("?");
  6212. }
  6213. if (conn)
  6214. tor_asprintf(&hostaddr, "%s:%d", conn->address, (int)conn->port);
  6215. else
  6216. hostaddr = tor_strdup("?");
  6217. log_fn(severity,
  6218. LD_CONTROL, "Problem bootstrapping. Stuck at %d%%: %s. (%s; %s; "
  6219. "count %d; recommendation %s; host %s at %s)",
  6220. status, summary, warn, reason,
  6221. bootstrap_problems, recommendation,
  6222. or_id, hostaddr);
  6223. connection_or_report_broken_states(severity, LD_HANDSHAKE);
  6224. tor_snprintf(buf, sizeof(buf),
  6225. "BOOTSTRAP PROGRESS=%d TAG=%s SUMMARY=\"%s\" WARNING=\"%s\" REASON=%s "
  6226. "COUNT=%d RECOMMENDATION=%s HOSTID=\"%s\" HOSTADDR=\"%s\"",
  6227. bootstrap_percent, tag, summary, warn, reason, bootstrap_problems,
  6228. recommendation,
  6229. or_id, hostaddr);
  6230. tor_snprintf(last_sent_bootstrap_message,
  6231. sizeof(last_sent_bootstrap_message),
  6232. "WARN %s", buf);
  6233. control_event_client_status(LOG_WARN, "%s", buf);
  6234. tor_free(hostaddr);
  6235. tor_free(or_id);
  6236. }
  6237. /** Called when Tor has failed to make bootstrapping progress in a way
  6238. * that indicates a problem. <b>warn</b> gives a hint as to why, and
  6239. * <b>reason</b> provides an "or_conn_end_reason" tag. <b>or_conn</b>
  6240. * is the connection that caused this problem.
  6241. */
  6242. MOCK_IMPL(void,
  6243. control_event_bootstrap_prob_or, (const char *warn, int reason,
  6244. or_connection_t *or_conn))
  6245. {
  6246. int dowarn = 0;
  6247. if (or_conn->have_noted_bootstrap_problem)
  6248. return;
  6249. or_conn->have_noted_bootstrap_problem = 1;
  6250. if (reason == END_OR_CONN_REASON_NO_ROUTE)
  6251. dowarn = 1;
  6252. /* If we are using bridges and all our OR connections are now
  6253. closed, it means that we totally failed to connect to our
  6254. bridges. Throw a warning. */
  6255. if (get_options()->UseBridges && !any_other_active_or_conns(or_conn))
  6256. dowarn = 1;
  6257. control_event_bootstrap_problem(warn,
  6258. orconn_end_reason_to_control_string(reason),
  6259. TO_CONN(or_conn), dowarn);
  6260. }
  6261. /** We just generated a new summary of which countries we've seen clients
  6262. * from recently. Send a copy to the controller in case it wants to
  6263. * display it for the user. */
  6264. void
  6265. control_event_clients_seen(const char *controller_str)
  6266. {
  6267. send_control_event(EVENT_CLIENTS_SEEN,
  6268. "650 CLIENTS_SEEN %s\r\n", controller_str);
  6269. }
  6270. /** A new pluggable transport called <b>transport_name</b> was
  6271. * launched on <b>addr</b>:<b>port</b>. <b>mode</b> is either
  6272. * "server" or "client" depending on the mode of the pluggable
  6273. * transport.
  6274. * "650" SP "TRANSPORT_LAUNCHED" SP Mode SP Name SP Address SP Port
  6275. */
  6276. void
  6277. control_event_transport_launched(const char *mode, const char *transport_name,
  6278. tor_addr_t *addr, uint16_t port)
  6279. {
  6280. send_control_event(EVENT_TRANSPORT_LAUNCHED,
  6281. "650 TRANSPORT_LAUNCHED %s %s %s %u\r\n",
  6282. mode, transport_name, fmt_addr(addr), port);
  6283. }
  6284. /** Convert rendezvous auth type to string for HS_DESC control events
  6285. */
  6286. const char *
  6287. rend_auth_type_to_string(rend_auth_type_t auth_type)
  6288. {
  6289. const char *str;
  6290. switch (auth_type) {
  6291. case REND_NO_AUTH:
  6292. str = "NO_AUTH";
  6293. break;
  6294. case REND_BASIC_AUTH:
  6295. str = "BASIC_AUTH";
  6296. break;
  6297. case REND_STEALTH_AUTH:
  6298. str = "STEALTH_AUTH";
  6299. break;
  6300. default:
  6301. str = "UNKNOWN";
  6302. }
  6303. return str;
  6304. }
  6305. /** Return a longname the node whose identity is <b>id_digest</b>. If
  6306. * node_get_by_id() returns NULL, base 16 encoding of <b>id_digest</b> is
  6307. * returned instead.
  6308. *
  6309. * This function is not thread-safe. Each call to this function invalidates
  6310. * previous values returned by this function.
  6311. */
  6312. MOCK_IMPL(const char *,
  6313. node_describe_longname_by_id,(const char *id_digest))
  6314. {
  6315. static char longname[MAX_VERBOSE_NICKNAME_LEN+1];
  6316. node_get_verbose_nickname_by_id(id_digest, longname);
  6317. return longname;
  6318. }
  6319. /** Return either the onion address if the given pointer is a non empty
  6320. * string else the unknown string. */
  6321. static const char *
  6322. rend_hsaddress_str_or_unknown(const char *onion_address)
  6323. {
  6324. static const char *str_unknown = "UNKNOWN";
  6325. const char *str_ret = str_unknown;
  6326. /* No valid pointer, unknown it is. */
  6327. if (!onion_address) {
  6328. goto end;
  6329. }
  6330. /* Empty onion address thus we don't know, unknown it is. */
  6331. if (onion_address[0] == '\0') {
  6332. goto end;
  6333. }
  6334. /* All checks are good so return the given onion address. */
  6335. str_ret = onion_address;
  6336. end:
  6337. return str_ret;
  6338. }
  6339. /** send HS_DESC requested event.
  6340. *
  6341. * <b>rend_query</b> is used to fetch requested onion address and auth type.
  6342. * <b>hs_dir</b> is the description of contacting hs directory.
  6343. * <b>desc_id_base32</b> is the ID of requested hs descriptor.
  6344. */
  6345. void
  6346. control_event_hs_descriptor_requested(const rend_data_t *rend_query,
  6347. const char *id_digest,
  6348. const char *desc_id_base32)
  6349. {
  6350. if (!id_digest || !rend_query || !desc_id_base32) {
  6351. log_warn(LD_BUG, "Called with rend_query==%p, "
  6352. "id_digest==%p, desc_id_base32==%p",
  6353. rend_query, id_digest, desc_id_base32);
  6354. return;
  6355. }
  6356. send_control_event(EVENT_HS_DESC,
  6357. "650 HS_DESC REQUESTED %s %s %s %s\r\n",
  6358. rend_hsaddress_str_or_unknown(
  6359. rend_data_get_address(rend_query)),
  6360. rend_auth_type_to_string(
  6361. TO_REND_DATA_V2(rend_query)->auth_type),
  6362. node_describe_longname_by_id(id_digest),
  6363. desc_id_base32);
  6364. }
  6365. /** For an HS descriptor query <b>rend_data</b>, using the
  6366. * <b>onion_address</b> and HSDir fingerprint <b>hsdir_fp</b>, find out
  6367. * which descriptor ID in the query is the right one.
  6368. *
  6369. * Return a pointer of the binary descriptor ID found in the query's object
  6370. * or NULL if not found. */
  6371. static const char *
  6372. get_desc_id_from_query(const rend_data_t *rend_data, const char *hsdir_fp)
  6373. {
  6374. int replica;
  6375. const char *desc_id = NULL;
  6376. const rend_data_v2_t *rend_data_v2 = TO_REND_DATA_V2(rend_data);
  6377. /* Possible if the fetch was done using a descriptor ID. This means that
  6378. * the HSFETCH command was used. */
  6379. if (!tor_digest_is_zero(rend_data_v2->desc_id_fetch)) {
  6380. desc_id = rend_data_v2->desc_id_fetch;
  6381. goto end;
  6382. }
  6383. /* Without a directory fingerprint at this stage, we can't do much. */
  6384. if (hsdir_fp == NULL) {
  6385. goto end;
  6386. }
  6387. /* OK, we have an onion address so now let's find which descriptor ID
  6388. * is the one associated with the HSDir fingerprint. */
  6389. for (replica = 0; replica < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS;
  6390. replica++) {
  6391. const char *digest = rend_data_get_desc_id(rend_data, replica, NULL);
  6392. SMARTLIST_FOREACH_BEGIN(rend_data->hsdirs_fp, char *, fingerprint) {
  6393. if (tor_memcmp(fingerprint, hsdir_fp, DIGEST_LEN) == 0) {
  6394. /* Found it! This descriptor ID is the right one. */
  6395. desc_id = digest;
  6396. goto end;
  6397. }
  6398. } SMARTLIST_FOREACH_END(fingerprint);
  6399. }
  6400. end:
  6401. return desc_id;
  6402. }
  6403. /** send HS_DESC CREATED event when a local service generates a descriptor.
  6404. *
  6405. * <b>service_id</b> is the descriptor onion address.
  6406. * <b>desc_id_base32</b> is the descriptor ID.
  6407. * <b>replica</b> is the the descriptor replica number.
  6408. */
  6409. void
  6410. control_event_hs_descriptor_created(const char *service_id,
  6411. const char *desc_id_base32,
  6412. int replica)
  6413. {
  6414. if (!service_id || !desc_id_base32) {
  6415. log_warn(LD_BUG, "Called with service_digest==%p, "
  6416. "desc_id_base32==%p", service_id, desc_id_base32);
  6417. return;
  6418. }
  6419. send_control_event(EVENT_HS_DESC,
  6420. "650 HS_DESC CREATED %s UNKNOWN UNKNOWN %s "
  6421. "REPLICA=%d\r\n",
  6422. service_id,
  6423. desc_id_base32,
  6424. replica);
  6425. }
  6426. /** send HS_DESC upload event.
  6427. *
  6428. * <b>service_id</b> is the descriptor onion address.
  6429. * <b>hs_dir</b> is the description of contacting hs directory.
  6430. * <b>desc_id_base32</b> is the ID of requested hs descriptor.
  6431. */
  6432. void
  6433. control_event_hs_descriptor_upload(const char *service_id,
  6434. const char *id_digest,
  6435. const char *desc_id_base32)
  6436. {
  6437. if (!service_id || !id_digest || !desc_id_base32) {
  6438. log_warn(LD_BUG, "Called with service_digest==%p, "
  6439. "desc_id_base32==%p, id_digest==%p", service_id,
  6440. desc_id_base32, id_digest);
  6441. return;
  6442. }
  6443. send_control_event(EVENT_HS_DESC,
  6444. "650 HS_DESC UPLOAD %s UNKNOWN %s %s\r\n",
  6445. service_id,
  6446. node_describe_longname_by_id(id_digest),
  6447. desc_id_base32);
  6448. }
  6449. /** send HS_DESC event after got response from hs directory.
  6450. *
  6451. * NOTE: this is an internal function used by following functions:
  6452. * control_event_hs_descriptor_received
  6453. * control_event_hs_descriptor_failed
  6454. *
  6455. * So do not call this function directly.
  6456. */
  6457. void
  6458. control_event_hs_descriptor_receive_end(const char *action,
  6459. const char *onion_address,
  6460. const rend_data_t *rend_data,
  6461. const char *id_digest,
  6462. const char *reason)
  6463. {
  6464. char *desc_id_field = NULL;
  6465. char *reason_field = NULL;
  6466. char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  6467. const char *desc_id = NULL;
  6468. if (!action || !rend_data || !onion_address) {
  6469. log_warn(LD_BUG, "Called with action==%p, rend_data==%p, "
  6470. "onion_address==%p", action, rend_data, onion_address);
  6471. return;
  6472. }
  6473. desc_id = get_desc_id_from_query(rend_data, id_digest);
  6474. if (desc_id != NULL) {
  6475. /* Set the descriptor ID digest to base32 so we can send it. */
  6476. base32_encode(desc_id_base32, sizeof(desc_id_base32), desc_id,
  6477. DIGEST_LEN);
  6478. /* Extra whitespace is needed before the value. */
  6479. tor_asprintf(&desc_id_field, " %s", desc_id_base32);
  6480. }
  6481. if (reason) {
  6482. tor_asprintf(&reason_field, " REASON=%s", reason);
  6483. }
  6484. send_control_event(EVENT_HS_DESC,
  6485. "650 HS_DESC %s %s %s %s%s%s\r\n",
  6486. action,
  6487. rend_hsaddress_str_or_unknown(onion_address),
  6488. rend_auth_type_to_string(
  6489. TO_REND_DATA_V2(rend_data)->auth_type),
  6490. id_digest ?
  6491. node_describe_longname_by_id(id_digest) : "UNKNOWN",
  6492. desc_id_field ? desc_id_field : "",
  6493. reason_field ? reason_field : "");
  6494. tor_free(desc_id_field);
  6495. tor_free(reason_field);
  6496. }
  6497. /** send HS_DESC event after got response from hs directory.
  6498. *
  6499. * NOTE: this is an internal function used by following functions:
  6500. * control_event_hs_descriptor_uploaded
  6501. * control_event_hs_descriptor_upload_failed
  6502. *
  6503. * So do not call this function directly.
  6504. */
  6505. void
  6506. control_event_hs_descriptor_upload_end(const char *action,
  6507. const char *onion_address,
  6508. const char *id_digest,
  6509. const char *reason)
  6510. {
  6511. char *reason_field = NULL;
  6512. if (!action || !id_digest) {
  6513. log_warn(LD_BUG, "Called with action==%p, id_digest==%p", action,
  6514. id_digest);
  6515. return;
  6516. }
  6517. if (reason) {
  6518. tor_asprintf(&reason_field, " REASON=%s", reason);
  6519. }
  6520. send_control_event(EVENT_HS_DESC,
  6521. "650 HS_DESC %s %s UNKNOWN %s%s\r\n",
  6522. action,
  6523. rend_hsaddress_str_or_unknown(onion_address),
  6524. node_describe_longname_by_id(id_digest),
  6525. reason_field ? reason_field : "");
  6526. tor_free(reason_field);
  6527. }
  6528. /** send HS_DESC RECEIVED event
  6529. *
  6530. * called when we successfully received a hidden service descriptor.
  6531. */
  6532. void
  6533. control_event_hs_descriptor_received(const char *onion_address,
  6534. const rend_data_t *rend_data,
  6535. const char *id_digest)
  6536. {
  6537. if (!rend_data || !id_digest || !onion_address) {
  6538. log_warn(LD_BUG, "Called with rend_data==%p, id_digest==%p, "
  6539. "onion_address==%p", rend_data, id_digest, onion_address);
  6540. return;
  6541. }
  6542. control_event_hs_descriptor_receive_end("RECEIVED", onion_address,
  6543. rend_data, id_digest, NULL);
  6544. }
  6545. /** send HS_DESC UPLOADED event
  6546. *
  6547. * called when we successfully uploaded a hidden service descriptor.
  6548. */
  6549. void
  6550. control_event_hs_descriptor_uploaded(const char *id_digest,
  6551. const char *onion_address)
  6552. {
  6553. if (!id_digest) {
  6554. log_warn(LD_BUG, "Called with id_digest==%p",
  6555. id_digest);
  6556. return;
  6557. }
  6558. control_event_hs_descriptor_upload_end("UPLOADED", onion_address,
  6559. id_digest, NULL);
  6560. }
  6561. /** Send HS_DESC event to inform controller that query <b>rend_data</b>
  6562. * failed to retrieve hidden service descriptor from directory identified by
  6563. * <b>id_digest</b>. If NULL, "UNKNOWN" is used. If <b>reason</b> is not NULL,
  6564. * add it to REASON= field.
  6565. */
  6566. void
  6567. control_event_hs_descriptor_failed(const rend_data_t *rend_data,
  6568. const char *id_digest,
  6569. const char *reason)
  6570. {
  6571. if (!rend_data) {
  6572. log_warn(LD_BUG, "Called with rend_data==%p", rend_data);
  6573. return;
  6574. }
  6575. control_event_hs_descriptor_receive_end("FAILED",
  6576. rend_data_get_address(rend_data),
  6577. rend_data, id_digest, reason);
  6578. }
  6579. /** Send HS_DESC_CONTENT event after completion of a successful fetch from hs
  6580. * directory. If <b>hsdir_id_digest</b> is NULL, it is replaced by "UNKNOWN".
  6581. * If <b>content</b> is NULL, it is replaced by an empty string. The
  6582. * <b>onion_address</b> or <b>desc_id</b> set to NULL will no trigger the
  6583. * control event. */
  6584. void
  6585. control_event_hs_descriptor_content(const char *onion_address,
  6586. const char *desc_id,
  6587. const char *hsdir_id_digest,
  6588. const char *content)
  6589. {
  6590. static const char *event_name = "HS_DESC_CONTENT";
  6591. char *esc_content = NULL;
  6592. if (!onion_address || !desc_id) {
  6593. log_warn(LD_BUG, "Called with onion_address==%p, desc_id==%p, ",
  6594. onion_address, desc_id);
  6595. return;
  6596. }
  6597. if (content == NULL) {
  6598. /* Point it to empty content so it can still be escaped. */
  6599. content = "";
  6600. }
  6601. write_escaped_data(content, strlen(content), &esc_content);
  6602. send_control_event(EVENT_HS_DESC_CONTENT,
  6603. "650+%s %s %s %s\r\n%s650 OK\r\n",
  6604. event_name,
  6605. rend_hsaddress_str_or_unknown(onion_address),
  6606. desc_id,
  6607. hsdir_id_digest ?
  6608. node_describe_longname_by_id(hsdir_id_digest) :
  6609. "UNKNOWN",
  6610. esc_content);
  6611. tor_free(esc_content);
  6612. }
  6613. /** Send HS_DESC event to inform controller upload of hidden service
  6614. * descriptor identified by <b>id_digest</b> failed. If <b>reason</b>
  6615. * is not NULL, add it to REASON= field.
  6616. */
  6617. void
  6618. control_event_hs_descriptor_upload_failed(const char *id_digest,
  6619. const char *onion_address,
  6620. const char *reason)
  6621. {
  6622. if (!id_digest) {
  6623. log_warn(LD_BUG, "Called with id_digest==%p",
  6624. id_digest);
  6625. return;
  6626. }
  6627. control_event_hs_descriptor_upload_end("FAILED", onion_address,
  6628. id_digest, reason);
  6629. }
  6630. /** Free any leftover allocated memory of the control.c subsystem. */
  6631. void
  6632. control_free_all(void)
  6633. {
  6634. if (authentication_cookie) /* Free the auth cookie */
  6635. tor_free(authentication_cookie);
  6636. if (detached_onion_services) { /* Free the detached onion services */
  6637. SMARTLIST_FOREACH(detached_onion_services, char *, cp, tor_free(cp));
  6638. smartlist_free(detached_onion_services);
  6639. }
  6640. if (queued_control_events) {
  6641. SMARTLIST_FOREACH(queued_control_events, queued_event_t *, ev,
  6642. queued_event_free(ev));
  6643. smartlist_free(queued_control_events);
  6644. queued_control_events = NULL;
  6645. }
  6646. if (flush_queued_events_event) {
  6647. tor_event_free(flush_queued_events_event);
  6648. flush_queued_events_event = NULL;
  6649. }
  6650. }
  6651. #ifdef TOR_UNIT_TESTS
  6652. /* For testing: change the value of global_event_mask */
  6653. void
  6654. control_testing_set_global_event_mask(uint64_t mask)
  6655. {
  6656. global_event_mask = mask;
  6657. }
  6658. #endif /* defined(TOR_UNIT_TESTS) */