control.c 214 KB

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