Virtual.c 222 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438643964406441644264436444644564466447644864496450645164526453645464556456645764586459646064616462646364646465646664676468646964706471647264736474647564766477647864796480648164826483648464856486648764886489649064916492649364946495649664976498649965006501650265036504650565066507650865096510651165126513651465156516651765186519652065216522652365246525652665276528652965306531653265336534653565366537653865396540654165426543654465456546654765486549655065516552655365546555655665576558655965606561656265636564656565666567656865696570657165726573657465756576657765786579658065816582658365846585658665876588658965906591659265936594659565966597659865996600660166026603660466056606660766086609661066116612661366146615661666176618661966206621662266236624662566266627662866296630663166326633663466356636663766386639664066416642664366446645664666476648664966506651665266536654665566566657665866596660666166626663666466656666666766686669667066716672667366746675667666776678667966806681668266836684668566866687668866896690669166926693669466956696669766986699670067016702670367046705670667076708670967106711671267136714671567166717671867196720672167226723672467256726672767286729673067316732673367346735673667376738673967406741674267436744674567466747674867496750675167526753675467556756675767586759676067616762676367646765676667676768676967706771677267736774677567766777677867796780678167826783678467856786678767886789679067916792679367946795679667976798679968006801680268036804680568066807680868096810681168126813681468156816681768186819682068216822682368246825682668276828682968306831683268336834683568366837683868396840684168426843684468456846684768486849685068516852685368546855685668576858685968606861686268636864686568666867686868696870687168726873687468756876687768786879688068816882688368846885688668876888688968906891689268936894689568966897689868996900690169026903690469056906690769086909691069116912691369146915691669176918691969206921692269236924692569266927692869296930693169326933693469356936693769386939694069416942694369446945694669476948694969506951695269536954695569566957695869596960696169626963696469656966696769686969697069716972697369746975697669776978697969806981698269836984698569866987698869896990699169926993699469956996699769986999700070017002700370047005700670077008700970107011701270137014701570167017701870197020702170227023702470257026702770287029703070317032703370347035703670377038703970407041704270437044704570467047704870497050705170527053705470557056705770587059706070617062706370647065706670677068706970707071707270737074707570767077707870797080708170827083708470857086708770887089709070917092709370947095709670977098709971007101710271037104710571067107710871097110711171127113711471157116711771187119712071217122712371247125712671277128712971307131713271337134713571367137713871397140714171427143714471457146714771487149715071517152715371547155715671577158715971607161716271637164716571667167716871697170717171727173717471757176717771787179718071817182718371847185718671877188718971907191719271937194719571967197719871997200720172027203720472057206720772087209721072117212721372147215721672177218721972207221722272237224722572267227722872297230723172327233723472357236723772387239724072417242724372447245724672477248724972507251725272537254725572567257725872597260726172627263726472657266726772687269727072717272727372747275727672777278727972807281728272837284728572867287728872897290729172927293729472957296729772987299730073017302730373047305730673077308730973107311731273137314731573167317731873197320732173227323732473257326732773287329733073317332733373347335733673377338733973407341734273437344734573467347734873497350735173527353735473557356735773587359736073617362736373647365736673677368736973707371737273737374737573767377737873797380738173827383738473857386738773887389739073917392739373947395739673977398739974007401740274037404740574067407740874097410741174127413741474157416741774187419742074217422742374247425742674277428742974307431743274337434743574367437743874397440744174427443744474457446744774487449745074517452745374547455745674577458745974607461746274637464746574667467746874697470747174727473747474757476747774787479748074817482748374847485748674877488748974907491749274937494749574967497749874997500750175027503750475057506750775087509751075117512751375147515751675177518751975207521752275237524752575267527752875297530753175327533753475357536753775387539754075417542754375447545754675477548754975507551755275537554755575567557755875597560756175627563756475657566756775687569757075717572757375747575757675777578757975807581758275837584758575867587758875897590759175927593759475957596759775987599760076017602760376047605760676077608760976107611761276137614761576167617761876197620762176227623762476257626762776287629763076317632763376347635763676377638763976407641764276437644764576467647764876497650765176527653765476557656765776587659766076617662766376647665766676677668766976707671767276737674767576767677767876797680768176827683768476857686768776887689769076917692769376947695769676977698769977007701770277037704770577067707770877097710771177127713771477157716771777187719772077217722772377247725772677277728772977307731773277337734773577367737773877397740774177427743774477457746774777487749775077517752775377547755775677577758775977607761776277637764776577667767776877697770777177727773777477757776777777787779778077817782778377847785778677877788778977907791779277937794779577967797779877997800780178027803780478057806780778087809781078117812781378147815781678177818781978207821782278237824782578267827782878297830783178327833783478357836783778387839784078417842784378447845784678477848784978507851785278537854785578567857785878597860786178627863786478657866786778687869787078717872787378747875787678777878787978807881788278837884788578867887788878897890789178927893789478957896789778987899790079017902790379047905790679077908790979107911791279137914791579167917791879197920792179227923792479257926792779287929793079317932793379347935793679377938793979407941794279437944794579467947794879497950795179527953795479557956795779587959796079617962796379647965796679677968796979707971797279737974797579767977797879797980798179827983798479857986798779887989799079917992799379947995799679977998799980008001800280038004800580068007800880098010801180128013801480158016801780188019802080218022802380248025802680278028802980308031803280338034803580368037803880398040804180428043804480458046804780488049805080518052805380548055805680578058805980608061806280638064806580668067806880698070807180728073807480758076807780788079808080818082808380848085808680878088808980908091809280938094809580968097809880998100810181028103810481058106810781088109811081118112811381148115811681178118811981208121812281238124812581268127812881298130813181328133813481358136813781388139814081418142814381448145814681478148814981508151815281538154815581568157815881598160816181628163816481658166816781688169817081718172817381748175817681778178817981808181818281838184818581868187818881898190819181928193819481958196819781988199820082018202820382048205820682078208820982108211821282138214821582168217821882198220822182228223822482258226822782288229823082318232823382348235823682378238823982408241824282438244824582468247824882498250825182528253825482558256825782588259826082618262826382648265826682678268826982708271827282738274827582768277827882798280828182828283828482858286828782888289829082918292829382948295829682978298829983008301830283038304830583068307830883098310831183128313831483158316831783188319832083218322832383248325832683278328832983308331833283338334833583368337833883398340834183428343834483458346834783488349835083518352835383548355835683578358835983608361836283638364836583668367836883698370837183728373837483758376837783788379838083818382838383848385838683878388838983908391839283938394839583968397839883998400840184028403840484058406840784088409841084118412841384148415841684178418841984208421842284238424842584268427842884298430843184328433843484358436843784388439844084418442844384448445844684478448844984508451845284538454845584568457845884598460846184628463846484658466846784688469847084718472847384748475847684778478847984808481848284838484848584868487848884898490849184928493849484958496849784988499850085018502850385048505850685078508850985108511851285138514851585168517851885198520852185228523852485258526852785288529853085318532853385348535853685378538853985408541854285438544854585468547854885498550855185528553855485558556855785588559856085618562856385648565856685678568856985708571857285738574857585768577857885798580858185828583858485858586858785888589859085918592859385948595859685978598859986008601860286038604860586068607860886098610861186128613861486158616861786188619862086218622862386248625862686278628862986308631863286338634863586368637863886398640864186428643864486458646864786488649865086518652865386548655865686578658865986608661866286638664866586668667866886698670867186728673867486758676867786788679868086818682868386848685868686878688868986908691869286938694869586968697869886998700870187028703870487058706870787088709871087118712871387148715871687178718871987208721872287238724872587268727872887298730873187328733873487358736873787388739874087418742874387448745874687478748874987508751875287538754875587568757875887598760876187628763876487658766876787688769877087718772877387748775877687778778877987808781878287838784878587868787878887898790879187928793879487958796879787988799880088018802880388048805880688078808880988108811881288138814881588168817881888198820882188228823882488258826882788288829883088318832883388348835883688378838883988408841884288438844884588468847884888498850885188528853885488558856885788588859886088618862886388648865886688678868886988708871887288738874887588768877887888798880888188828883888488858886888788888889889088918892889388948895889688978898889989008901890289038904890589068907890889098910891189128913891489158916891789188919892089218922892389248925892689278928892989308931893289338934893589368937893889398940894189428943894489458946894789488949895089518952895389548955895689578958895989608961896289638964896589668967896889698970897189728973897489758976897789788979898089818982898389848985898689878988898989908991899289938994899589968997899889999000900190029003900490059006900790089009901090119012901390149015901690179018901990209021902290239024902590269027902890299030903190329033903490359036903790389039904090419042904390449045904690479048904990509051905290539054905590569057905890599060906190629063906490659066906790689069907090719072907390749075907690779078907990809081908290839084908590869087908890899090909190929093909490959096909790989099910091019102910391049105910691079108910991109111911291139114911591169117911891199120912191229123912491259126912791289129913091319132913391349135913691379138913991409141914291439144914591469147914891499150915191529153915491559156915791589159916091619162916391649165916691679168916991709171917291739174917591769177917891799180918191829183918491859186918791889189919091919192919391949195919691979198919992009201920292039204920592069207920892099210921192129213921492159216921792189219922092219222922392249225922692279228922992309231923292339234923592369237923892399240924192429243924492459246924792489249925092519252925392549255925692579258925992609261926292639264926592669267926892699270927192729273927492759276927792789279928092819282928392849285928692879288928992909291929292939294929592969297929892999300930193029303930493059306930793089309931093119312931393149315931693179318931993209321932293239324932593269327932893299330933193329333933493359336933793389339934093419342934393449345934693479348934993509351935293539354935593569357935893599360936193629363936493659366936793689369937093719372937393749375937693779378937993809381938293839384938593869387938893899390939193929393939493959396939793989399940094019402940394049405940694079408940994109411941294139414941594169417941894199420942194229423942494259426942794289429943094319432943394349435943694379438943994409441944294439444944594469447944894499450945194529453945494559456945794589459946094619462946394649465946694679468946994709471947294739474947594769477947894799480948194829483948494859486948794889489949094919492949394949495949694979498949995009501950295039504950595069507950895099510951195129513951495159516951795189519952095219522952395249525952695279528952995309531953295339534953595369537953895399540954195429543954495459546954795489549955095519552955395549555955695579558955995609561956295639564956595669567956895699570957195729573957495759576957795789579958095819582958395849585958695879588958995909591959295939594959595969597959895999600960196029603960496059606960796089609961096119612961396149615961696179618961996209621962296239624962596269627962896299630963196329633963496359636963796389639964096419642964396449645964696479648964996509651965296539654965596569657965896599660966196629663966496659666966796689669967096719672967396749675967696779678967996809681968296839684968596869687968896899690969196929693969496959696969796989699970097019702970397049705970697079708970997109711971297139714971597169717971897199720972197229723972497259726972797289729973097319732973397349735973697379738973997409741974297439744974597469747974897499750975197529753975497559756975797589759976097619762976397649765976697679768976997709771977297739774977597769777977897799780978197829783978497859786978797889789979097919792979397949795979697979798979998009801980298039804980598069807980898099810981198129813981498159816981798189819982098219822982398249825982698279828982998309831983298339834983598369837983898399840984198429843984498459846984798489849985098519852985398549855985698579858985998609861986298639864986598669867986898699870987198729873987498759876987798789879988098819882988398849885988698879888988998909891989298939894989598969897989898999900990199029903990499059906990799089909991099119912991399149915991699179918991999209921992299239924992599269927992899299930993199329933993499359936993799389939994099419942994399449945994699479948994999509951995299539954995599569957995899599960996199629963996499659966996799689969997099719972997399749975997699779978997999809981998299839984998599869987998899899990999199929993999499959996999799989999100001000110002100031000410005100061000710008100091001010011100121001310014100151001610017100181001910020100211002210023100241002510026100271002810029100301003110032100331003410035100361003710038100391004010041100421004310044100451004610047100481004910050100511005210053100541005510056100571005810059100601006110062100631006410065100661006710068100691007010071100721007310074100751007610077100781007910080100811008210083100841008510086100871008810089100901009110092100931009410095100961009710098100991010010101101021010310104101051010610107101081010910110101111011210113101141011510116101171011810119101201012110122101231012410125101261012710128101291013010131101321013310134101351013610137101381013910140101411014210143101441014510146101471014810149101501015110152101531015410155101561015710158101591016010161101621016310164101651016610167101681016910170101711017210173101741017510176101771017810179101801018110182101831018410185101861018710188101891019010191101921019310194101951019610197101981019910200102011020210203102041020510206102071020810209102101021110212102131021410215102161021710218102191022010221102221022310224102251022610227
  1. // SoftEther VPN Source Code
  2. // Cedar Communication Module
  3. //
  4. // SoftEther VPN Server, Client and Bridge are free software under GPLv2.
  5. //
  6. // Copyright (c) 2012-2014 Daiyuu Nobori.
  7. // Copyright (c) 2012-2014 SoftEther VPN Project, University of Tsukuba, Japan.
  8. // Copyright (c) 2012-2014 SoftEther Corporation.
  9. //
  10. // All Rights Reserved.
  11. //
  12. // http://www.softether.org/
  13. //
  14. // Author: Daiyuu Nobori
  15. // Comments: Tetsuo Sugiyama, Ph.D.
  16. //
  17. // This program is free software; you can redistribute it and/or
  18. // modify it under the terms of the GNU General Public License
  19. // version 2 as published by the Free Software Foundation.
  20. //
  21. // This program is distributed in the hope that it will be useful,
  22. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  23. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  24. // GNU General Public License for more details.
  25. //
  26. // You should have received a copy of the GNU General Public License version 2
  27. // along with this program; if not, write to the Free Software
  28. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  29. //
  30. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  31. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  32. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  33. // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  34. // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  35. // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  36. // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  37. //
  38. // THE LICENSE AGREEMENT IS ATTACHED ON THE SOURCE-CODE PACKAGE
  39. // AS "LICENSE.TXT" FILE. READ THE TEXT FILE IN ADVANCE TO USE THE SOFTWARE.
  40. //
  41. //
  42. // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN,
  43. // UNDER JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY,
  44. // MERGE, PUBLISH, DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS
  45. // SOFTWARE, THAT ANY JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS
  46. // SOFTWARE OR ITS CONTENTS, AGAINST US (SOFTETHER PROJECT, SOFTETHER
  47. // CORPORATION, DAIYUU NOBORI OR OTHER SUPPLIERS), OR ANY JURIDICAL
  48. // DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND OF USING, COPYING,
  49. // MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, AND/OR
  50. // SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
  51. // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO
  52. // EXCLUSIVE JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO,
  53. // JAPAN. YOU MUST WAIVE ALL DEFENSES OF LACK OF PERSONAL JURISDICTION
  54. // AND FORUM NON CONVENIENS. PROCESS MAY BE SERVED ON EITHER PARTY IN
  55. // THE MANNER AUTHORIZED BY APPLICABLE LAW OR COURT RULE.
  56. //
  57. // USE ONLY IN JAPAN. DO NOT USE IT IN OTHER COUNTRIES. IMPORTING THIS
  58. // SOFTWARE INTO OTHER COUNTRIES IS AT YOUR OWN RISK. SOME COUNTRIES
  59. // PROHIBIT ENCRYPTED COMMUNICATIONS. USING THIS SOFTWARE IN OTHER
  60. // COUNTRIES MIGHT BE RESTRICTED.
  61. //
  62. //
  63. // SOURCE CODE CONTRIBUTION
  64. // ------------------------
  65. //
  66. // Your contribution to SoftEther VPN Project is much appreciated.
  67. // Please send patches to us through GitHub.
  68. // Read the SoftEther VPN Patch Acceptance Policy in advance:
  69. // http://www.softether.org/5-download/src/9.patch
  70. //
  71. //
  72. // DEAR SECURITY EXPERTS
  73. // ---------------------
  74. //
  75. // If you find a bug or a security vulnerability please kindly inform us
  76. // about the problem immediately so that we can fix the security problem
  77. // to protect a lot of users around the world as soon as possible.
  78. //
  79. // Our e-mail address for security reports is:
  80. // softether-vpn-security [at] softether.org
  81. //
  82. // Please note that the above e-mail address is not a technical support
  83. // inquiry address. If you need technical assistance, please visit
  84. // http://www.softether.org/ and ask your question on the users forum.
  85. //
  86. // Thank you for your cooperation.
  87. //
  88. //
  89. // NO MEMORY OR RESOURCE LEAKS
  90. // ---------------------------
  91. //
  92. // The memory-leaks and resource-leaks verification under the stress
  93. // test has been passed before release this source code.
  94. // Virtual.c
  95. // User-mode virtual host program
  96. #include "CedarPch.h"
  97. static UCHAR broadcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  98. static char v_vgs_hostname[256] = {0};
  99. static char secure_nat_target_hostname[MAX_SIZE] = {0};
  100. // Specify the destination host name to be used for connectivity testing in SecureNAT
  101. void NnSetSecureNatTargetHostname(char *name)
  102. {
  103. // Validate arguments
  104. if (name == NULL)
  105. {
  106. return;
  107. }
  108. StrCpy(secure_nat_target_hostname, sizeof(secure_nat_target_hostname), name);
  109. }
  110. // Delete the oldest NAT session if necessary
  111. void NnDeleteOldestNatSessionIfNecessary(NATIVE_NAT *t, UINT ip, UINT protocol)
  112. {
  113. UINT current_num;
  114. UINT max_sessions = 0;
  115. // Validate arguments
  116. if (t == NULL)
  117. {
  118. return;
  119. }
  120. if (t->v->HubOption != NULL)
  121. {
  122. HUB_OPTION *o = t->v->HubOption;
  123. switch (protocol)
  124. {
  125. case NAT_TCP:
  126. max_sessions = o->SecureNAT_MaxTcpSessionsPerIp;
  127. break;
  128. case NAT_UDP:
  129. max_sessions = o->SecureNAT_MaxUdpSessionsPerIp;
  130. break;
  131. case NAT_ICMP:
  132. max_sessions = o->SecureNAT_MaxIcmpSessionsPerIp;
  133. break;
  134. }
  135. }
  136. if (max_sessions == 0)
  137. {
  138. return;
  139. }
  140. current_num = NnGetNumNatEntriesPerIp(t, ip, protocol);
  141. if (current_num >= max_sessions)
  142. {
  143. NnDeleteOldestNatSession(t, ip, protocol);
  144. }
  145. }
  146. // Delete the oldest NAT session
  147. void NnDeleteOldestNatSession(NATIVE_NAT *t, UINT ip, UINT protocol)
  148. {
  149. NATIVE_NAT_ENTRY *e;
  150. // Validate arguments
  151. if (t == NULL)
  152. {
  153. return;
  154. }
  155. e = NnGetOldestNatEntryOfIp(t, ip, protocol);
  156. if (e != NULL)
  157. {
  158. NnDeleteSession(t, e);
  159. }
  160. }
  161. // Get the oldest NAT session
  162. NATIVE_NAT_ENTRY *NnGetOldestNatEntryOfIp(NATIVE_NAT *t, UINT ip, UINT protocol)
  163. {
  164. UINT i;
  165. NATIVE_NAT_ENTRY *oldest = NULL;
  166. UINT64 oldest_tick = 0xFFFFFFFFFFFFFFFFULL;
  167. // Validate arguments
  168. if (t == NULL)
  169. {
  170. return NULL;
  171. }
  172. for (i = 0;i < LIST_NUM(t->NatTableForRecv->AllList);i++)
  173. {
  174. NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForRecv->AllList, i);
  175. if (e->SrcIp == ip)
  176. {
  177. if (e->Protocol == protocol)
  178. {
  179. if (e->LastCommTime <= oldest_tick)
  180. {
  181. oldest_tick = e->LastCommTime;
  182. oldest = e;
  183. }
  184. }
  185. }
  186. }
  187. return oldest;
  188. }
  189. // Get the number of NAT sessions per IP address
  190. UINT NnGetNumNatEntriesPerIp(NATIVE_NAT *t, UINT src_ip, UINT protocol)
  191. {
  192. UINT ret = 0;
  193. UINT i;
  194. // Validate arguments
  195. if (t == NULL)
  196. {
  197. return 0;
  198. }
  199. for (i = 0;i < LIST_NUM(t->NatTableForRecv->AllList);i++)
  200. {
  201. NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForRecv->AllList, i);
  202. if (e->SrcIp == src_ip)
  203. {
  204. if (e->Protocol == protocol)
  205. {
  206. ret++;
  207. }
  208. }
  209. }
  210. return ret;
  211. }
  212. // Delete the old NAT sessions
  213. void NnDeleteOldSessions(NATIVE_NAT *t)
  214. {
  215. UINT i;
  216. LIST *o;
  217. UINT64 now;
  218. // Validate arguments
  219. if (t == NULL)
  220. {
  221. return;
  222. }
  223. o = NULL;
  224. now = t->v->Now;
  225. for (i = 0;i < LIST_NUM(t->NatTableForSend->AllList);i++)
  226. {
  227. NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForSend->AllList, i);
  228. UINT64 timeout;
  229. if (e->Status == NAT_TCP_CONNECTED || e->Status == NAT_TCP_ESTABLISHED)
  230. {
  231. timeout = e->LastCommTime + (UINT64)(e->Protocol == NAT_TCP ? t->v->NatTcpTimeout : t->v->NatUdpTimeout);
  232. }
  233. else
  234. {
  235. timeout = e->LastCommTime + (UINT64)NN_TIMEOUT_FOR_UNESTBALISHED_TCP;
  236. }
  237. if (timeout < now)
  238. {
  239. // Time-out occurs
  240. if (o == NULL)
  241. {
  242. o = NewListFast(NULL);
  243. }
  244. Add(o, e);
  245. }
  246. }
  247. if (o != NULL)
  248. {
  249. for (i = 0;i < LIST_NUM(o);i++)
  250. {
  251. NATIVE_NAT_ENTRY *e = LIST_DATA(o, i);
  252. NnDeleteSession(t, e);
  253. }
  254. ReleaseList(o);
  255. }
  256. }
  257. // Delete the NAT entry
  258. void NnDeleteSession(NATIVE_NAT *t, NATIVE_NAT_ENTRY *e)
  259. {
  260. // Validate arguments
  261. if (t == NULL || e == NULL)
  262. {
  263. return;
  264. }
  265. switch (e->Protocol)
  266. {
  267. case NAT_TCP:
  268. // Send a RST to the client side
  269. SendTcp(t->v, e->DestIp, e->DestPort, e->SrcIp, e->SrcPort,
  270. e->LastAck, e->LastSeq + (e->Status == NAT_TCP_CONNECTING ? 1 : 0), TCP_RST | TCP_ACK, 0, 0, NULL, 0);
  271. NLog(t->v, "LH_NAT_TCP_DELETED", e->Id);
  272. break;
  273. case NAT_UDP:
  274. NLog(t->v, "LH_NAT_UDP_DELETED", e->Id);
  275. break;
  276. case NAT_ICMP:
  277. Debug("NAT ICMP %u Deleted.", e->Id);
  278. break;
  279. }
  280. DeleteHash(t->NatTableForSend, e);
  281. DeleteHash(t->NatTableForRecv, e);
  282. Free(e);
  283. }
  284. // Poll the IP combining object
  285. void NnPollingIpCombine(NATIVE_NAT *t)
  286. {
  287. LIST *o;
  288. UINT i;
  289. // Validate arguments
  290. if (t == NULL)
  291. {
  292. return;
  293. }
  294. // Discard the old combining object
  295. o = NULL;
  296. for (i = 0;i < LIST_NUM(t->IpCombine);i++)
  297. {
  298. IP_COMBINE *c = LIST_DATA(t->IpCombine, i);
  299. if (c->Expire < t->v->Now)
  300. {
  301. if (o == NULL)
  302. {
  303. o = NewListFast(NULL);
  304. }
  305. Add(o, c);
  306. }
  307. }
  308. if (o != NULL)
  309. {
  310. for (i = 0;i < LIST_NUM(o);i++)
  311. {
  312. IP_COMBINE *c = LIST_DATA(o, i);
  313. // Remove from the list
  314. Delete(t->IpCombine, c);
  315. // Release the memory
  316. NnFreeIpCombine(t, c);
  317. }
  318. ReleaseList(o);
  319. }
  320. }
  321. // Combine the IP packet received to the IP combining object
  322. void NnCombineIp(NATIVE_NAT *t, IP_COMBINE *c, UINT offset, void *data, UINT size, bool last_packet, UCHAR *head_ip_header_data, UINT head_ip_header_size)
  323. {
  324. UINT i;
  325. IP_PART *p;
  326. UINT need_size;
  327. UINT data_size_delta;
  328. // Validate arguments
  329. if (c == NULL || data == NULL)
  330. {
  331. return;
  332. }
  333. // Check the size and offset
  334. if ((offset + size) > 65535)
  335. {
  336. // Do not process a packet larger than 64Kbytes
  337. return;
  338. }
  339. if (last_packet == false && c->Size != 0)
  340. {
  341. if ((offset + size) > c->Size)
  342. {
  343. // Do not process a packet larger than the packet size
  344. return;
  345. }
  346. }
  347. if (head_ip_header_data != NULL && head_ip_header_size >= sizeof(IPV4_HEADER))
  348. {
  349. if (c->HeadIpHeaderData == NULL)
  350. {
  351. c->HeadIpHeaderData = Clone(head_ip_header_data, head_ip_header_size);
  352. c->HeadIpHeaderDataSize = head_ip_header_size;
  353. }
  354. }
  355. need_size = offset + size;
  356. data_size_delta = c->DataReserved;
  357. // Ensure sufficient if the buffer is insufficient
  358. while (c->DataReserved < need_size)
  359. {
  360. c->DataReserved = c->DataReserved * 4;
  361. c->Data = ReAlloc(c->Data, c->DataReserved);
  362. }
  363. data_size_delta = c->DataReserved - data_size_delta;
  364. t->CurrentIpQuota += data_size_delta;
  365. // Overwrite the data into the buffer
  366. Copy(((UCHAR *)c->Data) + offset, data, size);
  367. if (last_packet)
  368. {
  369. // If No More Flagment packet arrives, the size of this datagram is finalized
  370. c->Size = offset + size;
  371. }
  372. // Check the overlap between the region which is represented by the offset and size of the
  373. // existing received list and the region which is represented by the offset and size
  374. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  375. {
  376. UINT moving_size;
  377. IP_PART *p = LIST_DATA(c->IpParts, i);
  378. // Check the overlapping between the existing area and head area
  379. if ((p->Offset <= offset) && ((p->Offset + p->Size) > offset))
  380. {
  381. // Compress behind the offset of this packet since a duplication is
  382. // found in the first part with the existing packet and this packet
  383. if ((offset + size) <= (p->Offset + p->Size))
  384. {
  385. // This packet is buried in the existing packet
  386. size = 0;
  387. }
  388. else
  389. {
  390. // Retral region is not overlapped
  391. moving_size = p->Offset + p->Size - offset;
  392. offset += moving_size;
  393. size -= moving_size;
  394. }
  395. }
  396. if ((p->Offset < (offset + size)) && ((p->Offset + p->Size) >= (offset + size)))
  397. {
  398. // Compress the size of this packet forward because a duplication is
  399. // found between the posterior portion the existing packet and this packet
  400. moving_size = p->Offset + p->Size - offset - size;
  401. size -= moving_size;
  402. }
  403. if ((p->Offset >= offset) && ((p->Offset + p->Size) <= (offset + size)))
  404. {
  405. // This packet was overwritten to completely hunched over a existing packet
  406. p->Size = 0;
  407. }
  408. }
  409. if (size != 0)
  410. {
  411. // Register this packet
  412. p = ZeroMalloc(sizeof(IP_PART));
  413. p->Offset = offset;
  414. p->Size = size;
  415. Add(c->IpParts, p);
  416. }
  417. if (c->Size != 0)
  418. {
  419. // Get the total size of the data portion list already received
  420. UINT total_size = 0;
  421. UINT i;
  422. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  423. {
  424. IP_PART *p = LIST_DATA(c->IpParts, i);
  425. total_size += p->Size;
  426. }
  427. if (total_size == c->Size)
  428. {
  429. // Received whole of the IP packet
  430. NnIpReceived(t, c->SrcIP, c->DestIP, c->Protocol, c->Data, c->Size, c->Ttl,
  431. c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->MaxL3Size);
  432. // Release the combining object
  433. NnFreeIpCombine(t, c);
  434. // Remove from the combining object list
  435. Delete(t->IpCombine, c);
  436. }
  437. }
  438. }
  439. // Release the IP combining object
  440. void NnFreeIpCombine(NATIVE_NAT *t, IP_COMBINE *c)
  441. {
  442. UINT i;
  443. // Validate arguments
  444. if (c == NULL)
  445. {
  446. return;
  447. }
  448. // Release the data
  449. t->CurrentIpQuota -= c->DataReserved;
  450. Free(c->Data);
  451. // Release the partial list
  452. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  453. {
  454. IP_PART *p = LIST_DATA(c->IpParts, i);
  455. Free(p);
  456. }
  457. Free(c->HeadIpHeaderData);
  458. ReleaseList(c->IpParts);
  459. Free(c);
  460. }
  461. // Search the IP combining list
  462. IP_COMBINE *NnSearchIpCombine(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, USHORT id, UCHAR protocol)
  463. {
  464. IP_COMBINE *c, tt;
  465. // Validate arguments
  466. if (t == NULL)
  467. {
  468. return NULL;
  469. }
  470. tt.DestIP = dest_ip;
  471. tt.SrcIP = src_ip;
  472. tt.Id = id;
  473. tt.Protocol = protocol;
  474. c = Search(t->IpCombine, &tt);
  475. return c;
  476. }
  477. // Insert by creating a new object to the IP combining list
  478. IP_COMBINE *NnInsertIpCombine(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, USHORT id, UCHAR protocol, bool mac_broadcast, UCHAR ttl, bool src_is_localmac)
  479. {
  480. IP_COMBINE *c;
  481. // Validate arguments
  482. if (t == NULL)
  483. {
  484. return NULL;
  485. }
  486. // Examine the quota
  487. if ((t->CurrentIpQuota + IP_COMBINE_INITIAL_BUF_SIZE) > IP_COMBINE_WAIT_QUEUE_SIZE_QUOTA)
  488. {
  489. // IP packet can not be stored any more
  490. return NULL;
  491. }
  492. c = ZeroMalloc(sizeof(IP_COMBINE));
  493. c->SrcIsLocalMacAddr = src_is_localmac;
  494. c->DestIP = dest_ip;
  495. c->SrcIP = src_ip;
  496. c->Id = id;
  497. c->Expire = t->v->Now + (UINT64)IP_COMBINE_TIMEOUT;
  498. c->Size = 0;
  499. c->IpParts = NewList(NULL);
  500. c->Protocol = protocol;
  501. c->MacBroadcast = mac_broadcast;
  502. c->Ttl = ttl;
  503. // Secure the memory
  504. c->DataReserved = IP_COMBINE_INITIAL_BUF_SIZE;
  505. c->Data = Malloc(c->DataReserved);
  506. t->CurrentIpQuota += c->DataReserved;
  507. Insert(t->IpCombine, c);
  508. return c;
  509. }
  510. // Initialize the IP combining list
  511. void NnInitIpCombineList(NATIVE_NAT *t)
  512. {
  513. // Validate arguments
  514. if (t == NULL)
  515. {
  516. return;
  517. }
  518. t->IpCombine = NewList(CompareIpCombine);
  519. }
  520. // Release the IP combining list
  521. void NnFreeIpCombineList(NATIVE_NAT *t)
  522. {
  523. UINT i;
  524. // Validate arguments
  525. if (t == NULL)
  526. {
  527. return;
  528. }
  529. for (i = 0;i < LIST_NUM(t->IpCombine);i++)
  530. {
  531. IP_COMBINE *c = LIST_DATA(t->IpCombine, i);
  532. NnFreeIpCombine(t, c);
  533. }
  534. ReleaseList(t->IpCombine);
  535. }
  536. // A TCP packet is received
  537. void NnTcpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT size, UCHAR ttl, UINT max_l3_size)
  538. {
  539. TCP_HEADER *tcp;
  540. UCHAR *payload;
  541. UINT payload_size;
  542. UINT tcp_header_size;
  543. // Validate arguments
  544. if (t == NULL || data == NULL)
  545. {
  546. return;
  547. }
  548. // TCP header
  549. if (size < sizeof(TCP_HEADER))
  550. {
  551. return;
  552. }
  553. tcp = (TCP_HEADER *)data;
  554. // Get the TCP header size
  555. tcp_header_size = TCP_GET_HEADER_SIZE(tcp) * 4;
  556. if (size < tcp_header_size || tcp_header_size < sizeof(TCP_HEADER))
  557. {
  558. return;
  559. }
  560. // Payload
  561. payload = ((UCHAR *)data) + tcp_header_size;
  562. payload_size = size - tcp_header_size;
  563. // Search the port from the NAT table
  564. if (true)
  565. {
  566. NATIVE_NAT_ENTRY tt;
  567. NATIVE_NAT_ENTRY *e;
  568. NnSetNat(&tt, NAT_TCP, 0, 0, src_ip, Endian16(tcp->SrcPort), dest_ip, Endian16(tcp->DstPort));
  569. e = SearchHash(t->NatTableForRecv, &tt);
  570. if (e != NULL)
  571. {
  572. // Last communication time
  573. e->LastCommTime = t->v->Now;
  574. e->TotalRecv += (UINT64)size;
  575. // Rewrite the TCP header
  576. tcp->Checksum = 0;
  577. tcp->DstPort = Endian16(e->SrcPort);
  578. if (tcp->Flag & TCP_FIN || tcp->Flag & TCP_RST)
  579. {
  580. // Disconnect
  581. e->Status = NAT_TCP_WAIT_DISCONNECT;
  582. }
  583. if (tcp->Flag & TCP_SYN && tcp->Flag & TCP_ACK)
  584. {
  585. // Connection complete
  586. if (e->Status != NAT_TCP_WAIT_DISCONNECT)
  587. {
  588. e->Status = NAT_TCP_ESTABLISHED;
  589. }
  590. }
  591. e->LastSeq = Endian32(tcp->AckNumber);
  592. e->LastAck = Endian32(tcp->SeqNumber);
  593. // Checksum recalculation
  594. tcp->Checksum = CalcChecksumForIPv4(src_ip, e->SrcIp, IP_PROTO_TCP, tcp, size, 0);
  595. // IP transmission
  596. SendIp(t->v, e->SrcIp, src_ip, IP_PROTO_TCP, tcp, size);
  597. }
  598. }
  599. }
  600. // An ICMP packet has been received
  601. void NnIcmpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT size, UCHAR ttl, UINT max_l3_size)
  602. {
  603. ICMP_HEADER *icmp;
  604. // Validate arguments
  605. if (t == NULL || data == NULL)
  606. {
  607. return;
  608. }
  609. if (ttl == 0)
  610. {
  611. ttl = 1;
  612. }
  613. // ICMP header
  614. if (size < sizeof(ICMP_HEADER))
  615. {
  616. return;
  617. }
  618. icmp = (ICMP_HEADER *)data;
  619. if (icmp->Type == ICMP_TYPE_ECHO_RESPONSE)
  620. {
  621. UCHAR *payload;
  622. UINT payload_size;
  623. ICMP_ECHO *echo;
  624. NATIVE_NAT_ENTRY tt, *e;
  625. // Echo Response
  626. echo = (ICMP_ECHO *)(((UCHAR *)data) + sizeof(ICMP_HEADER));
  627. if (size < (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  628. {
  629. return;
  630. }
  631. payload = ((UCHAR *)data) + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO);
  632. payload_size = size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  633. // Search the NAT
  634. NnSetNat(&tt, NAT_ICMP, 0, 0, 0, 0, dest_ip, Endian16(echo->Identifier));
  635. e = SearchHash(t->NatTableForRecv, &tt);
  636. if (e != NULL)
  637. {
  638. // Rewrite the header
  639. icmp->Checksum = 0;
  640. echo->Identifier = Endian16(e->SrcPort);
  641. icmp->Checksum = IpChecksum(icmp, size);
  642. e->LastCommTime = t->v->Now;
  643. e->TotalRecv += (UINT64)size;
  644. // Transmission
  645. SendIpEx(t->v, e->SrcIp, src_ip, IP_PROTO_ICMPV4, icmp, size, MAX(ttl - 1, 1));
  646. }
  647. }
  648. else if (icmp->Type == ICMP_TYPE_ECHO_REQUEST)
  649. {
  650. UCHAR *payload;
  651. UINT payload_size;
  652. ICMP_ECHO *echo;
  653. // Echo Response
  654. echo = (ICMP_ECHO *)(((UCHAR *)data) + sizeof(ICMP_HEADER));
  655. if (size < (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  656. {
  657. return;
  658. }
  659. payload = ((UCHAR *)data) + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO);
  660. payload_size = size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  661. if (dest_ip == t->PublicIP)
  662. {
  663. // Respond as soon as the Echo Request is received at the public side interface
  664. ICMP_HEADER *ret_icmp;
  665. ICMP_ECHO *ret_echo;
  666. UINT ret_size = sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + payload_size;
  667. ret_icmp = ZeroMalloc(ret_size);
  668. ret_echo = (ICMP_ECHO *)(((UCHAR *)ret_icmp) + sizeof(ICMP_HEADER));
  669. ret_icmp->Type = ICMP_TYPE_ECHO_RESPONSE;
  670. ret_icmp->Code = icmp->Code;
  671. ret_echo->Identifier = echo->Identifier;
  672. ret_echo->SeqNo = echo->SeqNo;
  673. Copy((UCHAR *)ret_icmp + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO),
  674. payload, payload_size);
  675. ret_icmp->Checksum = IpChecksum(ret_icmp, ret_size);
  676. NnIpSendForInternet(t, IP_PROTO_ICMPV4, 0, dest_ip, src_ip, ret_icmp, ret_size, max_l3_size);
  677. Free(ret_icmp);
  678. }
  679. }
  680. else
  681. {
  682. if (icmp->Type == ICMP_TYPE_DESTINATION_UNREACHABLE || icmp->Type == ICMP_TYPE_TIME_EXCEEDED)
  683. {
  684. // Rewrite the Src IP of the IPv4 header of the ICMP response packet
  685. if (size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + sizeof(IPV4_HEADER)))
  686. {
  687. IPV4_HEADER *orig_ipv4 = (IPV4_HEADER *)(((UCHAR *)data) + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  688. UINT orig_ipv4_size = size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  689. UINT orig_ipv4_header_size = GetIpHeaderSize((UCHAR *)orig_ipv4, orig_ipv4_size);
  690. if (orig_ipv4_header_size >= sizeof(IPV4_HEADER) && orig_ipv4_size >= orig_ipv4_header_size)
  691. {
  692. if (orig_ipv4->Protocol == IP_PROTO_ICMPV4)
  693. {
  694. // Search the inner ICMP header
  695. UINT inner_icmp_size = orig_ipv4_size - orig_ipv4_header_size;
  696. if (inner_icmp_size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  697. {
  698. ICMP_HEADER *inner_icmp = (ICMP_HEADER *)(((UCHAR *)data) +
  699. sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + orig_ipv4_header_size);
  700. if (inner_icmp->Type == ICMP_TYPE_ECHO_REQUEST)
  701. {
  702. ICMP_ECHO *inner_echo = (ICMP_ECHO *)(((UCHAR *)inner_icmp) + sizeof(ICMP_HEADER));
  703. NATIVE_NAT_ENTRY tt, *e;
  704. // Search for the existing NAT table entry
  705. NnSetNat(&tt, NAT_ICMP, 0, 0, 0, 0, orig_ipv4->SrcIP, Endian16(inner_echo->Identifier));
  706. e = SearchHash(t->NatTableForRecv, &tt);
  707. if (e != NULL)
  708. {
  709. e->LastCommTime = t->v->Now;
  710. // Rewrite the inner IP packet and the ICMP header according to the NAT table
  711. inner_echo->Identifier = Endian16(e->SrcPort);
  712. inner_icmp->Checksum = 0;
  713. orig_ipv4->SrcIP = e->SrcIp;
  714. orig_ipv4->Checksum = 0;
  715. orig_ipv4->Checksum = IpChecksum(orig_ipv4, orig_ipv4_header_size);
  716. // Rewrite the outer ICMP header
  717. if (true)
  718. {
  719. UCHAR *payload;
  720. UINT payload_size;
  721. ICMP_ECHO *echo;
  722. // Echo Response
  723. echo = (ICMP_ECHO *)(((UCHAR *)data) + sizeof(ICMP_HEADER));
  724. if (size < (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  725. {
  726. return;
  727. }
  728. payload = ((UCHAR *)data) + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO);
  729. payload_size = size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  730. // Rewrite the header
  731. icmp->Checksum = 0;
  732. echo->Identifier = Endian16(e->SrcPort);
  733. icmp->Checksum = IpChecksum(icmp, size);
  734. // Transmission
  735. SendIpEx(t->v, e->SrcIp, src_ip, IP_PROTO_ICMPV4, icmp, size, MAX(ttl - 1, 1));
  736. }
  737. }
  738. }
  739. }
  740. }
  741. }
  742. }
  743. }
  744. }
  745. }
  746. // An UDP packet has been received
  747. void NnUdpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT size, UCHAR ttl, UINT max_l3_size)
  748. {
  749. UDP_HEADER *udp;
  750. UCHAR *payload;
  751. UINT payload_size;
  752. // Validate arguments
  753. if (t == NULL || data == NULL)
  754. {
  755. return;
  756. }
  757. // UDP header
  758. if (size <= sizeof(UDP_HEADER))
  759. {
  760. return;
  761. }
  762. udp = (UDP_HEADER *)data;
  763. // Payload
  764. payload = ((UCHAR *)data) + sizeof(UDP_HEADER);
  765. payload_size = size - sizeof(UDP_HEADER);
  766. // Inspect the payload size
  767. if (payload_size < (Endian16(udp->PacketLength) - sizeof(UDP_HEADER)))
  768. {
  769. return;
  770. }
  771. // Truncate the payload
  772. payload_size = Endian16(udp->PacketLength) - sizeof(UDP_HEADER);
  773. // Search the port number from the NAT table
  774. if (true)
  775. {
  776. NATIVE_NAT_ENTRY tt;
  777. NATIVE_NAT_ENTRY *e;
  778. NnSetNat(&tt, NAT_UDP, 0, 0, 0, 0, dest_ip, Endian16(udp->DstPort));
  779. e = SearchHash(t->NatTableForRecv, &tt);
  780. if (e != NULL)
  781. {
  782. // Last communication time
  783. e->LastCommTime = t->v->Now;
  784. e->TotalRecv += (UINT64)payload_size;
  785. // Deliver to the client by rewriting the port number
  786. SendUdp(t->v, e->SrcIp, e->SrcPort, src_ip, Endian16(udp->SrcPort),
  787. payload, payload_size);
  788. }
  789. }
  790. }
  791. // A combined IP packet is received
  792. void NnIpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, UINT protocol, void *data, UINT size,
  793. UCHAR ttl, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size)
  794. {
  795. // Validate arguments
  796. if (t == NULL || data == NULL)
  797. {
  798. return;
  799. }
  800. if (dest_ip != t->PublicIP)
  801. {
  802. // Destination IP is not a unicast
  803. return;
  804. }
  805. switch (protocol)
  806. {
  807. case IP_PROTO_UDP:
  808. // UDP
  809. NnUdpReceived(t, src_ip, dest_ip, data, size, ttl, max_l3_size);
  810. break;
  811. case IP_PROTO_TCP:
  812. // TCP
  813. NnTcpReceived(t, src_ip, dest_ip, data, size, ttl, max_l3_size);
  814. break;
  815. case IP_PROTO_ICMPV4:
  816. // ICMP
  817. NnIcmpReceived(t, src_ip, dest_ip, data, size, ttl, max_l3_size);
  818. break;
  819. }
  820. }
  821. // Received an IP packet
  822. void NnFragmentedIpReceived(NATIVE_NAT *t, PKT *packet)
  823. {
  824. IPV4_HEADER *ip;
  825. void *data;
  826. UINT data_size_recved;
  827. UINT size;
  828. UINT ipv4_header_size;
  829. bool last_packet = false;
  830. UINT l3_size = 0;
  831. UCHAR *head_ip_header_data = NULL;
  832. UINT head_ip_header_size = 0;
  833. // Validate arguments
  834. if (t == NULL || packet == NULL)
  835. {
  836. return;
  837. }
  838. ip = packet->L3.IPv4Header;
  839. // Get the size of the IPv4 header
  840. ipv4_header_size = IPV4_GET_HEADER_LEN(packet->L3.IPv4Header) * 4;
  841. head_ip_header_size = ipv4_header_size;
  842. // Get the pointer to the data
  843. data = ((UCHAR *)packet->L3.PointerL3) + ipv4_header_size;
  844. // Get the data size
  845. size = l3_size = Endian16(ip->TotalLength);
  846. if (size <= ipv4_header_size)
  847. {
  848. // There is no data
  849. return;
  850. }
  851. size -= ipv4_header_size;
  852. // Get the size of data actually received
  853. data_size_recved = packet->PacketSize - (ipv4_header_size + MAC_HEADER_SIZE);
  854. if (data_size_recved < size)
  855. {
  856. // Data insufficient (It may be missing on the way)
  857. return;
  858. }
  859. if (IPV4_GET_OFFSET(ip) == 0 && (IPV4_GET_FLAGS(ip) & 0x01) == 0)
  860. {
  861. // Because this packet has not been fragmented, it can be passed to the upper layer immediately
  862. head_ip_header_data = (UCHAR *)packet->L3.IPv4Header;
  863. NnIpReceived(t, ip->SrcIP, ip->DstIP, ip->Protocol, data, size, ip->TimeToLive,
  864. head_ip_header_data, head_ip_header_size, l3_size);
  865. }
  866. else
  867. {
  868. // This packet is necessary to combine because it is fragmented
  869. UINT offset = IPV4_GET_OFFSET(ip) * 8;
  870. IP_COMBINE *c = NnSearchIpCombine(t, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol);
  871. if (offset == 0)
  872. {
  873. head_ip_header_data = (UCHAR *)packet->L3.IPv4Header;
  874. }
  875. last_packet = ((IPV4_GET_FLAGS(ip) & 0x01) == 0 ? true : false);
  876. if (c != NULL)
  877. {
  878. // It is the second or subsequent packet
  879. c->MaxL3Size = MAX(c->MaxL3Size, l3_size);
  880. NnCombineIp(t, c, offset, data, size, last_packet, head_ip_header_data, head_ip_header_size);
  881. }
  882. else
  883. {
  884. // Create a combining object because it is the first packet
  885. c = NnInsertIpCombine(
  886. t, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket,
  887. ip->TimeToLive, false);
  888. c->MaxL3Size = MAX(c->MaxL3Size, l3_size);
  889. if (c != NULL)
  890. {
  891. NnCombineIp(t, c, offset, data, size, last_packet, head_ip_header_data, head_ip_header_size);
  892. }
  893. }
  894. }
  895. }
  896. // Layer 2 packet processing
  897. void NnLayer2(NATIVE_NAT *t, PKT *packet)
  898. {
  899. // Validate arguments
  900. if (t == NULL || packet == NULL)
  901. {
  902. return;
  903. }
  904. if (packet->TypeL3 == L3_IPV4)
  905. {
  906. // IPv4
  907. NnFragmentedIpReceived(t, packet);
  908. }
  909. }
  910. // Extract the received packets of native NAT, and deliver it to the VPN client
  911. void NnPoll(NATIVE_NAT *t)
  912. {
  913. // Validate arguments
  914. if (t == NULL)
  915. {
  916. return;
  917. }
  918. LockQueue(t->RecvQueue);
  919. {
  920. while (true)
  921. {
  922. PKT *pkt = GetNext(t->RecvQueue);
  923. if (pkt == NULL)
  924. {
  925. break;
  926. }
  927. NnLayer2(t, pkt);
  928. FreePacketWithData(pkt);
  929. }
  930. }
  931. UnlockQueue(t->RecvQueue);
  932. if (t->SendStateChanged)
  933. {
  934. TUBE *halt_tube = NULL;
  935. Lock(t->Lock);
  936. {
  937. if (t->HaltTube != NULL)
  938. {
  939. halt_tube = t->HaltTube;
  940. AddRef(halt_tube->Ref);
  941. }
  942. }
  943. Unlock(t->Lock);
  944. if (halt_tube != NULL)
  945. {
  946. TubeFlushEx(halt_tube, true);
  947. t->SendStateChanged = false;
  948. ReleaseTube(halt_tube);
  949. }
  950. }
  951. NnPollingIpCombine(t);
  952. NnDeleteOldSessions(t);
  953. }
  954. // Send a fragmented IP packet to the Internet
  955. void NnIpSendFragmentedForInternet(NATIVE_NAT *t, UCHAR ip_protocol, UINT src_ip, UINT dest_ip, USHORT id, USHORT total_size,
  956. USHORT offset, void *data, UINT size, UCHAR ttl)
  957. {
  958. UCHAR *buf;
  959. IPV4_HEADER *ip;
  960. BLOCK *b;
  961. // Validate arguments
  962. if (t == NULL || data == NULL)
  963. {
  964. return;
  965. }
  966. // Memory allocation
  967. buf = Malloc(size + IP_HEADER_SIZE);
  968. ip = (IPV4_HEADER *)&buf[0];
  969. // IP header construction
  970. ip->VersionAndHeaderLength = 0;
  971. IPV4_SET_VERSION(ip, 4);
  972. IPV4_SET_HEADER_LEN(ip, (IP_HEADER_SIZE / 4));
  973. ip->TypeOfService = DEFAULT_IP_TOS;
  974. ip->TotalLength = Endian16((USHORT)(size + IP_HEADER_SIZE));
  975. ip->Identification = Endian16(id);
  976. ip->FlagsAndFlagmentOffset[0] = ip->FlagsAndFlagmentOffset[1] = 0;
  977. IPV4_SET_OFFSET(ip, (offset / 8));
  978. if ((offset + size) >= total_size)
  979. {
  980. IPV4_SET_FLAGS(ip, 0x00);
  981. }
  982. else
  983. {
  984. IPV4_SET_FLAGS(ip, 0x01);
  985. }
  986. ip->TimeToLive = (ttl == 0 ? DEFAULT_IP_TTL : ttl);
  987. ip->Protocol = ip_protocol;
  988. ip->Checksum = 0;
  989. ip->SrcIP = src_ip;
  990. ip->DstIP = dest_ip;
  991. // Checksum calculation
  992. ip->Checksum = IpChecksum(ip, IP_HEADER_SIZE);
  993. // Data copy
  994. Copy(buf + IP_HEADER_SIZE, data, size);
  995. // Transmission
  996. b = NewBlock(buf, size + IP_HEADER_SIZE, 0);
  997. LockQueue(t->SendQueue);
  998. {
  999. if (t->SendQueue->num_item <= NN_MAX_QUEUE_LENGTH)
  1000. {
  1001. InsertQueue(t->SendQueue, b);
  1002. t->SendStateChanged = true;
  1003. }
  1004. else
  1005. {
  1006. FreeBlock(b);
  1007. }
  1008. }
  1009. UnlockQueue(t->SendQueue);
  1010. }
  1011. // Send an IP packet to the Internet
  1012. void NnIpSendForInternet(NATIVE_NAT *t, UCHAR ip_protocol, UCHAR ttl, UINT src_ip, UINT dest_ip, void *data, UINT size, UINT max_l3_size)
  1013. {
  1014. UINT mss = 0;
  1015. UCHAR *buf;
  1016. USHORT offset;
  1017. USHORT id;
  1018. USHORT total_size;
  1019. UINT size_of_this_packet;
  1020. // Validate arguments
  1021. if (t == NULL || data == NULL)
  1022. {
  1023. return;
  1024. }
  1025. // Maximum segment size
  1026. if (max_l3_size > IP_HEADER_SIZE)
  1027. {
  1028. mss = max_l3_size - IP_HEADER_SIZE;
  1029. }
  1030. if (mss == 0)
  1031. {
  1032. mss = t->v->IpMss;
  1033. }
  1034. mss = MAX(mss, 1000);
  1035. // Buffer
  1036. buf = (UCHAR *)data;
  1037. // ID
  1038. id = (t->NextId++);
  1039. // Total size
  1040. total_size = (USHORT)size;
  1041. // Start to fragment
  1042. offset = 0;
  1043. while (true)
  1044. {
  1045. bool last_packet = false;
  1046. // Get the size of this packet
  1047. size_of_this_packet = MIN((USHORT)mss, (total_size - offset));
  1048. if ((offset + (USHORT)size_of_this_packet) == total_size)
  1049. {
  1050. last_packet = true;
  1051. }
  1052. // Transmit the fragmented packet
  1053. NnIpSendFragmentedForInternet(t, ip_protocol, src_ip, dest_ip, id, total_size, offset,
  1054. buf + offset, size_of_this_packet, ttl);
  1055. if (last_packet)
  1056. {
  1057. break;
  1058. }
  1059. offset += (USHORT)size_of_this_packet;
  1060. }
  1061. }
  1062. // Communication of ICMP towards the Internet
  1063. void NnIcmpEchoRecvForInternet(VH *v, UINT src_ip, UINT dest_ip, void *data, UINT size, UCHAR ttl, void *icmp_data, UINT icmp_size, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size)
  1064. {
  1065. NATIVE_NAT_ENTRY tt;
  1066. NATIVE_NAT_ENTRY *e;
  1067. NATIVE_NAT *t;
  1068. USHORT src_port;
  1069. ICMP_HEADER *old_icmp_header;
  1070. ICMP_ECHO *old_icmp_echo;
  1071. ICMP_HEADER *icmp;
  1072. ICMP_ECHO *echo;
  1073. UCHAR *payload_data;
  1074. UINT payload_size;
  1075. // Validate arguments
  1076. if (NnIsActive(v) == false || icmp_data == NULL)
  1077. {
  1078. return;
  1079. }
  1080. t = v->NativeNat;
  1081. old_icmp_header = (ICMP_HEADER *)icmp_data;
  1082. old_icmp_echo = (ICMP_ECHO *)(((UCHAR *)icmp_data) + sizeof(ICMP_HEADER));
  1083. if (size < (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  1084. {
  1085. return;
  1086. }
  1087. payload_data = ((UCHAR *)icmp_data) + (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  1088. payload_size = icmp_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  1089. if (dest_ip == v->HostIP)
  1090. {
  1091. // Respond because it is addressed to me
  1092. VirtualIcmpEchoSendResponse(v, dest_ip, src_ip, Endian16(old_icmp_echo->Identifier),
  1093. Endian16(old_icmp_echo->SeqNo), payload_data, payload_size);
  1094. return;
  1095. }
  1096. if (ttl <= 1)
  1097. {
  1098. // Reply the Time Exceeded immediately for the packet whose TTL is 1
  1099. UINT reply_size = sizeof(ICMP_HEADER) + 4 + ip_header_size + 8;
  1100. UCHAR *reply_data = ZeroMalloc(reply_size);
  1101. ICMP_HEADER *icmp = (ICMP_HEADER *)reply_data;
  1102. icmp->Type = ICMP_TYPE_TIME_EXCEEDED;
  1103. icmp->Code = ICMP_CODE_TTL_EXCEEDED_IN_TRANSIT;
  1104. Copy(reply_data + sizeof(ICMP_HEADER) + 4, ip_header, ip_header_size);
  1105. Copy(reply_data + sizeof(ICMP_HEADER) + 4 + ip_header_size, icmp_data, MIN(icmp_size, 8));
  1106. icmp->Checksum = IpChecksum(icmp, reply_size);
  1107. SendIp(v, src_ip, v->HostIP, IP_PROTO_ICMPV4, reply_data, reply_size);
  1108. Free(reply_data);
  1109. return;
  1110. }
  1111. src_port = Endian16(old_icmp_echo->Identifier);
  1112. // Search whether there is an existing session
  1113. NnSetNat(&tt, NAT_ICMP, src_ip, src_port, 0, 0, 0, 0);
  1114. e = SearchHash(t->NatTableForSend, &tt);
  1115. if (e == NULL)
  1116. {
  1117. // Create a new session because there is no existing one
  1118. UINT public_port;
  1119. if (CanCreateNewNatEntry(v) == false)
  1120. {
  1121. // Can not make any more
  1122. return;
  1123. }
  1124. NnDeleteOldestNatSessionIfNecessary(t, src_ip, NAT_ICMP);
  1125. // Get a free port
  1126. public_port = NnMapNewPublicPort(t, NAT_ICMP, 0, 0, t->PublicIP);
  1127. if (public_port == 0)
  1128. {
  1129. // There are no free ports
  1130. return;
  1131. }
  1132. e = ZeroMalloc(sizeof(NATIVE_NAT_ENTRY));
  1133. e->Status = NAT_TCP_ESTABLISHED;
  1134. e->HashCodeForSend = INFINITE;
  1135. e->HashCodeForRecv = INFINITE;
  1136. e->Id = Inc(v->Counter);
  1137. e->Protocol = NAT_ICMP;
  1138. e->SrcIp = src_ip;
  1139. e->SrcPort = src_port;
  1140. e->DestIp = 0;
  1141. e->DestPort = 0;
  1142. e->PublicIp = t->PublicIP;
  1143. e->PublicPort = public_port;
  1144. e->CreatedTime = v->Now;
  1145. e->LastCommTime = v->Now;
  1146. // Add to the list
  1147. AddHash(t->NatTableForSend, e);
  1148. AddHash(t->NatTableForRecv, e);
  1149. // Log
  1150. if (true)
  1151. {
  1152. IP ip1, ip2;
  1153. char s1[MAX_SIZE], s2[MAX_SIZE];
  1154. UINTToIP(&ip1, src_ip);
  1155. UINTToIP(&ip2, dest_ip);
  1156. IPToStr(s1, 0, &ip1);
  1157. IPToStr(s2, 0, &ip2);
  1158. Debug("ICMP Session %u: %s:0x%x -> %s:0x%x\n", e->Id, s1, src_port, s2, public_port);
  1159. }
  1160. }
  1161. // Rebuild the ICMP header
  1162. icmp = ZeroMalloc(sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + payload_size);
  1163. icmp->Code = old_icmp_header->Code;
  1164. icmp->Type = old_icmp_header->Type;
  1165. icmp->Checksum = 0;
  1166. echo = (ICMP_ECHO *)(((UCHAR *)icmp) + sizeof(ICMP_HEADER));
  1167. echo->SeqNo = old_icmp_echo->SeqNo;
  1168. echo->Identifier = Endian16(e->PublicPort);
  1169. Copy(((UCHAR *)icmp) + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), payload_data, payload_size);
  1170. icmp->Checksum = IpChecksum(icmp, sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + payload_size);
  1171. e->TotalSent += (UINT64)payload_size;
  1172. e->LastCommTime = v->Now;
  1173. // Send to the Internet
  1174. NnIpSendForInternet(t, IP_PROTO_ICMPV4, ttl - 1, e->PublicIp, dest_ip, icmp, sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + payload_size, max_l3_size);
  1175. Free(icmp);
  1176. }
  1177. // Communication of UDP towards the Internet
  1178. void NnUdpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size, UINT max_l3_size)
  1179. {
  1180. NATIVE_NAT_ENTRY tt;
  1181. NATIVE_NAT_ENTRY *e;
  1182. NATIVE_NAT *t;
  1183. UDP_HEADER *udp;
  1184. // Validate arguments
  1185. if (NnIsActive(v) == false || data == NULL)
  1186. {
  1187. return;
  1188. }
  1189. t = v->NativeNat;
  1190. // Search whether there is an existing session
  1191. NnSetNat(&tt, NAT_UDP, src_ip, src_port, 0, 0, 0, 0);
  1192. e = SearchHash(t->NatTableForSend, &tt);
  1193. if (e == NULL)
  1194. {
  1195. // Create a new session because there is no existing one
  1196. UINT public_port;
  1197. if (CanCreateNewNatEntry(v) == false)
  1198. {
  1199. // Can not make any more
  1200. return;
  1201. }
  1202. NnDeleteOldestNatSessionIfNecessary(t, src_ip, NAT_UDP);
  1203. // Get a free port
  1204. public_port = NnMapNewPublicPort(t, NAT_UDP, 0, 0, t->PublicIP);
  1205. if (public_port == 0)
  1206. {
  1207. // There are no free ports
  1208. return;
  1209. }
  1210. e = ZeroMalloc(sizeof(NATIVE_NAT_ENTRY));
  1211. e->Status = NAT_TCP_ESTABLISHED;
  1212. e->HashCodeForSend = INFINITE;
  1213. e->HashCodeForRecv = INFINITE;
  1214. e->Id = Inc(v->Counter);
  1215. e->Protocol = NAT_UDP;
  1216. e->SrcIp = src_ip;
  1217. e->SrcPort = src_port;
  1218. e->DestIp = 0;
  1219. e->DestPort = 0;
  1220. e->PublicIp = t->PublicIP;
  1221. e->PublicPort = public_port;
  1222. e->CreatedTime = v->Now;
  1223. e->LastCommTime = v->Now;
  1224. // Add to the list
  1225. AddHash(t->NatTableForSend, e);
  1226. AddHash(t->NatTableForRecv, e);
  1227. // Log
  1228. if (true)
  1229. {
  1230. IP ip1, ip2;
  1231. char s1[MAX_SIZE], s2[MAX_SIZE];
  1232. UINTToIP(&ip1, src_ip);
  1233. UINTToIP(&ip2, dest_ip);
  1234. IPToStr(s1, 0, &ip1);
  1235. IPToStr(s2, 0, &ip2);
  1236. NLog(v, "LH_NAT_UDP_CREATED", e->Id, s1, src_port, s2, dest_port);
  1237. }
  1238. }
  1239. // Rebuild the UDP header
  1240. udp = ZeroMalloc(sizeof(UDP_HEADER) + size);
  1241. udp->SrcPort = Endian16(e->PublicPort);
  1242. udp->DstPort = Endian16(dest_port);
  1243. udp->PacketLength = Endian16((USHORT)sizeof(UDP_HEADER) + size);
  1244. Copy(((UCHAR *)udp) + sizeof(UDP_HEADER), data, size);
  1245. udp->Checksum = CalcChecksumForIPv4(e->PublicIp, dest_ip, IP_PROTO_UDP, udp, sizeof(UDP_HEADER) + size, 0);
  1246. e->TotalSent += (UINT64)size;
  1247. e->LastCommTime = v->Now;
  1248. // Send to the Internet
  1249. NnIpSendForInternet(t, IP_PROTO_UDP, 127, e->PublicIp, dest_ip, udp, sizeof(UDP_HEADER) + size, max_l3_size);
  1250. Free(udp);
  1251. }
  1252. // Communication of TCP towards the Internet
  1253. void NnTcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, TCP_HEADER *old_tcp, void *data, UINT size, UINT max_l3_size)
  1254. {
  1255. NATIVE_NAT_ENTRY tt;
  1256. NATIVE_NAT_ENTRY *e;
  1257. NATIVE_NAT *t;
  1258. UINT tcp_header_size;
  1259. TCP_HEADER *tcp;
  1260. // Validate arguments
  1261. if (NnIsActive(v) == false || old_tcp == NULL || data == NULL)
  1262. {
  1263. return;
  1264. }
  1265. t = v->NativeNat;
  1266. // Search whether there is an existing session
  1267. NnSetNat(&tt, NAT_TCP, src_ip, src_port, dest_ip, dest_port, 0, 0);
  1268. e = SearchHash(t->NatTableForSend, &tt);
  1269. if (e == NULL)
  1270. {
  1271. // Create a new session because there is no existing one
  1272. UINT public_port;
  1273. if (old_tcp->Flag != TCP_SYN)
  1274. {
  1275. // If there is no existing session, pass through only for SYN packet
  1276. return;
  1277. }
  1278. if (CanCreateNewNatEntry(v) == false)
  1279. {
  1280. // Can not make any more
  1281. return;
  1282. }
  1283. NnDeleteOldestNatSessionIfNecessary(t, src_ip, NAT_TCP);
  1284. // Get a free port
  1285. public_port = NnMapNewPublicPort(t, NAT_TCP, dest_ip, dest_port, t->PublicIP);
  1286. if (public_port == 0)
  1287. {
  1288. // There are no free ports
  1289. return;
  1290. }
  1291. e = ZeroMalloc(sizeof(NATIVE_NAT_ENTRY));
  1292. e->HashCodeForSend = INFINITE;
  1293. e->HashCodeForRecv = INFINITE;
  1294. e->Id = Inc(v->Counter);
  1295. e->Status = NAT_TCP_CONNECTING;
  1296. e->Protocol = NAT_TCP;
  1297. e->SrcIp = src_ip;
  1298. e->SrcPort = src_port;
  1299. e->DestIp = dest_ip;
  1300. e->DestPort = dest_port;
  1301. e->PublicIp = t->PublicIP;
  1302. e->PublicPort = public_port;
  1303. e->CreatedTime = v->Now;
  1304. e->LastCommTime = v->Now;
  1305. // Add to the list
  1306. AddHash(t->NatTableForSend, e);
  1307. AddHash(t->NatTableForRecv, e);
  1308. // Log
  1309. if (true)
  1310. {
  1311. IP ip1, ip2;
  1312. char s1[MAX_SIZE], s2[MAX_SIZE];
  1313. UINTToIP(&ip1, src_ip);
  1314. UINTToIP(&ip2, dest_ip);
  1315. IPToStr(s1, 0, &ip1);
  1316. IPToStr(s2, 0, &ip2);
  1317. NLog(v, "LH_NAT_TCP_CREATED", e->Id, s1, src_port, s2, dest_port);
  1318. }
  1319. }
  1320. // Update the last communication time
  1321. e->LastCommTime = v->Now;
  1322. e->TotalSent += (UINT64)size;
  1323. tcp_header_size = TCP_GET_HEADER_SIZE(old_tcp) * 4;
  1324. // Create a new TCP packet
  1325. tcp = ZeroMalloc(tcp_header_size + size);
  1326. // Copy the old TCP header
  1327. Copy(tcp, old_tcp, tcp_header_size);
  1328. if (tcp->Flag & TCP_RST || tcp->Flag & TCP_FIN)
  1329. {
  1330. // Disconnect
  1331. e->Status = NAT_TCP_WAIT_DISCONNECT;
  1332. }
  1333. // Rewrite the TCP header
  1334. tcp->Checksum = 0;
  1335. tcp->SrcPort = Endian16(e->PublicPort);
  1336. e->LastSeq = Endian32(tcp->SeqNumber);
  1337. e->LastAck = Endian32(tcp->AckNumber);
  1338. // Payload
  1339. Copy(((UCHAR *)tcp) + tcp_header_size, data, size);
  1340. // Checksum calculation
  1341. tcp->Checksum = CalcChecksumForIPv4(e->PublicIp, dest_ip, IP_PROTO_TCP, tcp, tcp_header_size + size, 0);
  1342. // Send to the Internet
  1343. NnIpSendForInternet(t, IP_PROTO_TCP, 127, e->PublicIp, dest_ip, tcp, tcp_header_size + size, max_l3_size);
  1344. Free(tcp);
  1345. }
  1346. // Assign a new public-side port
  1347. UINT NnMapNewPublicPort(NATIVE_NAT *t, UINT protocol, UINT dest_ip, UINT dest_port, UINT public_ip)
  1348. {
  1349. UINT i;
  1350. UINT base_port;
  1351. // Validate arguments
  1352. if (t == NULL)
  1353. {
  1354. return 0;
  1355. }
  1356. base_port = Rand32() % (65500 - 1025) + 1025;
  1357. for (i = 0;i < (65500 - 1025);i++)
  1358. {
  1359. UINT port;
  1360. NATIVE_NAT_ENTRY tt;
  1361. NATIVE_NAT *e;
  1362. port = base_port + i;
  1363. if (port > 65500)
  1364. {
  1365. port = port - 65500 + 1025;
  1366. }
  1367. // Is this port vacant?
  1368. NnSetNat(&tt, protocol, 0, 0, dest_ip, dest_port, public_ip, port);
  1369. e = SearchHash(t->NatTableForRecv, &tt);
  1370. if (e == NULL)
  1371. {
  1372. // Free port is found
  1373. return port;
  1374. }
  1375. }
  1376. return 0;
  1377. }
  1378. // Examine whether the native NAT is available
  1379. bool NnIsActive(VH *v)
  1380. {
  1381. // Validate arguments
  1382. if (v == NULL)
  1383. {
  1384. return false;
  1385. }
  1386. if (v->NativeNat == NULL)
  1387. {
  1388. return false;
  1389. }
  1390. if (v->NativeNat->PublicIP == 0)
  1391. {
  1392. return false;
  1393. }
  1394. return v->NativeNat->Active;
  1395. }
  1396. // Native NAT main loop
  1397. void NnMainLoop(NATIVE_NAT *t, NATIVE_STACK *a)
  1398. {
  1399. IPC *ipc;
  1400. TUBE *tubes[3];
  1401. UINT num_tubes = 0;
  1402. UINT64 next_poll_tick = 0;
  1403. INTERRUPT_MANAGER *interrupt;
  1404. USHORT dns_src_port = 0;
  1405. USHORT dns_tran_id = 0;
  1406. USHORT tcp_src_port = 0;
  1407. UINT tcp_seq = 0;
  1408. IP yahoo_ip;
  1409. bool wait_for_dns = false;
  1410. UINT64 tcp_last_recv_tick = 0;
  1411. UINT dhcp_renew_interval;
  1412. UINT64 next_dhcp_renew_tick = 0;
  1413. // Validate arguments
  1414. if (t == NULL || a == NULL)
  1415. {
  1416. return;
  1417. }
  1418. dhcp_renew_interval = a->CurrentDhcpOptionList.LeaseTime;
  1419. if (dhcp_renew_interval == 0)
  1420. {
  1421. dhcp_renew_interval = IPC_DHCP_DEFAULT_LEASE;
  1422. }
  1423. dhcp_renew_interval = MAX(dhcp_renew_interval, IPC_DHCP_MIN_LEASE) / 2;
  1424. interrupt = NewInterruptManager();
  1425. ipc = a->Ipc;
  1426. tubes[num_tubes++] = ipc->Sock->RecvTube;
  1427. tubes[num_tubes++] = ipc->Sock->SendTube;
  1428. tubes[num_tubes++] = t->HaltTube;
  1429. Zero(&yahoo_ip, sizeof(yahoo_ip));
  1430. next_poll_tick = Tick64() + (UINT64)NN_POLL_CONNECTIVITY_INTERVAL;
  1431. AddInterrupt(interrupt, next_poll_tick);
  1432. tcp_last_recv_tick = Tick64();
  1433. next_dhcp_renew_tick = Tick64() + (UINT64)dhcp_renew_interval;
  1434. AddInterrupt(interrupt, next_dhcp_renew_tick);
  1435. while (t->Halt == false && t->v->UseNat && ((t->v->HubOption == NULL) || (t->v->HubOption->DisableKernelModeSecureNAT == false)))
  1436. {
  1437. UINT64 now = Tick64();
  1438. bool call_cancel = false;
  1439. bool state_changed = false;
  1440. UINT wait_interval;
  1441. IPCFlushArpTable(ipc);
  1442. call_cancel = false;
  1443. LABEL_RESTART:
  1444. state_changed = false;
  1445. if (next_poll_tick == 0 || next_poll_tick <= now)
  1446. {
  1447. BUF *dns_query;
  1448. dns_src_port = NnGenSrcPort();
  1449. dns_tran_id = Rand16();
  1450. // Start a connectivity check periodically
  1451. dns_query = NnBuildIpPacket(NnBuildUdpPacket(NnBuildDnsQueryPacket(NN_CHECK_HOSTNAME, dns_tran_id),
  1452. IPToUINT(&ipc->ClientIPAddress), dns_src_port, IPToUINT(&a->DnsServerIP), 53),
  1453. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0);
  1454. IPCSendIPv4(ipc, dns_query->Buf, dns_query->Size);
  1455. wait_for_dns = true;
  1456. FreeBuf(dns_query);
  1457. next_poll_tick = now + (UINT64)NN_POLL_CONNECTIVITY_INTERVAL;
  1458. AddInterrupt(interrupt, next_poll_tick);
  1459. }
  1460. if (next_dhcp_renew_tick == 0 || next_dhcp_renew_tick <= now)
  1461. {
  1462. IP ip;
  1463. UINTToIP(&ip, a->CurrentDhcpOptionList.ServerAddress);
  1464. IPCDhcpRenewIP(ipc, &ip);
  1465. next_dhcp_renew_tick = now + (UINT64)dhcp_renew_interval;
  1466. AddInterrupt(interrupt, next_dhcp_renew_tick);
  1467. }
  1468. // Send an IP packet to IPC
  1469. LockQueue(t->SendQueue);
  1470. {
  1471. while (true)
  1472. {
  1473. BLOCK *b = GetNext(t->SendQueue);
  1474. if (b == NULL)
  1475. {
  1476. break;
  1477. }
  1478. IPCSendIPv4(ipc, b->Buf, b->Size);
  1479. state_changed = true;
  1480. FreeBlock(b);
  1481. }
  1482. }
  1483. UnlockQueue(t->SendQueue);
  1484. // Happy processing
  1485. IPCProcessL3Events(ipc);
  1486. LockQueue(t->RecvQueue);
  1487. {
  1488. while (true)
  1489. {
  1490. // Receive an IP packet from IPC
  1491. BLOCK *b = IPCRecvIPv4(ipc);
  1492. PKT *pkt;
  1493. if (b == NULL)
  1494. {
  1495. // Can not receive any more
  1496. break;
  1497. }
  1498. // Parse the packet
  1499. pkt = ParsePacketIPv4WithDummyMacHeader(b->Buf, b->Size);
  1500. FreeBlock(b);
  1501. if (pkt != NULL)
  1502. {
  1503. bool no_store = false;
  1504. // Read the contents of the packet first, to determine whether it is a response for the connectivity test packet
  1505. if (wait_for_dns)
  1506. {
  1507. if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_UDP &&
  1508. pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) &&
  1509. pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) &&
  1510. pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(dns_src_port))
  1511. {
  1512. DNSV4_HEADER *dns_header = (DNSV4_HEADER *)pkt->Payload;
  1513. if (pkt->PayloadSize >= sizeof(DNSV4_HEADER))
  1514. {
  1515. if (dns_header->TransactionId == Endian16(dns_tran_id))
  1516. {
  1517. IP ret_ip;
  1518. if (NnParseDnsResponsePacket(pkt->Payload, pkt->PayloadSize, &ret_ip))
  1519. {
  1520. BUF *tcp_query;
  1521. Copy(&yahoo_ip, &ret_ip, sizeof(IP));
  1522. //SetIP(&yahoo_ip, 192, 168, 2, 32);
  1523. // DNS response has been received
  1524. no_store = true;
  1525. tcp_src_port = NnGenSrcPort();
  1526. // Generate a TCP connection attempt packet
  1527. tcp_seq = Rand32();
  1528. tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), tcp_src_port,
  1529. IPToUINT(&yahoo_ip), 80, tcp_seq, 0, TCP_SYN, 8192, 1414),
  1530. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0);
  1531. IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size);
  1532. FreeBuf(tcp_query);
  1533. wait_for_dns = false;
  1534. }
  1535. }
  1536. }
  1537. }
  1538. }
  1539. if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_TCP &&
  1540. pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) &&
  1541. pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) &&
  1542. pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(tcp_src_port))
  1543. {
  1544. TCP_HEADER *tcp_header = (TCP_HEADER *)pkt->L4.TCPHeader;
  1545. if ((tcp_header->Flag & TCP_SYN) && (tcp_header->Flag & TCP_ACK))
  1546. {
  1547. // There was a TCP response
  1548. BUF *tcp_query;
  1549. UINT recv_seq = Endian32(tcp_header->SeqNumber) + 1;
  1550. no_store = true;
  1551. // Send a RST
  1552. tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), tcp_src_port,
  1553. IPToUINT(&yahoo_ip), 80, tcp_seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0),
  1554. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0);
  1555. IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size);
  1556. FreeBuf(tcp_query);
  1557. tcp_last_recv_tick = now;
  1558. }
  1559. }
  1560. if (t->RecvQueue->num_item > NN_MAX_QUEUE_LENGTH)
  1561. {
  1562. no_store = true;
  1563. }
  1564. if (no_store == false)
  1565. {
  1566. // Put in the queue
  1567. InsertQueue(t->RecvQueue, pkt);
  1568. call_cancel = true;
  1569. state_changed = true;
  1570. }
  1571. else
  1572. {
  1573. // Release the packet
  1574. FreePacketWithData(pkt);
  1575. }
  1576. }
  1577. }
  1578. }
  1579. UnlockQueue(t->RecvQueue);
  1580. if (state_changed)
  1581. {
  1582. goto LABEL_RESTART;
  1583. }
  1584. if (call_cancel)
  1585. {
  1586. CANCEL *c = NULL;
  1587. Lock(t->CancelLock);
  1588. {
  1589. c = t->Cancel;
  1590. AddRef(c->ref);
  1591. }
  1592. Unlock(t->CancelLock);
  1593. if (c != NULL)
  1594. {
  1595. Cancel(c);
  1596. ReleaseCancel(c);
  1597. }
  1598. }
  1599. if (IsTubeConnected(ipc->Sock->RecvTube) == false || IsTubeConnected(ipc->Sock->SendTube) == false)
  1600. {
  1601. // Disconnected
  1602. break;
  1603. }
  1604. if ((tcp_last_recv_tick + (UINT64)NN_POLL_CONNECTIVITY_TIMEOUT) < now)
  1605. {
  1606. // Connectivity test has timed out because a certain period of time has elapsed
  1607. Debug("NN_POLL_CONNECTIVITY_TIMEOUT\n");
  1608. break;
  1609. }
  1610. wait_interval = GetNextIntervalForInterrupt(interrupt);
  1611. wait_interval = MIN(wait_interval, 1234);
  1612. if (wait_interval != 0)
  1613. {
  1614. WaitForTubes(tubes, num_tubes, wait_interval);
  1615. }
  1616. }
  1617. FreeInterruptManager(interrupt);
  1618. }
  1619. // Build an IP packet
  1620. BUF *NnBuildIpPacket(BUF *payload, UINT src_ip, UINT dst_ip, UCHAR protocol, UCHAR ttl)
  1621. {
  1622. BUF *ret = NewBuf();
  1623. IPV4_HEADER h;
  1624. if (ttl == 0)
  1625. {
  1626. ttl = 127;
  1627. }
  1628. // IP header
  1629. Zero(&h, sizeof(h));
  1630. IPV4_SET_VERSION(&h, 4);
  1631. IPV4_SET_HEADER_LEN(&h, sizeof(IPV4_HEADER) / 4);
  1632. h.TotalLength = Endian16((USHORT)sizeof(IPV4_HEADER) + payload->Size);
  1633. h.Identification = Rand16();
  1634. h.TimeToLive = ttl;
  1635. h.Protocol = protocol;
  1636. h.SrcIP = src_ip;
  1637. h.DstIP = dst_ip;
  1638. h.Checksum = IpChecksum(&h, sizeof(h));
  1639. WriteBuf(ret, &h, sizeof(h));
  1640. WriteBufBuf(ret, payload);
  1641. SeekBufToBegin(ret);
  1642. FreeBuf(payload);
  1643. return ret;
  1644. }
  1645. // Build an UDP packet
  1646. BUF *NnBuildUdpPacket(BUF *payload, UINT src_ip, USHORT src_port, UINT dst_ip, USHORT dst_port)
  1647. {
  1648. BUF *ret = NewBuf();
  1649. BUF *phbuf = NewBuf();
  1650. UDPV4_PSEUDO_HEADER ph;
  1651. UDP_HEADER h;
  1652. // UDP pseudo header
  1653. Zero(&ph, sizeof(ph));
  1654. ph.SrcIP = src_ip;
  1655. ph.DstIP = dst_ip;
  1656. ph.SrcPort = Endian16(src_port);
  1657. ph.DstPort = Endian16(dst_port);
  1658. ph.Protocol = IP_PROTO_UDP;
  1659. ph.PacketLength1 = ph.PacketLength2 = Endian16(payload->Size + (USHORT)sizeof(UDP_HEADER));
  1660. WriteBuf(phbuf, &ph, sizeof(ph));
  1661. WriteBufBuf(phbuf, payload);
  1662. // UDP header
  1663. Zero(&h, sizeof(h));
  1664. h.SrcPort = Endian16(src_port);
  1665. h.DstPort = Endian16(dst_port);
  1666. h.PacketLength = Endian16(payload->Size + (USHORT)sizeof(UDP_HEADER));
  1667. h.Checksum = IpChecksum(phbuf->Buf, phbuf->Size);
  1668. WriteBuf(ret, &h, sizeof(h));
  1669. WriteBuf(ret, payload->Buf, payload->Size);
  1670. SeekBufToBegin(ret);
  1671. FreeBuf(payload);
  1672. FreeBuf(phbuf);
  1673. return ret;
  1674. }
  1675. // Build a TCP packet
  1676. BUF *NnBuildTcpPacket(BUF *payload, UINT src_ip, USHORT src_port, UINT dst_ip, USHORT dst_port, UINT seq, UINT ack, UINT flag, UINT window_size, UINT mss)
  1677. {
  1678. BUF *ret;
  1679. IPV4_PSEUDO_HEADER *vh;
  1680. TCP_HEADER *tcp;
  1681. static UCHAR tcp_mss_option[] = {0x02, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00};
  1682. UINT header_size = TCP_HEADER_SIZE;
  1683. UINT total_size;
  1684. // Memory allocation
  1685. vh = Malloc(sizeof(IPV4_PSEUDO_HEADER) + TCP_HEADER_SIZE + payload->Size + 32);
  1686. tcp = (TCP_HEADER *)(((UCHAR *)vh) + sizeof(IPV4_PSEUDO_HEADER));
  1687. if (mss != 0)
  1688. {
  1689. USHORT *mss_size;
  1690. mss_size = (USHORT *)(&tcp_mss_option[2]);
  1691. *mss_size = Endian16((USHORT)mss);
  1692. header_size += sizeof(tcp_mss_option);
  1693. }
  1694. total_size = header_size + payload->Size;
  1695. // Pseudo header generation
  1696. vh->SrcIP = src_ip;
  1697. vh->DstIP = dst_ip;
  1698. vh->Reserved = 0;
  1699. vh->Protocol = IP_PROTO_TCP;
  1700. vh->PacketLength = Endian16((USHORT)total_size);
  1701. // TCP header generation
  1702. tcp->SrcPort = Endian16((USHORT)src_port);
  1703. tcp->DstPort = Endian16((USHORT)dst_port);
  1704. tcp->SeqNumber = Endian32(seq);
  1705. tcp->AckNumber = Endian32(ack);
  1706. tcp->HeaderSizeAndReserved = 0;
  1707. TCP_SET_HEADER_SIZE(tcp, (UCHAR)(header_size / 4));
  1708. tcp->Flag = (UCHAR)flag;
  1709. tcp->WindowSize = Endian16((USHORT)window_size);
  1710. tcp->Checksum = 0;
  1711. tcp->UrgentPointer = 0;
  1712. // Copy the option values
  1713. if (mss != 0)
  1714. {
  1715. Copy(((UCHAR *)tcp) + TCP_HEADER_SIZE, tcp_mss_option, sizeof(tcp_mss_option));
  1716. }
  1717. // Data copy
  1718. Copy(((UCHAR *)tcp) + header_size, payload->Buf, payload->Size);
  1719. // Checksum calculation
  1720. tcp->Checksum = IpChecksum(vh, total_size + 12);
  1721. ret = NewBufFromMemory(tcp, total_size);
  1722. Free(vh);
  1723. FreeBuf(payload);
  1724. return ret;
  1725. }
  1726. // Build a DNS query packet
  1727. BUF *NnBuildDnsQueryPacket(char *hostname, USHORT tran_id)
  1728. {
  1729. BUF *buf = NewBuf();
  1730. DNSV4_HEADER header;
  1731. Zero(&header, sizeof(header));
  1732. header.TransactionId = Endian16(tran_id);
  1733. header.Flag1 = 0x01;
  1734. header.Flag2 = 0x00;
  1735. header.NumQuery = Endian16(1);
  1736. WriteBuf(buf, &header, sizeof(header));
  1737. BuildDnsQueryPacket(buf, hostname, false);
  1738. SeekBufToBegin(buf);
  1739. return buf;
  1740. }
  1741. // Read a DNS record
  1742. BUF *NnReadDnsRecord(BUF *buf, bool answer, USHORT *ret_type, USHORT *ret_class)
  1743. {
  1744. USHORT type;
  1745. USHORT clas;
  1746. UINT ttl;
  1747. BUF *ret = NULL;
  1748. // Validate arguments
  1749. if (buf == NULL)
  1750. {
  1751. return NULL;
  1752. }
  1753. // Read the DNS label
  1754. if (NnReadDnsLabel(buf) == false)
  1755. {
  1756. return false;
  1757. }
  1758. // Type and Class
  1759. if (ReadBuf(buf, &type, sizeof(USHORT)) != sizeof(USHORT))
  1760. {
  1761. return false;
  1762. }
  1763. if (ret_type != NULL)
  1764. {
  1765. *ret_type = Endian16(type);
  1766. }
  1767. if (ReadBuf(buf, &clas, sizeof(USHORT)) != sizeof(USHORT))
  1768. {
  1769. return false;
  1770. }
  1771. if (ret_class != NULL)
  1772. {
  1773. *ret_class = Endian16(clas);
  1774. }
  1775. if (answer)
  1776. {
  1777. USHORT data_len;
  1778. UCHAR *data;
  1779. // TTL
  1780. if (ReadBuf(buf, &ttl, sizeof(UINT)) != sizeof(UINT))
  1781. {
  1782. return false;
  1783. }
  1784. // data_len
  1785. if (ReadBuf(buf, &data_len, sizeof(USHORT)) != sizeof(USHORT))
  1786. {
  1787. return false;
  1788. }
  1789. data_len = Endian16(data_len);
  1790. // data
  1791. data = Malloc(data_len);
  1792. if (ReadBuf(buf, data, data_len) != data_len)
  1793. {
  1794. return false;
  1795. }
  1796. ret = NewBufFromMemory(data, data_len);
  1797. Free(data);
  1798. }
  1799. else
  1800. {
  1801. ret = NewBuf();
  1802. }
  1803. return ret;
  1804. }
  1805. // Read the DNS label
  1806. bool NnReadDnsLabel(BUF *buf)
  1807. {
  1808. UCHAR c;
  1809. UCHAR tmp[256];
  1810. // Validate arguments
  1811. if (buf == NULL)
  1812. {
  1813. return false;
  1814. }
  1815. LABEL_START:
  1816. if (ReadBuf(buf, &c, 1) != 1)
  1817. {
  1818. return false;
  1819. }
  1820. if (c == 0)
  1821. {
  1822. return true;
  1823. }
  1824. if (c & 0xC0)
  1825. {
  1826. // Compression label
  1827. if (ReadBuf(buf, &c, 1) != 1)
  1828. {
  1829. return false;
  1830. }
  1831. else
  1832. {
  1833. return true;
  1834. }
  1835. }
  1836. else
  1837. {
  1838. // Usual label
  1839. if (ReadBuf(buf, tmp, c) != c)
  1840. {
  1841. return false;
  1842. }
  1843. else
  1844. {
  1845. goto LABEL_START;
  1846. }
  1847. }
  1848. }
  1849. // Parse the DNS response packet
  1850. bool NnParseDnsResponsePacket(UCHAR *data, UINT size, IP *ret_ip)
  1851. {
  1852. BUF *buf = NewBufFromMemory(data, size);
  1853. bool ret = false;
  1854. DNSV4_HEADER h;
  1855. if (ReadBuf(buf, &h, sizeof(h)) == sizeof(h))
  1856. {
  1857. UINT num_questions = Endian16(h.NumQuery);
  1858. UINT num_answers = Endian16(h.AnswerRRs);
  1859. UINT i;
  1860. for (i = 0;i < num_questions;i++)
  1861. {
  1862. BUF *r = NnReadDnsRecord(buf, false, NULL, NULL);
  1863. if (r != NULL)
  1864. {
  1865. FreeBuf(r);
  1866. }
  1867. else
  1868. {
  1869. goto LABEL_CLEANUP;
  1870. }
  1871. }
  1872. for (i = 0;i < num_answers;i++)
  1873. {
  1874. USHORT tp, cl;
  1875. BUF *r = NnReadDnsRecord(buf, true, &tp, &cl);
  1876. if (r != NULL)
  1877. {
  1878. if (tp == 0x0001 && cl == 0x0001 && r->Size == 4)
  1879. {
  1880. ret = true;
  1881. if (ret_ip != NULL)
  1882. {
  1883. Zero(ret_ip, sizeof(IP));
  1884. Copy(ret_ip->addr, r->Buf, 4);
  1885. }
  1886. }
  1887. FreeBuf(r);
  1888. }
  1889. else
  1890. {
  1891. goto LABEL_CLEANUP;
  1892. }
  1893. }
  1894. }
  1895. LABEL_CLEANUP:
  1896. FreeBuf(buf);
  1897. return ret;
  1898. }
  1899. // Test the connectivity of the stack to the Internet
  1900. bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube)
  1901. {
  1902. BUF *dns_query;
  1903. bool ok = false;
  1904. USHORT dns_tran_id = Rand16();
  1905. UINT64 next_send_tick = 0;
  1906. UINT64 giveup_time;
  1907. IPC *ipc;
  1908. UINT src_port = NnGenSrcPort();
  1909. INTERRUPT_MANAGER *interrupt;
  1910. TUBE *tubes[3];
  1911. UINT num_tubes = 0;
  1912. IP yahoo_ip;
  1913. // Validate arguments
  1914. if (a == NULL)
  1915. {
  1916. return false;
  1917. }
  1918. ipc = a->Ipc;
  1919. interrupt = NewInterruptManager();
  1920. tubes[num_tubes++] = ipc->Sock->RecvTube;
  1921. tubes[num_tubes++] = ipc->Sock->SendTube;
  1922. if (halt_tube != NULL)
  1923. {
  1924. tubes[num_tubes++] = halt_tube;
  1925. }
  1926. Zero(&yahoo_ip, sizeof(yahoo_ip));
  1927. // Try to get an IP address of www.yahoo.com
  1928. dns_query = NnBuildIpPacket(NnBuildUdpPacket(NnBuildDnsQueryPacket(NN_CHECK_HOSTNAME, dns_tran_id),
  1929. IPToUINT(&ipc->ClientIPAddress), src_port, IPToUINT(&a->DnsServerIP), 53),
  1930. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0);
  1931. giveup_time = Tick64() + NN_CHECK_CONNECTIVITY_TIMEOUT;
  1932. AddInterrupt(interrupt, giveup_time);
  1933. while (true)
  1934. {
  1935. UINT64 now = Tick64();
  1936. IPCFlushArpTable(a->Ipc);
  1937. if (now >= giveup_time)
  1938. {
  1939. break;
  1940. }
  1941. // Send a packet periodically
  1942. if (next_send_tick == 0 || next_send_tick <= now)
  1943. {
  1944. next_send_tick = now + (UINT64)NN_CHECK_CONNECTIVITY_INTERVAL;
  1945. AddInterrupt(interrupt, next_send_tick);
  1946. IPCSendIPv4(ipc, dns_query->Buf, dns_query->Size);
  1947. }
  1948. // Happy processing
  1949. IPCProcessL3Events(ipc);
  1950. while (true)
  1951. {
  1952. // Receive a packet
  1953. BLOCK *b = IPCRecvIPv4(ipc);
  1954. PKT *pkt;
  1955. if (b == NULL)
  1956. {
  1957. break;
  1958. }
  1959. // Parse the packet
  1960. pkt = ParsePacketIPv4WithDummyMacHeader(b->Buf, b->Size);
  1961. if (pkt != NULL)
  1962. {
  1963. if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_UDP &&
  1964. pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) &&
  1965. pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) &&
  1966. pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(src_port))
  1967. {
  1968. DNSV4_HEADER *dns_header = (DNSV4_HEADER *)pkt->Payload;
  1969. if (pkt->PayloadSize >= sizeof(DNSV4_HEADER))
  1970. {
  1971. if (dns_header->TransactionId == Endian16(dns_tran_id))
  1972. {
  1973. IP ret_ip;
  1974. if (NnParseDnsResponsePacket(pkt->Payload, pkt->PayloadSize, &ret_ip))
  1975. {
  1976. Copy(&yahoo_ip, &ret_ip, sizeof(IP));
  1977. }
  1978. }
  1979. }
  1980. }
  1981. }
  1982. FreePacketWithData(pkt);
  1983. FreeBlock(b);
  1984. }
  1985. if ((halt_tube != NULL && IsTubeConnected(halt_tube) == false) ||
  1986. IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false)
  1987. {
  1988. // Disconnected
  1989. break;
  1990. }
  1991. if (IsZeroIP(&yahoo_ip) == false)
  1992. {
  1993. // There is a response
  1994. break;
  1995. }
  1996. // Keep the CPU waiting
  1997. WaitForTubes(tubes, num_tubes, GetNextIntervalForInterrupt(interrupt));
  1998. }
  1999. FreeBuf(dns_query);
  2000. if (IsZeroIP(&yahoo_ip) == false)
  2001. {
  2002. BUF *tcp_query;
  2003. UINT seq = Rand32();
  2004. bool tcp_get_response = false;
  2005. UINT recv_seq = 0;
  2006. // Since the IP address of www.yahoo.com has gotten, try to connect by TCP
  2007. giveup_time = Tick64() + NN_CHECK_CONNECTIVITY_TIMEOUT;
  2008. AddInterrupt(interrupt, giveup_time);
  2009. // Generate a TCP packet
  2010. tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), src_port,
  2011. IPToUINT(&yahoo_ip), 80, seq, 0, TCP_SYN, 8192, 1414),
  2012. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0);
  2013. Debug("Test TCP to %r\n", &yahoo_ip);
  2014. next_send_tick = 0;
  2015. while (true)
  2016. {
  2017. UINT64 now = Tick64();
  2018. IPCFlushArpTable(a->Ipc);
  2019. if (now >= giveup_time)
  2020. {
  2021. break;
  2022. }
  2023. // Send the packet periodically
  2024. if (next_send_tick == 0 || next_send_tick <= now)
  2025. {
  2026. next_send_tick = now + (UINT64)NN_CHECK_CONNECTIVITY_INTERVAL;
  2027. AddInterrupt(interrupt, next_send_tick);
  2028. IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size);
  2029. }
  2030. // Happy procedure
  2031. IPCProcessL3Events(ipc);
  2032. while (true)
  2033. {
  2034. // Receive a packet
  2035. BLOCK *b = IPCRecvIPv4(ipc);
  2036. PKT *pkt;
  2037. if (b == NULL)
  2038. {
  2039. break;
  2040. }
  2041. // Parse the packet
  2042. pkt = ParsePacketIPv4WithDummyMacHeader(b->Buf, b->Size);
  2043. if (pkt != NULL)
  2044. {
  2045. if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_TCP &&
  2046. pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) &&
  2047. pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) &&
  2048. pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(src_port))
  2049. {
  2050. TCP_HEADER *tcp_header = (TCP_HEADER *)pkt->L4.TCPHeader;
  2051. if ((tcp_header->Flag & TCP_SYN) && (tcp_header->Flag & TCP_ACK))
  2052. {
  2053. // There was a TCP response
  2054. tcp_get_response = true;
  2055. recv_seq = Endian32(tcp_header->SeqNumber);
  2056. }
  2057. }
  2058. }
  2059. FreePacketWithData(pkt);
  2060. FreeBlock(b);
  2061. }
  2062. if ((halt_tube != NULL && IsTubeConnected(halt_tube) == false) ||
  2063. IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false)
  2064. {
  2065. // Disconnected
  2066. break;
  2067. }
  2068. if (tcp_get_response)
  2069. {
  2070. WHERE;
  2071. break;
  2072. }
  2073. // Keep the CPU waiting
  2074. WaitForTubes(tubes, num_tubes, GetNextIntervalForInterrupt(interrupt));
  2075. }
  2076. FreeBuf(tcp_query);
  2077. // Send a RST
  2078. if (recv_seq != 0)
  2079. {
  2080. recv_seq++;
  2081. }
  2082. tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), src_port,
  2083. IPToUINT(&yahoo_ip), 80, seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0),
  2084. IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0);
  2085. IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size);
  2086. FreeBuf(tcp_query);
  2087. SleepThread(100);
  2088. if (tcp_get_response)
  2089. {
  2090. ok = true;
  2091. }
  2092. }
  2093. FreeInterruptManager(interrupt);
  2094. return ok;
  2095. }
  2096. // Generate source port number by a random number
  2097. UINT NnGenSrcPort()
  2098. {
  2099. return 1025 + Rand32() % (65500 - 1025);
  2100. }
  2101. // Get a next good interface for the native NAT
  2102. NATIVE_STACK *NnGetNextInterface(NATIVE_NAT *t)
  2103. {
  2104. NATIVE_STACK *ret = NULL;
  2105. UINT current_hash;
  2106. TOKEN_LIST *device_list;
  2107. UINT i;
  2108. char tmp[MAX_SIZE];
  2109. char *dev_name;
  2110. UINT current_ip_hash;
  2111. // Validate arguments
  2112. if (t == NULL)
  2113. {
  2114. return NULL;
  2115. }
  2116. t->NextWaitTimeForRetry = NN_NEXT_WAIT_TIME_FOR_DEVICE_ENUM * MIN((t->FailedCount + 1), NN_NEXT_WAIT_TIME_MAX_FAIL_COUNT);
  2117. // Get the device list
  2118. device_list = GetEthList();
  2119. if (device_list == NULL || device_list->NumTokens == 0)
  2120. {
  2121. // Device list acquisition failure (Or no device acquired as a result)
  2122. FreeToken(device_list);
  2123. t->FailedCount++;
  2124. return NULL;
  2125. }
  2126. current_hash = GetEthDeviceHash();
  2127. current_ip_hash = GetHostIPAddressHash32();
  2128. if (t->LastInterfaceDeviceHash != current_hash || t->LastHostAddressHash != current_ip_hash)
  2129. {
  2130. // Device list is altered from the previous search
  2131. t->LastInterfaceIndex = INFINITE;
  2132. t->FailedCount = 0;
  2133. }
  2134. t->LastInterfaceDeviceHash = current_hash;
  2135. t->LastHostAddressHash = current_ip_hash;
  2136. if (t->LastInterfaceIndex == INFINITE)
  2137. {
  2138. i = 0;
  2139. }
  2140. else
  2141. {
  2142. i = t->LastInterfaceIndex + 1;
  2143. if (i >= device_list->NumTokens)
  2144. {
  2145. i = 0;
  2146. }
  2147. }
  2148. if ((i + 1) == device_list->NumTokens)
  2149. {
  2150. // Searched to the end
  2151. t->LastInterfaceIndex = INFINITE;
  2152. // Increase the number of search failures by one
  2153. t->FailedCount++;
  2154. }
  2155. else
  2156. {
  2157. // It is not the end yet
  2158. t->LastInterfaceIndex = i;
  2159. t->NextWaitTimeForRetry = 0;
  2160. }
  2161. dev_name = device_list->Token[i];
  2162. if (IsInLinesFile(NN_NO_NATIVE_NAT_FILENAME, dev_name, true) == false)
  2163. {
  2164. // Try to open the device
  2165. BinToStr(tmp, sizeof(tmp), t->v->MacAddress, 6);
  2166. ret = NewNativeStack(NULL, dev_name, tmp);
  2167. if (ret != NULL)
  2168. {
  2169. // Test whether an IP address can be obtained from a DHCP server
  2170. DHCP_OPTION_LIST opt;
  2171. Copy(t->CurrentMacAddress, ret->Ipc->MacAddress, 6);
  2172. Zero(&opt, sizeof(opt));
  2173. BinToStr(tmp, sizeof(tmp), ret->MacAddress, 6);
  2174. Format(ret->Ipc->ClientHostname, sizeof(ret->Ipc->ClientHostname), NN_HOSTNAME_FORMAT, tmp);
  2175. StrLower(ret->Ipc->ClientHostname);
  2176. Debug("IPCDhcpAllocateIP for %s\n", ret->DeviceName);
  2177. if (IPCDhcpAllocateIP(ret->Ipc, &opt, t->HaltTube2))
  2178. {
  2179. char client_ip[64];
  2180. char dhcp_ip[64];
  2181. char client_mask[64];
  2182. char gateway_ip[64];
  2183. IP ip;
  2184. IP subnet;
  2185. IP gw;
  2186. IPToStr32(client_ip, sizeof(client_ip), opt.ClientAddress);
  2187. IPToStr32(client_mask, sizeof(client_mask), opt.SubnetMask);
  2188. IPToStr32(dhcp_ip, sizeof(dhcp_ip), opt.ServerAddress);
  2189. IPToStr32(gateway_ip, sizeof(gateway_ip), opt.Gateway);
  2190. Debug("DHCP: client_ip=%s, client_mask=%s, dhcp_ip=%s, gateway_ip=%s\n",
  2191. client_ip, client_mask, dhcp_ip, gateway_ip);
  2192. Copy(&ret->CurrentDhcpOptionList, &opt, sizeof(DHCP_OPTION_LIST));
  2193. // IP parameter settings
  2194. UINTToIP(&ip, opt.ClientAddress);
  2195. UINTToIP(&subnet, opt.SubnetMask);
  2196. UINTToIP(&gw, opt.Gateway);
  2197. IPCSetIPv4Parameters(ret->Ipc, &ip, &subnet, &gw, &opt.ClasslessRoute);
  2198. // Determine the DNS server to use
  2199. UINTToIP(&ret->DnsServerIP, opt.DnsServer);
  2200. if (IsZeroIP(&ret->DnsServerIP))
  2201. {
  2202. // Use 8.8.8.8 instead If the DNS is not assigned from the DHCP server
  2203. SetIP(&ret->DnsServerIP, 8, 8, 8, 8);
  2204. }
  2205. // Connectivity test
  2206. // (always fail if the default gateway is not set)
  2207. if (opt.Gateway != 0 &&
  2208. NnTestConnectivity(ret, t->HaltTube2))
  2209. {
  2210. // Reset the number of search failures
  2211. t->FailedCount = 0;
  2212. Debug("Connectivity OK.\n");
  2213. }
  2214. else
  2215. {
  2216. Debug("Connectivity Failed.\n");
  2217. FreeNativeStack(ret);
  2218. ret = NULL;
  2219. }
  2220. }
  2221. else
  2222. {
  2223. Debug("DHCP Failed.\n");
  2224. FreeNativeStack(ret);
  2225. ret = NULL;
  2226. Zero(t->CurrentMacAddress, sizeof(t->CurrentMacAddress));
  2227. }
  2228. }
  2229. }
  2230. FreeToken(device_list);
  2231. return ret;
  2232. }
  2233. // Native NAT thread
  2234. void NativeNatThread(THREAD *thread, void *param)
  2235. {
  2236. NATIVE_NAT *t = (NATIVE_NAT *)param;
  2237. void *wait_handle = InitWaitUntilHostIPAddressChanged();
  2238. // Validate arguments
  2239. if (thread == NULL || param == NULL)
  2240. {
  2241. return;
  2242. }
  2243. while (t->Halt == false)
  2244. {
  2245. NATIVE_STACK *a;
  2246. while (t->v->UseNat == false || (t->v->HubOption != NULL && t->v->HubOption->DisableKernelModeSecureNAT))
  2247. {
  2248. if (t->Halt)
  2249. {
  2250. break;
  2251. }
  2252. // If the NAT is disabled, wait until it becomes enabled
  2253. Wait(t->HaltEvent, 1234);
  2254. }
  2255. if (t->Halt)
  2256. {
  2257. break;
  2258. }
  2259. // Get a next good native NAT stack
  2260. Debug("NnGetNextInterface Start.\n");
  2261. NnClearQueue(t);
  2262. a = NnGetNextInterface(t);
  2263. if (a != NULL)
  2264. {
  2265. char macstr[64];
  2266. // Acquisition success
  2267. Debug("NnGetNextInterface Ok: %s\n", a->DeviceName);
  2268. Lock(t->Lock);
  2269. {
  2270. if (a->Sock1 != NULL)
  2271. {
  2272. t->HaltTube = a->Sock2->RecvTube;
  2273. if (t->HaltTube != NULL)
  2274. {
  2275. AddRef(t->HaltTube->Ref);
  2276. }
  2277. }
  2278. }
  2279. Unlock(t->Lock);
  2280. NnClearQueue(t);
  2281. t->PublicIP = IPToUINT(&a->Ipc->ClientIPAddress);
  2282. t->Active = true;
  2283. Debug("NnMainLoop Start.\n");
  2284. MacToStr(macstr, sizeof(macstr), a->Ipc->MacAddress);
  2285. NLog(t->v, "LH_KERNEL_MODE_START", a->DeviceName,
  2286. &a->Ipc->ClientIPAddress, &a->Ipc->SubnetMask, &a->Ipc->DefaultGateway, &a->Ipc->BroadcastAddress,
  2287. macstr, &a->CurrentDhcpOptionList.ServerAddress, &a->DnsServerIP);
  2288. NnMainLoop(t, a);
  2289. Debug("NnMainLoop End.\n");
  2290. t->Active = false;
  2291. t->PublicIP = 0;
  2292. NnClearQueue(t);
  2293. // Close the stack
  2294. Lock(t->Lock);
  2295. {
  2296. if (t->HaltTube != NULL)
  2297. {
  2298. ReleaseTube(t->HaltTube);
  2299. t->HaltTube = NULL;
  2300. }
  2301. }
  2302. Unlock(t->Lock);
  2303. FreeNativeStack(a);
  2304. Zero(t->CurrentMacAddress, 6);
  2305. }
  2306. else
  2307. {
  2308. Debug("NnGetNextInterface Failed.\n");
  2309. }
  2310. // Wait for a certain period of time
  2311. if (t->NextWaitTimeForRetry != 0)
  2312. {
  2313. WaitUntilHostIPAddressChanged(wait_handle, t->HaltEvent, t->NextWaitTimeForRetry, 1000);
  2314. }
  2315. }
  2316. FreeWaitUntilHostIPAddressChanged(wait_handle);
  2317. }
  2318. // Erase the contents of the queue for transmission and reception
  2319. void NnClearQueue(NATIVE_NAT *t)
  2320. {
  2321. // Validate arguments
  2322. if (t == NULL)
  2323. {
  2324. return;
  2325. }
  2326. LockQueue(t->SendQueue);
  2327. {
  2328. while (true)
  2329. {
  2330. BLOCK *b = GetNext(t->SendQueue);
  2331. if (b == NULL)
  2332. {
  2333. break;
  2334. }
  2335. FreeBlock(b);
  2336. }
  2337. }
  2338. UnlockQueue(t->SendQueue);
  2339. LockQueue(t->RecvQueue);
  2340. {
  2341. while (true)
  2342. {
  2343. PKT *p = GetNext(t->RecvQueue);
  2344. if (p == NULL)
  2345. {
  2346. break;
  2347. }
  2348. FreePacketWithData(p);
  2349. }
  2350. }
  2351. UnlockQueue(t->RecvQueue);
  2352. }
  2353. // Structure setting function to search for native NAT
  2354. void NnSetNat(NATIVE_NAT_ENTRY *e, UINT protocol, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, UINT pub_ip, UINT pub_port)
  2355. {
  2356. // Validate arguments
  2357. if (e == NULL)
  2358. {
  2359. return;
  2360. }
  2361. Zero(e, sizeof(NATIVE_NAT_ENTRY));
  2362. e->Protocol = protocol;
  2363. e->SrcIp = src_ip;
  2364. e->SrcPort = src_port;
  2365. e->DestIp = dest_ip;
  2366. e->DestPort = dest_port;
  2367. e->PublicIp = pub_ip;
  2368. e->PublicPort = pub_port;
  2369. e->HashCodeForSend = e->HashCodeForRecv = INFINITE;
  2370. }
  2371. // Get the hash code of the native NAT table (receiving direction)
  2372. UINT GetHashNativeNatTableForRecv(void *p)
  2373. {
  2374. UINT r;
  2375. NATIVE_NAT_ENTRY *e = (NATIVE_NAT_ENTRY *)p;
  2376. if (e == NULL)
  2377. {
  2378. return 0;
  2379. }
  2380. if (e->HashCodeForRecv != INFINITE)
  2381. {
  2382. return e->HashCodeForRecv;
  2383. }
  2384. r = 0;
  2385. r += e->Protocol;
  2386. r += e->PublicIp;
  2387. r += e->PublicPort;
  2388. if (e->Protocol == NAT_TCP)
  2389. {
  2390. r += e->DestIp;
  2391. r += e->DestPort;
  2392. }
  2393. e->HashCodeForRecv = r;
  2394. return r;
  2395. }
  2396. // Comparison function of native NAT table (receiving direction)
  2397. int CmpNativeNatTableForRecv(void *p1, void *p2)
  2398. {
  2399. int r;
  2400. NATIVE_NAT_ENTRY *e1, *e2;
  2401. if (p1 == NULL || p2 == NULL)
  2402. {
  2403. return 0;
  2404. }
  2405. e1 = *(NATIVE_NAT_ENTRY **)p1;
  2406. e2 = *(NATIVE_NAT_ENTRY **)p2;
  2407. if (e1 == NULL || e2 == NULL)
  2408. {
  2409. return 0;
  2410. }
  2411. r = COMPARE_RET(e1->Protocol, e2->Protocol);
  2412. if (r != 0)
  2413. {
  2414. return r;
  2415. }
  2416. r = COMPARE_RET(e1->PublicIp, e2->PublicIp);
  2417. if (r != 0)
  2418. {
  2419. return r;
  2420. }
  2421. r = COMPARE_RET(e1->PublicPort, e2->PublicPort);
  2422. if (r != 0)
  2423. {
  2424. return r;
  2425. }
  2426. if (e1->Protocol == NAT_TCP)
  2427. {
  2428. r = COMPARE_RET(e1->DestIp, e2->DestIp);
  2429. if (r != 0)
  2430. {
  2431. return r;
  2432. }
  2433. r = COMPARE_RET(e1->DestPort, e2->DestPort);
  2434. if (r != 0)
  2435. {
  2436. return r;
  2437. }
  2438. }
  2439. return 0;
  2440. }
  2441. // Get the hash code of the native NAT table (transmit direction)
  2442. UINT GetHashNativeNatTableForSend(void *p)
  2443. {
  2444. UINT r;
  2445. NATIVE_NAT_ENTRY *e = (NATIVE_NAT_ENTRY *)p;
  2446. if (e == NULL)
  2447. {
  2448. return 0;
  2449. }
  2450. if (e->HashCodeForSend != INFINITE)
  2451. {
  2452. return e->HashCodeForSend;
  2453. }
  2454. r = 0;
  2455. r += e->Protocol;
  2456. r += e->SrcIp;
  2457. r += e->SrcPort;
  2458. if (e->Protocol == NAT_TCP)
  2459. {
  2460. r += e->DestIp;
  2461. r += e->DestPort;
  2462. }
  2463. e->HashCodeForSend = r;
  2464. return r;
  2465. }
  2466. // Comparison function of native NAT table (transmit direction)
  2467. int CmpNativeNatTableForSend(void *p1, void *p2)
  2468. {
  2469. int r;
  2470. NATIVE_NAT_ENTRY *e1, *e2;
  2471. if (p1 == NULL || p2 == NULL)
  2472. {
  2473. return 0;
  2474. }
  2475. e1 = *(NATIVE_NAT_ENTRY **)p1;
  2476. e2 = *(NATIVE_NAT_ENTRY **)p2;
  2477. if (e1 == NULL || e2 == NULL)
  2478. {
  2479. return 0;
  2480. }
  2481. r = COMPARE_RET(e1->Protocol, e2->Protocol);
  2482. if (r != 0)
  2483. {
  2484. return r;
  2485. }
  2486. r = COMPARE_RET(e1->SrcIp, e2->SrcIp);
  2487. if (r != 0)
  2488. {
  2489. return r;
  2490. }
  2491. r = COMPARE_RET(e1->SrcPort, e2->SrcPort);
  2492. if (r != 0)
  2493. {
  2494. return r;
  2495. }
  2496. if (e1->Protocol == NAT_TCP)
  2497. {
  2498. r = COMPARE_RET(e1->DestIp, e2->DestIp);
  2499. if (r != 0)
  2500. {
  2501. return r;
  2502. }
  2503. r = COMPARE_RET(e1->DestPort, e2->DestPort);
  2504. if (r != 0)
  2505. {
  2506. return r;
  2507. }
  2508. }
  2509. return 0;
  2510. }
  2511. // Start the native NAT
  2512. NATIVE_NAT *NewNativeNat(VH *v)
  2513. {
  2514. NATIVE_NAT *t;
  2515. // Validate arguments
  2516. if (v == NULL)
  2517. {
  2518. return NULL;
  2519. }
  2520. t = ZeroMalloc(sizeof(NATIVE_NAT));
  2521. t->v = v;
  2522. t->Cancel = v->Cancel;
  2523. AddRef(t->Cancel->ref);
  2524. // Data structure initialization
  2525. t->LastInterfaceIndex = INFINITE;
  2526. t->SendQueue = NewQueue();
  2527. t->RecvQueue = NewQueue();
  2528. NnInitIpCombineList(t);
  2529. t->Lock = NewLock();
  2530. t->CancelLock = NewLock();
  2531. t->HaltEvent = NewEvent();
  2532. NewTubePair(&t->HaltTube2, &t->HaltTube3, 0);
  2533. // Create a NAT table
  2534. t->NatTableForSend = NewHashList(GetHashNativeNatTableForSend, CmpNativeNatTableForSend, 11, true);
  2535. t->NatTableForRecv = NewHashList(GetHashNativeNatTableForRecv, CmpNativeNatTableForRecv, 11, true);
  2536. t->Thread = NewThread(NativeNatThread, t);
  2537. return t;
  2538. }
  2539. // Stop the native NAT
  2540. void FreeNativeNat(NATIVE_NAT *t)
  2541. {
  2542. TUBE *tube;
  2543. UINT i;
  2544. // Validate arguments
  2545. if (t == NULL)
  2546. {
  2547. return;
  2548. }
  2549. t->Halt = true;
  2550. Lock(t->Lock);
  2551. {
  2552. tube = t->HaltTube;
  2553. if (tube != NULL)
  2554. {
  2555. AddRef(tube->Ref);
  2556. }
  2557. }
  2558. Unlock(t->Lock);
  2559. if (tube != NULL)
  2560. {
  2561. TubeFlushEx(tube, true);
  2562. SleepThread(100);
  2563. TubeDisconnect(tube);
  2564. ReleaseTube(tube);
  2565. }
  2566. TubeDisconnect(t->HaltTube2);
  2567. TubeDisconnect(t->HaltTube3);
  2568. Set(t->HaltEvent);
  2569. WaitThread(t->Thread, INFINITE);
  2570. ReleaseThread(t->Thread);
  2571. DeleteLock(t->Lock);
  2572. DeleteLock(t->CancelLock);
  2573. ReleaseEvent(t->HaltEvent);
  2574. ReleaseTube(t->HaltTube2);
  2575. ReleaseTube(t->HaltTube3);
  2576. NnClearQueue(t);
  2577. ReleaseQueue(t->RecvQueue);
  2578. ReleaseQueue(t->SendQueue);
  2579. ReleaseCancel(t->Cancel);
  2580. // Release the NAT table
  2581. for (i = 0;i < LIST_NUM(t->NatTableForSend->AllList);i++)
  2582. {
  2583. NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForSend->AllList, i);
  2584. Free(e);
  2585. }
  2586. ReleaseHashList(t->NatTableForSend);
  2587. ReleaseHashList(t->NatTableForRecv);
  2588. NnFreeIpCombineList(t);
  2589. Free(t);
  2590. }
  2591. // Take the log of Virtual Host
  2592. void VLog(VH *v, char *str)
  2593. {
  2594. // Not take!!
  2595. return;
  2596. }
  2597. // Disconnect the NAT entry immediately
  2598. void DisconnectNatEntryNow(VH *v, NAT_ENTRY *e)
  2599. {
  2600. // Validate arguments
  2601. if (v == NULL || e == NULL)
  2602. {
  2603. return;
  2604. }
  2605. if (e->DisconnectNow == false)
  2606. {
  2607. e->DisconnectNow = true;
  2608. SetSockEvent(v->SockEvent);
  2609. }
  2610. }
  2611. // Get the NAT entry with specified source IP address and the oldest last communication time
  2612. NAT_ENTRY *GetOldestNatEntryOfIp(VH *v, UINT ip, UINT protocol)
  2613. {
  2614. UINT i;
  2615. NAT_ENTRY *oldest = NULL;
  2616. UINT64 oldest_tick = 0xFFFFFFFFFFFFFFFFULL;
  2617. // Validate arguments
  2618. if (v == NULL)
  2619. {
  2620. return NULL;
  2621. }
  2622. for (i = 0;i < LIST_NUM(v->NatTable);i++)
  2623. {
  2624. NAT_ENTRY *e = LIST_DATA(v->NatTable, i);
  2625. if (e->DisconnectNow == false)
  2626. {
  2627. if (e->SrcIp == ip)
  2628. {
  2629. if (e->Protocol == protocol)
  2630. {
  2631. if (protocol != NAT_TCP || e->TcpStatus != NAT_TCP_CONNECTING)
  2632. {
  2633. if (e->LastCommTime <= oldest_tick)
  2634. {
  2635. oldest_tick = e->LastCommTime;
  2636. oldest = e;
  2637. }
  2638. }
  2639. }
  2640. }
  2641. }
  2642. }
  2643. return oldest;
  2644. }
  2645. // Get the number of current NAT entries per IP address
  2646. UINT GetNumNatEntriesPerIp(VH *v, UINT ip, UINT protocol, bool tcp_syn_sent)
  2647. {
  2648. UINT ret = 0;
  2649. UINT i;
  2650. // Validate arguments
  2651. if (v == NULL)
  2652. {
  2653. return 0;
  2654. }
  2655. for (i = 0;i < LIST_NUM(v->NatTable);i++)
  2656. {
  2657. NAT_ENTRY *e = LIST_DATA(v->NatTable, i);
  2658. if (e->DisconnectNow == false)
  2659. {
  2660. if (e->SrcIp == ip)
  2661. {
  2662. if (e->Protocol == protocol)
  2663. {
  2664. bool ok = false;
  2665. if (protocol == NAT_TCP)
  2666. {
  2667. if (tcp_syn_sent)
  2668. {
  2669. if (e->TcpStatus == NAT_TCP_CONNECTING)
  2670. {
  2671. ok = true;
  2672. }
  2673. }
  2674. else
  2675. {
  2676. if (e->TcpStatus != NAT_TCP_CONNECTING)
  2677. {
  2678. ok = true;
  2679. }
  2680. }
  2681. }
  2682. else
  2683. {
  2684. ok = true;
  2685. }
  2686. if (ok)
  2687. {
  2688. ret++;
  2689. }
  2690. }
  2691. }
  2692. }
  2693. }
  2694. return ret;
  2695. }
  2696. // Check whether the NAT is available
  2697. bool CanCreateNewNatEntry(VH *v)
  2698. {
  2699. // Validate arguments
  2700. if (v == NULL)
  2701. {
  2702. return false;
  2703. }
  2704. if (v->UseNat == false)
  2705. {
  2706. // NAT stopped
  2707. return false;
  2708. }
  2709. if (NnIsActive(v) && v->NativeNat != NULL && v->NativeNat->NatTableForRecv != NULL)
  2710. {
  2711. if (v->NativeNat->NatTableForRecv->AllList->num_item > NAT_MAX_SESSIONS_KERNEL)
  2712. {
  2713. // Number of sessions exceeded (kernel mode)
  2714. return false;
  2715. }
  2716. }
  2717. else
  2718. {
  2719. if (v->NatTable->num_item > NAT_MAX_SESSIONS)
  2720. {
  2721. // Number of sessions exceeded (user mode)
  2722. return false;
  2723. }
  2724. }
  2725. return true;
  2726. }
  2727. // Set a pointer to the Virtual HUB options
  2728. void NatSetHubOption(VH *v, HUB_OPTION *o)
  2729. {
  2730. // Validate arguments
  2731. if (v == NULL)
  2732. {
  2733. return;
  2734. }
  2735. v->HubOption = o;
  2736. }
  2737. // Get a pointer to the Virtual HUB options
  2738. HUB_OPTION *NatGetHubOption(VH *v)
  2739. {
  2740. // Validate arguments
  2741. if (v == NULL)
  2742. {
  2743. return NULL;
  2744. }
  2745. return v->HubOption;
  2746. }
  2747. // The main function of NAT processing thread
  2748. void NatThreadMain(VH *v)
  2749. {
  2750. bool halt_flag;
  2751. // Validate arguments
  2752. if (v == NULL)
  2753. {
  2754. return;
  2755. }
  2756. v->TmpBuf = Malloc(NAT_TMPBUF_SIZE);
  2757. while (true)
  2758. {
  2759. // Wait until the next event is set
  2760. WaitSockEvent(v->SockEvent, SELECT_TIME);
  2761. halt_flag = false;
  2762. LockVirtual(v);
  2763. {
  2764. // Process on all NAT sessions
  2765. UINT i, num;
  2766. v->Now = Tick64();
  2767. v->NatDoCancelFlag = false;
  2768. LIST_ELEMENT_DELETED:
  2769. num = LIST_NUM(v->NatTable);
  2770. for (i = 0;i < num;i++)
  2771. {
  2772. NAT_ENTRY *n = LIST_DATA(v->NatTable, i);
  2773. switch (n->Protocol)
  2774. {
  2775. case NAT_TCP: // TCP
  2776. if (NatTransactTcp(v, n) == false)
  2777. {
  2778. goto LIST_ELEMENT_DELETED;
  2779. }
  2780. break;
  2781. case NAT_UDP: // UDP
  2782. if (NatTransactUdp(v, n) == false)
  2783. {
  2784. goto LIST_ELEMENT_DELETED;
  2785. }
  2786. break;
  2787. case NAT_ICMP: // ICMP
  2788. if (NatTransactIcmp(v, n) == false)
  2789. {
  2790. goto LIST_ELEMENT_DELETED;
  2791. }
  2792. break;
  2793. case NAT_DNS: // DNS
  2794. if (NatTransactDns(v, n) == false)
  2795. {
  2796. goto LIST_ELEMENT_DELETED;
  2797. }
  2798. break;
  2799. }
  2800. }
  2801. if (v->NatDoCancelFlag)
  2802. {
  2803. // Hit the cancel of the parent thread
  2804. Cancel(v->Cancel);
  2805. }
  2806. // Halting flag check
  2807. if (v->HaltNat)
  2808. {
  2809. halt_flag = true;
  2810. }
  2811. }
  2812. UnlockVirtual(v);
  2813. if (halt_flag)
  2814. {
  2815. // Terminate the thread by disconnecting all entries forcibly
  2816. LockVirtual(v);
  2817. {
  2818. UINT num = LIST_NUM(v->NatTable);
  2819. NAT_ENTRY **nn = ToArray(v->NatTable);
  2820. UINT i;
  2821. for (i = 0;i < num;i++)
  2822. {
  2823. NAT_ENTRY *n = nn[i];
  2824. n->DisconnectNow = true;
  2825. switch (n->Protocol)
  2826. {
  2827. case NAT_TCP: // TCP
  2828. NatTransactTcp(v, n);
  2829. break;
  2830. case NAT_UDP: // UDP
  2831. NatTransactUdp(v, n);
  2832. break;
  2833. case NAT_ICMP: // ICMP
  2834. NatTransactIcmp(v, n);
  2835. break;
  2836. case NAT_DNS: // DNS
  2837. NatTransactDns(v, n);
  2838. break;
  2839. }
  2840. }
  2841. Free(nn);
  2842. }
  2843. UnlockVirtual(v);
  2844. break;
  2845. }
  2846. }
  2847. Free(v->TmpBuf);
  2848. }
  2849. // DNS: Thread to get the IP address
  2850. void NatGetIPThread(THREAD *t, void *param)
  2851. {
  2852. NAT_DNS_QUERY *q;
  2853. // Validate arguments
  2854. if (t == NULL || param == NULL)
  2855. {
  2856. return;
  2857. }
  2858. q = (NAT_DNS_QUERY *)param;
  2859. AddWaitThread(t);
  2860. q->Ok = GetIP(&q->Ip, q->Hostname);
  2861. DelWaitThread(t);
  2862. if (Release(q->ref) == 0)
  2863. {
  2864. Free(q);
  2865. }
  2866. }
  2867. // DNS: Get an IP address from host name
  2868. bool NatGetIP(IP *ip, char *hostname)
  2869. {
  2870. TOKEN_LIST *t;
  2871. bool ret = false;
  2872. // Validate arguments
  2873. if (ip == NULL || hostname == NULL)
  2874. {
  2875. return false;
  2876. }
  2877. t = ParseToken(hostname, ".");
  2878. if (t == NULL)
  2879. {
  2880. return false;
  2881. }
  2882. if (t->NumTokens == 0)
  2883. {
  2884. FreeToken(t);
  2885. return false;
  2886. }
  2887. if (t->NumTokens == 1)
  2888. {
  2889. ret = GetIP(ip, hostname);
  2890. }
  2891. else
  2892. {
  2893. char *hostname2 = t->Token[0];
  2894. NAT_DNS_QUERY *q1, *q2;
  2895. THREAD *t1, *t2;
  2896. q1 = ZeroMalloc(sizeof(NAT_DNS_QUERY));
  2897. q2 = ZeroMalloc(sizeof(NAT_DNS_QUERY));
  2898. q1->ref = NewRef();
  2899. q2->ref = NewRef();
  2900. AddRef(q1->ref);
  2901. AddRef(q2->ref);
  2902. StrCpy(q1->Hostname, sizeof(q1->Hostname), hostname);
  2903. StrCpy(q2->Hostname, sizeof(q2->Hostname), hostname2);
  2904. t1 = NewThread(NatGetIPThread, q1);
  2905. t2 = NewThread(NatGetIPThread, q2);
  2906. WaitThread(t1, NAT_DNS_QUERY_TIMEOUT);
  2907. if (q1->Ok)
  2908. {
  2909. ret = true;
  2910. Copy(ip, &q1->Ip, sizeof(IP));
  2911. }
  2912. else
  2913. {
  2914. WaitThread(t2, NAT_DNS_QUERY_TIMEOUT);
  2915. if (q1->Ok)
  2916. {
  2917. ret = true;
  2918. Copy(ip, &q1->Ip, sizeof(IP));
  2919. }
  2920. else if (q2->Ok)
  2921. {
  2922. ret = true;
  2923. Copy(ip, &q2->Ip, sizeof(IP));
  2924. }
  2925. }
  2926. ReleaseThread(t1);
  2927. ReleaseThread(t2);
  2928. if (Release(q1->ref) == 0)
  2929. {
  2930. Free(q1);
  2931. }
  2932. if (Release(q2->ref) == 0)
  2933. {
  2934. Free(q2);
  2935. }
  2936. }
  2937. FreeToken(t);
  2938. return ret;
  2939. }
  2940. // DNS query function
  2941. void NatDnsThread(THREAD *t, void *param)
  2942. {
  2943. NAT_ENTRY *n;
  2944. IP ip;
  2945. // Validate arguments
  2946. if (t == NULL || param == NULL)
  2947. {
  2948. return;
  2949. }
  2950. n = (NAT_ENTRY *)param;
  2951. // Notify the initialization completion
  2952. NoticeThreadInit(t);
  2953. // Run processing
  2954. if (EndWith(n->DnsTargetHostName, ".in-addr.arpa") == false)
  2955. {
  2956. // Forward resolution
  2957. if (NatGetIP(&ip, n->DnsTargetHostName))
  2958. {
  2959. // Forward resolution success
  2960. Copy(&n->DnsResponseIp, &ip, sizeof(IP));
  2961. n->DnsOk = true;
  2962. }
  2963. }
  2964. else
  2965. {
  2966. // Reverse resolution
  2967. IP ip;
  2968. n->DnsGetIpFromHost = true; // Set the reverse resolution flag
  2969. // Convert a *.in-addr.arpa string to an IP address
  2970. if (ArpaToIP(&ip, n->DnsTargetHostName))
  2971. {
  2972. // Reverse resolution process
  2973. char tmp[256];
  2974. if (GetHostName(tmp, sizeof(tmp), &ip))
  2975. {
  2976. // Reverse resolution success
  2977. n->DnsResponseHostName = CopyStr(tmp);
  2978. n->DnsOk = true;
  2979. }
  2980. }
  2981. }
  2982. // Notify the results
  2983. n->DnsFinished = true;
  2984. SetSockEvent(n->v->SockEvent);
  2985. }
  2986. // Convert a reverse resolution address to an IP address
  2987. bool ArpaToIP(IP *ip, char *str)
  2988. {
  2989. TOKEN_LIST *token;
  2990. bool ret = false;
  2991. // Validate arguments
  2992. if (ip == NULL || str == NULL)
  2993. {
  2994. return false;
  2995. }
  2996. // Token conversion
  2997. token = ParseToken(str, ".");
  2998. if (token->NumTokens == 6)
  2999. {
  3000. // Convert the token [0, 1, 2, 3] to IP
  3001. UINT i;
  3002. Zero(ip, sizeof(IP));
  3003. for (i = 0;i < 4;i++)
  3004. {
  3005. ip->addr[i] = (UCHAR)ToInt(token->Token[3 - i]);
  3006. }
  3007. ret = true;
  3008. }
  3009. FreeToken(token);
  3010. if (IPToUINT(ip) == 0)
  3011. {
  3012. ret = false;
  3013. }
  3014. return ret;
  3015. }
  3016. // Handle a DNS entry
  3017. bool NatTransactDns(VH *v, NAT_ENTRY *n)
  3018. {
  3019. // Validate arguments
  3020. if (v == NULL || n == NULL)
  3021. {
  3022. return true;
  3023. }
  3024. if (n->DisconnectNow)
  3025. {
  3026. goto DISCONNECT;
  3027. }
  3028. if (n->DnsThread == NULL && n->DnsFinished == false)
  3029. {
  3030. // Create a thread
  3031. THREAD *t = NewThread(NatDnsThread, (void *)n);
  3032. WaitThreadInit(t);
  3033. n->DnsThread = t;
  3034. }
  3035. else
  3036. {
  3037. // Wait for the result
  3038. if (n->DnsFinished)
  3039. {
  3040. // Results have been received
  3041. WaitThread(n->DnsThread, INFINITE);
  3042. ReleaseThread(n->DnsThread);
  3043. n->DnsThread = NULL;
  3044. // Notify to the main thread
  3045. v->NatDoCancelFlag = true;
  3046. }
  3047. }
  3048. return true;
  3049. DISCONNECT:
  3050. // Releasing process
  3051. if (n->DnsThread != NULL)
  3052. {
  3053. WaitThread(n->DnsThread, INFINITE);
  3054. ReleaseThread(n->DnsThread);
  3055. n->DnsThread = NULL;
  3056. }
  3057. if (n->DnsTargetHostName != NULL)
  3058. {
  3059. Free(n->DnsTargetHostName);
  3060. n->DnsTargetHostName = NULL;
  3061. }
  3062. if (n->DnsResponseHostName != NULL)
  3063. {
  3064. Free(n->DnsResponseHostName);
  3065. n->DnsResponseHostName = NULL;
  3066. }
  3067. DeleteLock(n->lock);
  3068. Delete(v->NatTable, n);
  3069. Free(n);
  3070. return false;
  3071. }
  3072. // ICMP thread procedure
  3073. void NatIcmpThreadProc(THREAD *thread, void *param)
  3074. {
  3075. NAT_ENTRY *n;
  3076. ICMP_RESULT *ret = NULL;
  3077. USHORT src_id = 0, src_seqno = 0;
  3078. // Validate arguments
  3079. if (thread == NULL || param == NULL)
  3080. {
  3081. return;
  3082. }
  3083. n = (NAT_ENTRY *)param;
  3084. if (n->IcmpQueryBlock)
  3085. {
  3086. UCHAR *data = n->IcmpQueryBlock->Buf;
  3087. UINT size = n->IcmpQueryBlock->Size;
  3088. if (size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)))
  3089. {
  3090. ICMP_HEADER *icmp = (ICMP_HEADER *)data;
  3091. ICMP_ECHO *echo = (ICMP_ECHO *)(data + sizeof(ICMP_HEADER));
  3092. if (icmp->Type == ICMP_TYPE_ECHO_REQUEST && icmp->Code == 0)
  3093. {
  3094. UCHAR *icmp_payload = data + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO);
  3095. UINT icmp_payload_size = size - sizeof(ICMP_HEADER) - sizeof(ICMP_ECHO);
  3096. IP dest_ip;
  3097. src_id = Endian16(echo->Identifier);
  3098. src_seqno = Endian16(echo->SeqNo);
  3099. UINTToIP(&dest_ip, n->DestIp);
  3100. // Send a query by using the ICMP API
  3101. ret = IcmpApiEchoSend(&dest_ip, n->IcmpQueryBlock->Ttl,
  3102. icmp_payload, icmp_payload_size, NAT_ICMP_TIMEOUT_WITH_API);
  3103. }
  3104. }
  3105. }
  3106. if (ret != NULL && ret->Timeout == false)
  3107. {
  3108. // Convert to an IPv4 + ICMP packet since the result of ICMP API was obtained
  3109. IPV4_HEADER ipv4;
  3110. ICMP_HEADER icmp;
  3111. ICMP_ECHO echo;
  3112. BUF *buf = NewBuf();
  3113. // IPv4 header
  3114. Zero(&ipv4, sizeof(ipv4));
  3115. IPV4_SET_VERSION(&ipv4, 4);
  3116. IPV4_SET_HEADER_LEN(&ipv4, sizeof(IPV4_HEADER) / 4);
  3117. ipv4.TimeToLive = ret->Ttl;
  3118. ipv4.Protocol = IP_PROTO_ICMPV4;
  3119. ipv4.SrcIP = IPToUINT(&ret->IpAddress);
  3120. ipv4.DstIP = 0x01010101;
  3121. // ICMP header
  3122. Zero(&icmp, sizeof(icmp));
  3123. Zero(&echo, sizeof(echo));
  3124. if (ret->Ok)
  3125. {
  3126. // Normal response
  3127. echo.Identifier = Endian16(src_id);
  3128. echo.SeqNo = Endian16(src_seqno);
  3129. ipv4.TotalLength = Endian16((USHORT)(sizeof(ipv4) + sizeof(icmp) + sizeof(echo) + ret->DataSize));
  3130. WriteBuf(buf, &ipv4, sizeof(ipv4));
  3131. WriteBuf(buf, &icmp, sizeof(icmp));
  3132. WriteBuf(buf, &echo, sizeof(echo));
  3133. WriteBuf(buf, ret->Data, ret->DataSize);
  3134. }
  3135. else
  3136. {
  3137. // Error reply
  3138. icmp.Type = ret->Type;
  3139. icmp.Code = ret->Code;
  3140. echo.Identifier = Endian16(src_id);
  3141. echo.SeqNo = Endian16(src_seqno);
  3142. ipv4.TotalLength = Endian16((USHORT)(sizeof(ipv4) + sizeof(icmp) + sizeof(echo) + n->IcmpOriginalCopySize));
  3143. WriteBuf(buf, &ipv4, sizeof(ipv4));
  3144. WriteBuf(buf, &icmp, sizeof(icmp));
  3145. WriteBuf(buf, &echo, sizeof(echo));
  3146. // Copy of the original packet to be included in the response packet
  3147. WriteBuf(buf, n->IcmpOriginalCopy, n->IcmpOriginalCopySize);
  3148. }
  3149. n->IcmpResponseBlock = NewBlock(Clone(buf->Buf, buf->Size), buf->Size, 0);
  3150. n->IcmpResponseBlock->Ttl = ret->Ttl;
  3151. FreeBuf(buf);
  3152. }
  3153. IcmpApiFreeResult(ret);
  3154. // Inform the completion of the processing
  3155. n->IcmpTaskFinished = true;
  3156. SetSockEvent(n->v->SockEvent);
  3157. }
  3158. // Process ICMP entry
  3159. bool NatTransactIcmp(VH *v, NAT_ENTRY *n)
  3160. {
  3161. void *buf;
  3162. UINT recv_size;
  3163. BLOCK *block;
  3164. UINT dest_port = n->DestPort;
  3165. IP dest_ip;
  3166. UINT num_ignore_errors = 0;
  3167. // Validate arguments
  3168. if (v == NULL || n == NULL)
  3169. {
  3170. return true;
  3171. }
  3172. if (n->DisconnectNow)
  3173. {
  3174. goto DISCONNECT;
  3175. }
  3176. if (v->IcmpRawSocketOk)
  3177. {
  3178. // Environment that the Raw sockets are available
  3179. if (n->UdpSocketCreated == false)
  3180. {
  3181. // Create a UDP socket
  3182. n->Sock = NewUDP(MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4));
  3183. if (n->Sock == NULL)
  3184. {
  3185. // Socket creation failure
  3186. goto DISCONNECT;
  3187. }
  3188. else
  3189. {
  3190. n->PublicIp = IPToUINT(&n->Sock->LocalIP);
  3191. n->PublicPort = n->Sock->LocalPort;
  3192. JoinSockToSockEvent(n->Sock, v->SockEvent);
  3193. n->UdpSocketCreated = true;
  3194. }
  3195. }
  3196. }
  3197. else
  3198. {
  3199. // Create a thread for using ICMP API if Raw sockets are not available
  3200. if (n->IcmpThread == NULL)
  3201. {
  3202. if (n->UdpSendQueue->num_item >= 1)
  3203. {
  3204. // Since UdpSendQueue contains only 1 query, get a first query
  3205. // and create a thread and pass the query to the thread
  3206. BLOCK *block = GetNext(n->UdpSendQueue);
  3207. n->IcmpQueryBlock = block;
  3208. n->IcmpThread = NewThread(NatIcmpThreadProc, n);
  3209. }
  3210. }
  3211. if (n->IcmpTaskFinished)
  3212. {
  3213. if (n->IcmpResponseBlock != NULL)
  3214. {
  3215. // Because there was a response from the thread that calls ICMP API, pass this result to the stack
  3216. block = n->IcmpResponseBlock;
  3217. n->IcmpResponseBlock = NULL;
  3218. InsertQueue(n->UdpRecvQueue, block);
  3219. v->NatDoCancelFlag = true;
  3220. n->LastCommTime = v->Now;
  3221. }
  3222. else
  3223. {
  3224. // Disconnect immediately when it fails
  3225. goto DISCONNECT;
  3226. }
  3227. }
  3228. // Examine whether this session timed-out
  3229. if ((n->LastCommTime + (UINT64)NAT_ICMP_TIMEOUT_WITH_API) < v->Now || n->LastCommTime > v->Now)
  3230. {
  3231. // Time-out
  3232. goto DISCONNECT;
  3233. }
  3234. return true;
  3235. }
  3236. // Following are processed only for if the raw sockets are available
  3237. buf = v->TmpBuf;
  3238. UINTToIP(&dest_ip, n->DestIp);
  3239. // Try to receive data from the UDP socket
  3240. while (true)
  3241. {
  3242. IP src_ip;
  3243. UINT src_port;
  3244. recv_size = RecvFrom(n->Sock, &src_ip, &src_port, buf, 65536);
  3245. if (recv_size == SOCK_LATER)
  3246. {
  3247. // Packet has not arrived
  3248. break;
  3249. }
  3250. else if (recv_size == 0)
  3251. {
  3252. Debug("ICMP ERROR\n");
  3253. // Error?
  3254. if (n->Sock->IgnoreRecvErr == false)
  3255. {
  3256. // A fatal error occurred
  3257. goto DISCONNECT;
  3258. }
  3259. else
  3260. {
  3261. if ((num_ignore_errors++) >= MAX_NUM_IGNORE_ERRORS)
  3262. {
  3263. goto DISCONNECT;
  3264. }
  3265. }
  3266. }
  3267. else
  3268. {
  3269. // Analyze the arriving packet
  3270. ICMP_RESULT *ret = IcmpParseResult(&dest_ip, n->SrcPort, 0, buf, recv_size);
  3271. if (ret != NULL)
  3272. {
  3273. if ((ret->Ok && CmpIpAddr(&ret->IpAddress, &dest_ip) == 0) ||
  3274. (ret->DataSize >= sizeof(IPV4_HEADER) && ((IPV4_HEADER *)ret->Data)->DstIP == n->DestIp))
  3275. {
  3276. // Insert to the queue
  3277. void *data = Malloc(recv_size);
  3278. Copy(data, buf, recv_size);
  3279. block = NewBlock(data, recv_size, 0);
  3280. InsertQueue(n->UdpRecvQueue, block);
  3281. v->NatDoCancelFlag = true;
  3282. n->LastCommTime = v->Now;
  3283. }
  3284. IcmpFreeResult(ret);
  3285. }
  3286. }
  3287. }
  3288. // Try to send data to the UDP socket
  3289. while (block = GetNext(n->UdpSendQueue))
  3290. {
  3291. // Assemble the Echo header and ICMP header
  3292. UINT send_size;
  3293. SetTtl(n->Sock, block->Ttl);
  3294. send_size = SendTo(n->Sock, &dest_ip, dest_port, block->Buf, block->Size);
  3295. FreeBlock(block);
  3296. if (send_size == 0)
  3297. {
  3298. Debug("ICMP ERROR\n");
  3299. // Determine whether a fatal error
  3300. if (n->Sock->IgnoreSendErr == false)
  3301. {
  3302. // A fatal error occurred
  3303. goto DISCONNECT;
  3304. }
  3305. }
  3306. else
  3307. {
  3308. n->LastCommTime = v->Now;
  3309. }
  3310. }
  3311. // Examine whether this session timed-out
  3312. if ((n->LastCommTime + (UINT64)NAT_ICMP_TIMEOUT) < v->Now || n->LastCommTime > v->Now)
  3313. {
  3314. // Time-out
  3315. goto DISCONNECT;
  3316. }
  3317. return true;
  3318. DISCONNECT:
  3319. // Disconnect this session
  3320. if (n->UdpSocketCreated)
  3321. {
  3322. // Close the socket
  3323. Disconnect(n->Sock);
  3324. ReleaseSock(n->Sock);
  3325. n->Sock = NULL;
  3326. }
  3327. // Terminate if the thread has been created
  3328. if (n->IcmpThread != NULL)
  3329. {
  3330. WaitThread(n->IcmpThread, INFINITE);
  3331. ReleaseThread(n->IcmpThread);
  3332. n->IcmpThread = NULL;
  3333. }
  3334. // Delete the entry
  3335. DeleteNatIcmp(v, n);
  3336. return false;
  3337. }
  3338. // Process the UDP entry
  3339. bool NatTransactUdp(VH *v, NAT_ENTRY *n)
  3340. {
  3341. void *buf;
  3342. UINT recv_size;
  3343. BLOCK *block;
  3344. UINT dest_port = n->DestPort;
  3345. IP dest_ip;
  3346. UINT num_ignore_errors;
  3347. // Validate arguments
  3348. if (v == NULL || n == NULL)
  3349. {
  3350. return true;
  3351. }
  3352. if (n->DisconnectNow)
  3353. {
  3354. goto DISCONNECT;
  3355. }
  3356. if (n->UdpSocketCreated == false)
  3357. {
  3358. // Create a UDP socket
  3359. n->Sock = NewUDP(0);
  3360. if (n->Sock == NULL)
  3361. {
  3362. // Socket creation failure
  3363. goto DISCONNECT;
  3364. }
  3365. else
  3366. {
  3367. n->PublicIp = IPToUINT(&n->Sock->LocalIP);
  3368. n->PublicPort = n->Sock->LocalPort;
  3369. JoinSockToSockEvent(n->Sock, v->SockEvent);
  3370. n->UdpSocketCreated = true;
  3371. }
  3372. }
  3373. buf = v->TmpBuf;
  3374. if (n->ProxyDns == false)
  3375. {
  3376. UINTToIP(&dest_ip, n->DestIp);
  3377. }
  3378. else
  3379. {
  3380. UINTToIP(&dest_ip, n->DestIpProxy);
  3381. }
  3382. num_ignore_errors = 0;
  3383. // Try to receive data from the UDP socket
  3384. while (true)
  3385. {
  3386. IP src_ip;
  3387. UINT src_port;
  3388. recv_size = RecvFrom(n->Sock, &src_ip, &src_port, buf, 65536);
  3389. if (recv_size == SOCK_LATER)
  3390. {
  3391. // Packet has not arrived
  3392. break;
  3393. }
  3394. else if (recv_size == 0)
  3395. {
  3396. // Error?
  3397. if (n->Sock->IgnoreRecvErr == false)
  3398. {
  3399. // A fatal error occurred
  3400. goto DISCONNECT;
  3401. }
  3402. else
  3403. {
  3404. if ((num_ignore_errors++) > MAX_NUM_IGNORE_ERRORS)
  3405. {
  3406. goto DISCONNECT;
  3407. }
  3408. }
  3409. }
  3410. else
  3411. {
  3412. // Packet arrives. Check the source IP
  3413. if (IPToUINT(&src_ip) == n->DestIp || n->DestIp == 0xFFFFFFFF || (IPToUINT(&src_ip) == n->DestIpProxy && n->ProxyDns) && src_port == n->DestPort)
  3414. {
  3415. // Insert to the queue
  3416. void *data = Malloc(recv_size);
  3417. Copy(data, buf, recv_size);
  3418. block = NewBlock(data, recv_size, 0);
  3419. if (block != NULL)
  3420. {
  3421. if (src_port == SPECIAL_UDP_PORT_WSD || src_port == SPECIAL_UDP_PORT_SSDP)
  3422. {
  3423. // Make believe there is a response from the host really in the case of WSD packet
  3424. block->Param1 = IPToUINT(&src_ip);
  3425. }
  3426. }
  3427. InsertQueue(n->UdpRecvQueue, block);
  3428. v->NatDoCancelFlag = true;
  3429. n->LastCommTime = v->Now;
  3430. }
  3431. }
  3432. }
  3433. // Try to send data to the UDP socket
  3434. while (block = GetNext(n->UdpSendQueue))
  3435. {
  3436. UINT send_size;
  3437. bool is_nbtdgm = false;
  3438. LIST *local_ip_list = NULL;
  3439. if (dest_port == SPECIAL_UDP_PORT_NBTDGM)
  3440. {
  3441. // Determine whether NetBIOS Datagram packet
  3442. NBTDG_HEADER *nh = (NBTDG_HEADER *)block->Buf;
  3443. if (nh != NULL && block->Size >= sizeof(NBTDG_HEADER))
  3444. {
  3445. if (nh->SrcIP == n->SrcIp && Endian16(nh->SrcPort) == n->SrcPort)
  3446. {
  3447. local_ip_list = GetHostIPAddressList();
  3448. if (local_ip_list != NULL)
  3449. {
  3450. is_nbtdgm = true;
  3451. }
  3452. }
  3453. }
  3454. }
  3455. if (is_nbtdgm == false)
  3456. {
  3457. // Normal UDP packet
  3458. send_size = SendTo(n->Sock, &dest_ip, dest_port, block->Buf, block->Size);
  3459. }
  3460. else
  3461. {
  3462. // IP address and port number is embedded in the NetBIOS Datagram Packet.
  3463. // Transfer by rewriting it properly
  3464. UINT i;
  3465. for (i = 0;i < LIST_NUM(local_ip_list);i++)
  3466. {
  3467. IP *my_ip = LIST_DATA(local_ip_list, i);
  3468. if (IsIP4(my_ip) && IsZeroIp(my_ip) == false && IsLocalHostIP(my_ip) == false)
  3469. {
  3470. NBTDG_HEADER *nh = (NBTDG_HEADER *)block->Buf;
  3471. nh->SrcIP = IPToUINT(my_ip);
  3472. nh->SrcPort = Endian16(n->PublicPort);
  3473. send_size = SendTo(n->Sock, &dest_ip, dest_port, block->Buf, block->Size);
  3474. }
  3475. }
  3476. }
  3477. if (local_ip_list != NULL)
  3478. {
  3479. FreeHostIPAddressList(local_ip_list);
  3480. }
  3481. FreeBlock(block);
  3482. if (send_size == 0)
  3483. {
  3484. // Determining whether a fatal error
  3485. if (n->Sock->IgnoreSendErr == false)
  3486. {
  3487. // A fatal error occurred
  3488. goto DISCONNECT;
  3489. }
  3490. }
  3491. else
  3492. {
  3493. n->LastCommTime = v->Now;
  3494. }
  3495. }
  3496. // Examine whether this session timed-out
  3497. if ((n->LastCommTime + (UINT64)v->NatUdpTimeout) < v->Now || n->LastCommTime > v->Now)
  3498. {
  3499. // Time-out
  3500. goto DISCONNECT;
  3501. }
  3502. return true;
  3503. DISCONNECT:
  3504. // Disconnect this session
  3505. if (n->UdpSocketCreated)
  3506. {
  3507. // Close the socket
  3508. Disconnect(n->Sock);
  3509. ReleaseSock(n->Sock);
  3510. n->Sock = NULL;
  3511. }
  3512. // Delete the entry
  3513. DeleteNatUdp(v, n);
  3514. return false;
  3515. }
  3516. // Thread to make a connection to the TCP host
  3517. void NatTcpConnectThread(THREAD *t, void *p)
  3518. {
  3519. NAT_ENTRY *n = (NAT_ENTRY *)p;
  3520. IP ip;
  3521. char hostname[MAX_SIZE];
  3522. UINT port_number;
  3523. SOCK *sock;
  3524. SOCK_EVENT *e;
  3525. // Validate arguments
  3526. if (n == NULL || t == NULL)
  3527. {
  3528. return;
  3529. }
  3530. UINTToIP(&ip, n->DestIp);
  3531. IPToStr(hostname, sizeof(hostname), &ip);
  3532. port_number = n->DestPort;
  3533. e = n->v->SockEvent;
  3534. AddRef(e->ref);
  3535. // Notify the initialization completion
  3536. NoticeThreadInit(t);
  3537. // Attempt to connect to the TCP host
  3538. Debug("NatTcpConnect Connecting to %s:%u\n", hostname, port_number);
  3539. sock = ConnectEx3(hostname, port_number, 0, &n->NatTcpCancelFlag, NULL, NULL, false, false, true);
  3540. if (sock == NULL)
  3541. {
  3542. // Connection failure
  3543. n->TcpMakeConnectionFailed = true;
  3544. }
  3545. else
  3546. {
  3547. // Successful connection
  3548. n->TcpMakeConnectionSucceed = true;
  3549. }
  3550. n->Sock = sock;
  3551. JoinSockToSockEvent(sock, e);
  3552. SetSockEvent(e);
  3553. ReleaseSockEvent(e);
  3554. }
  3555. // Create a thread for trying to connect to the TCP host
  3556. void CreateNatTcpConnectThread(VH *v, NAT_ENTRY *n)
  3557. {
  3558. // Validate arguments
  3559. if (v == NULL || n == NULL)
  3560. {
  3561. return;
  3562. }
  3563. // Create a thread
  3564. n->NatTcpConnectThread = NewThread(NatTcpConnectThread, (void *)n);
  3565. // Wait for a thread initialization completion
  3566. WaitThreadInit(n->NatTcpConnectThread);
  3567. }
  3568. // Handle the TCP entry
  3569. bool NatTransactTcp(VH *v, NAT_ENTRY *n)
  3570. {
  3571. char str[MAX_SIZE];
  3572. bool timeouted = false;
  3573. // Validate arguments
  3574. if (v == NULL || n == NULL)
  3575. {
  3576. return false;
  3577. }
  3578. if (n->DisconnectNow)
  3579. {
  3580. goto DISCONNECT;
  3581. }
  3582. // Process by state of the TCP
  3583. switch (n->TcpStatus)
  3584. {
  3585. case NAT_TCP_CONNECTING: // Waiting for connection
  3586. if (n->NatTcpConnectThread == NULL)
  3587. {
  3588. // Start a connection by creating a connection thread
  3589. CreateNatTcpConnectThread(v, n);
  3590. }
  3591. else
  3592. {
  3593. // Wait for the result of the connection thread that has already started
  3594. if (n->TcpMakeConnectionFailed || n->TcpMakeConnectionSucceed)
  3595. {
  3596. // Use the results because operation thread has already finished
  3597. WaitThread(n->NatTcpConnectThread, INFINITE);
  3598. ReleaseThread(n->NatTcpConnectThread);
  3599. n->NatTcpConnectThread = NULL;
  3600. if (n->TcpMakeConnectionSucceed)
  3601. {
  3602. // Connection is successful, and a Sock was created
  3603. n->TcpStatus = NAT_TCP_CONNECTED;
  3604. IPToStr32(str, sizeof(str), n->DestIp);
  3605. NLog(v, "LH_NAT_TCP_SUCCEED", n->Id, n->Sock->RemoteHostname, str, n->DestPort);
  3606. }
  3607. else
  3608. {
  3609. // Failed to connect
  3610. n->TcpStatus = NAT_TCP_SEND_RESET;
  3611. IPToStr32(str, sizeof(str), n->DestIp);
  3612. NLog(v, "LH_NAT_TCP_FAILED", n->Id, str, n->DestPort);
  3613. }
  3614. v->NatDoCancelFlag = true;
  3615. }
  3616. }
  3617. break;
  3618. case NAT_TCP_CONNECTED: // TCP socket connection completed. Negotiating with the client host
  3619. break;
  3620. case NAT_TCP_SEND_RESET: // TCP communication disconnection: Send a RST to the client host
  3621. break;
  3622. case NAT_TCP_ESTABLISHED: // TCP connection established
  3623. {
  3624. UINT old_send_fifo_size = 0;
  3625. // Transmit to the socket if there is data in the receive buffer
  3626. while (n->RecvFifo->size > 0)
  3627. {
  3628. UINT sent_size = Send(n->Sock, ((UCHAR *)n->RecvFifo->p) + n->RecvFifo->pos,
  3629. n->RecvFifo->size, false);
  3630. if (sent_size == 0)
  3631. {
  3632. // Communication has been disconnected
  3633. n->TcpFinished = true;
  3634. v->NatDoCancelFlag = true;
  3635. break;
  3636. }
  3637. else if (sent_size == SOCK_LATER)
  3638. {
  3639. // Blocking
  3640. break;
  3641. }
  3642. else
  3643. {
  3644. // Successful transmission
  3645. ReadFifo(n->RecvFifo, NULL, sent_size);
  3646. n->SendAckNext = true;
  3647. if (false)
  3648. {
  3649. IP ip;
  3650. n->test_TotalSent += sent_size;
  3651. UINTToIP(&ip, n->DestIp);
  3652. Debug("TCP %u: %r:%u %u\n", n->Id, &ip, n->DestPort, (UINT)n->test_TotalSent);
  3653. }
  3654. }
  3655. }
  3656. old_send_fifo_size = FifoSize(n->SendFifo);
  3657. // Write to the transmission buffer by obtaining data from the socket
  3658. while (true)
  3659. {
  3660. void *buf = (void *)v->TmpBuf;
  3661. UINT want_to_recv_size = 0;
  3662. UINT recv_size;
  3663. // Calculate the size of wanting to receive
  3664. if (n->SendFifo->size < NAT_SEND_BUF_SIZE)
  3665. {
  3666. // Still can receive
  3667. want_to_recv_size = MIN(NAT_SEND_BUF_SIZE - n->SendFifo->size, NAT_TMPBUF_SIZE);
  3668. }
  3669. if (want_to_recv_size == 0)
  3670. {
  3671. SetNoNeedToRead(n->Sock);
  3672. break;
  3673. }
  3674. recv_size = Recv(n->Sock, buf, want_to_recv_size, false);
  3675. if (recv_size == 0)
  3676. {
  3677. // Communication has been disconnected
  3678. n->TcpFinished = true;
  3679. v->NatDoCancelFlag = true;
  3680. if (n->TcpDisconnected == false)
  3681. {
  3682. Disconnect(n->Sock);
  3683. n->TcpDisconnected = true;
  3684. }
  3685. break;
  3686. }
  3687. else if (recv_size == SOCK_LATER)
  3688. {
  3689. // Blocking
  3690. break;
  3691. }
  3692. else
  3693. {
  3694. // Successful reception
  3695. WriteFifo(n->SendFifo, buf, recv_size);
  3696. v->NatDoCancelFlag = true;
  3697. }
  3698. }
  3699. if (old_send_fifo_size == 0 && FifoSize(n->SendFifo) != 0)
  3700. {
  3701. // Reset the time data for timeout when the data is newly queued
  3702. // in the empty transmission buffer in the transmission process
  3703. n->TcpLastRecvAckTime = v->Now;
  3704. }
  3705. // Raise a transmission time-out if a certain period of time elapsed
  3706. // after receiving the last ACK, and the transmission buffer is not
  3707. // empty, and the reception window size of other party is not 0
  3708. if ((n->TcpLastRecvAckTime + (UINT64)VIRTUAL_TCP_SEND_TIMEOUT) < v->Now)
  3709. {
  3710. if (FifoSize(n->SendFifo) != 0 && n->TcpSendWindowSize != 0)
  3711. {
  3712. timeouted = true;
  3713. }
  3714. }
  3715. }
  3716. break;
  3717. }
  3718. // Timeout Detection
  3719. if ((n->LastCommTime + (UINT64)v->NatTcpTimeout) < v->Now || n->LastCommTime > v->Now)
  3720. {
  3721. timeouted = true;
  3722. }
  3723. if (timeouted)
  3724. {
  3725. // Time-out occurs, the session close
  3726. n->TcpStatus = NAT_TCP_SEND_RESET;
  3727. v->NatDoCancelFlag = true;
  3728. }
  3729. return true;
  3730. DISCONNECT: // Disconnect and session disposal
  3731. DeleteNatTcp(v, n);
  3732. return false;
  3733. }
  3734. // Delete the entry of TCP NAT
  3735. void DeleteNatTcp(VH *v, NAT_ENTRY *n)
  3736. {
  3737. // Validate arguments
  3738. if (v == NULL || n == NULL)
  3739. {
  3740. return;
  3741. }
  3742. NLog(v, "LH_NAT_TCP_DELETED", n->Id);
  3743. // Shutdown of connection thread
  3744. if (n->NatTcpConnectThread != NULL)
  3745. {
  3746. n->NatTcpCancelFlag = true;
  3747. WaitThread(n->NatTcpConnectThread, INFINITE);
  3748. ReleaseThread(n->NatTcpConnectThread);
  3749. n->NatTcpConnectThread = NULL;
  3750. }
  3751. if (n->Sock != NULL)
  3752. {
  3753. // Disconnect the socket
  3754. Disconnect(n->Sock);
  3755. ReleaseSock(n->Sock);
  3756. n->Sock = NULL;
  3757. }
  3758. // Release the window memory
  3759. if (n->TcpRecvWindow != NULL)
  3760. {
  3761. ReleaseFifo(n->TcpRecvWindow);
  3762. n->TcpRecvWindow = NULL;
  3763. }
  3764. // Release the window reception list
  3765. if (n->TcpRecvList != NULL)
  3766. {
  3767. UINT i;
  3768. for (i = 0;i < LIST_NUM(n->TcpRecvList);i++)
  3769. {
  3770. IP_PART *p = LIST_DATA(n->TcpRecvList, i);
  3771. Free(p);
  3772. }
  3773. ReleaseList(n->TcpRecvList);
  3774. n->TcpRecvList = NULL;
  3775. }
  3776. // FIFO release
  3777. ReleaseFifo(n->SendFifo);
  3778. ReleaseFifo(n->RecvFifo);
  3779. // Delete from the NAT entry
  3780. Delete(v->NatTable, n);
  3781. DeleteLock(n->lock);
  3782. // Release the memory
  3783. Free(n);
  3784. Debug("NAT_ENTRY: DeleteNatTcp\n");
  3785. }
  3786. // NAT processing thread
  3787. void NatThread(THREAD *t, void *param)
  3788. {
  3789. // Validate arguments
  3790. if (t == NULL || param == NULL)
  3791. {
  3792. return;
  3793. }
  3794. // Notify the initialization completion
  3795. NoticeThreadInit(t);
  3796. NatThreadMain((VH *)param);
  3797. }
  3798. // Send a beacon packet
  3799. void SendBeacon(VH *v)
  3800. {
  3801. UINT dest_ip;
  3802. ARPV4_HEADER arp;
  3803. static char beacon_str[] =
  3804. "SecureNAT Virtual TCP/IP Stack Beacon";
  3805. // Validate arguments
  3806. if (v == NULL)
  3807. {
  3808. return;
  3809. }
  3810. // Send an UDP
  3811. dest_ip = (v->HostIP & v->HostMask) | (~v->HostMask);
  3812. SendUdp(v, dest_ip, 7, v->HostIP, 7, beacon_str, sizeof(beacon_str));
  3813. // Build the ARP header
  3814. arp.HardwareType = Endian16(ARP_HARDWARE_TYPE_ETHERNET);
  3815. arp.ProtocolType = Endian16(MAC_PROTO_IPV4);
  3816. arp.HardwareSize = 6;
  3817. arp.ProtocolSize = 4;
  3818. arp.Operation = Endian16(ARP_OPERATION_RESPONSE);
  3819. Copy(arp.SrcAddress, v->MacAddress, 6);
  3820. arp.SrcIP = v->HostIP;
  3821. arp.TargetAddress[0] =
  3822. arp.TargetAddress[1] =
  3823. arp.TargetAddress[2] =
  3824. arp.TargetAddress[3] =
  3825. arp.TargetAddress[4] =
  3826. arp.TargetAddress[5] = 0xff;
  3827. arp.TargetIP = dest_ip;
  3828. // Transmission
  3829. VirtualLayer2Send(v, broadcast, v->MacAddress, MAC_PROTO_ARPV4, &arp, sizeof(arp));
  3830. }
  3831. // Send a TCP packet
  3832. void SendTcp(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, UINT seq, UINT ack, UINT flag, UINT window_size, UINT mss, void *data, UINT size)
  3833. {
  3834. static UCHAR tcp_mss_option[] = {0x02, 0x04, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00};
  3835. IPV4_PSEUDO_HEADER *vh;
  3836. TCP_HEADER *tcp;
  3837. UINT header_size = TCP_HEADER_SIZE;
  3838. UINT total_size;
  3839. // Validate arguments
  3840. if (v == NULL || (size != 0 && data == NULL))
  3841. {
  3842. return;
  3843. }
  3844. // Memory allocation
  3845. vh = Malloc(sizeof(IPV4_PSEUDO_HEADER) + TCP_HEADER_SIZE + size + 32);
  3846. tcp = (TCP_HEADER *)(((UCHAR *)vh) + sizeof(IPV4_PSEUDO_HEADER));
  3847. if (mss != 0)
  3848. {
  3849. USHORT *mss_size;
  3850. mss_size = (USHORT *)(&tcp_mss_option[2]);
  3851. *mss_size = Endian16((USHORT)mss);
  3852. header_size += sizeof(tcp_mss_option);
  3853. }
  3854. total_size = header_size + size;
  3855. if (total_size > 65536)
  3856. {
  3857. // Packet is too long
  3858. Free(vh);
  3859. return;
  3860. }
  3861. // Pseudo header generation
  3862. vh->SrcIP = src_ip;
  3863. vh->DstIP = dest_ip;
  3864. vh->Reserved = 0;
  3865. vh->Protocol = IP_PROTO_TCP;
  3866. vh->PacketLength = Endian16((USHORT)total_size);
  3867. // TCP header generation
  3868. tcp->SrcPort = Endian16((USHORT)src_port);
  3869. tcp->DstPort = Endian16((USHORT)dest_port);
  3870. tcp->SeqNumber = Endian32(seq);
  3871. tcp->AckNumber = Endian32(ack);
  3872. tcp->HeaderSizeAndReserved = 0;
  3873. TCP_SET_HEADER_SIZE(tcp, (UCHAR)(header_size / 4));
  3874. tcp->Flag = (UCHAR)flag;
  3875. tcp->WindowSize = Endian16((USHORT)window_size);
  3876. tcp->Checksum = 0;
  3877. tcp->UrgentPointer = 0;
  3878. // Copy the option values
  3879. if (mss != 0)
  3880. {
  3881. Copy(((UCHAR *)tcp) + TCP_HEADER_SIZE, tcp_mss_option, sizeof(tcp_mss_option));
  3882. }
  3883. // Data copy
  3884. Copy(((UCHAR *)tcp) + header_size, data, size);
  3885. // Checksum calculation
  3886. tcp->Checksum = IpChecksum(vh, total_size + 12);
  3887. // Submit as an IP packet
  3888. SendIp(v, dest_ip, src_ip, IP_PROTO_TCP, tcp, total_size);
  3889. // Release the memory
  3890. Free(vh);
  3891. }
  3892. // Polling process of TCP
  3893. void PollingNatTcp(VH *v, NAT_ENTRY *n)
  3894. {
  3895. // Validate arguments
  3896. if (v == NULL || n == NULL)
  3897. {
  3898. return;
  3899. }
  3900. switch (n->TcpStatus)
  3901. {
  3902. case NAT_TCP_CONNECTING: // Socket connecting: nothing to do
  3903. break;
  3904. case NAT_TCP_CONNECTED: // The socket connected: process SYN + ACK, ACK
  3905. if ((n->LastSynAckSentTime > v->Now) || n->LastSynAckSentTime == 0 || ((n->LastSynAckSentTime + (UINT64)(NAT_TCP_SYNACK_SEND_TIMEOUT * (UINT64)(n->SynAckSentCount + 1)) <= v->Now)))
  3906. {
  3907. n->LastSynAckSentTime = v->Now;
  3908. // Send a SYN + ACK
  3909. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  3910. (UINT)(n->SendSeqInit + n->SendSeq),
  3911. (UINT)(n->RecvSeqInit + n->RecvSeq),
  3912. TCP_SYN | TCP_ACK, n->TcpRecvWindowSize,
  3913. v->TcpMss, NULL, 0);
  3914. n->SynAckSentCount++;
  3915. }
  3916. break;
  3917. case NAT_TCP_SEND_RESET: // Reset the connection
  3918. // Send a RST
  3919. if (n->TcpFinished == false || n->TcpForceReset)
  3920. {
  3921. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  3922. (UINT)(n->SendSeq + n->SendSeqInit),
  3923. (UINT)(n->SendSeq + n->SendSeqInit),
  3924. TCP_RST, 0,
  3925. 0, NULL, 0);
  3926. // Disconnect
  3927. n->TcpStatus = NAT_TCP_WAIT_DISCONNECT;
  3928. n->DisconnectNow = true;
  3929. }
  3930. else
  3931. {
  3932. // Send FINs for NAT_FIN_SEND_MAX_COUNT times
  3933. if (n->FinSentTime == 0 || (n->FinSentTime > v->Now) || (n->FinSentTime + NAT_FIN_SEND_INTERVAL * (n->FinSentCount + 1)) < v->Now)
  3934. {
  3935. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  3936. (UINT)(n->SendSeq + n->SendSeqInit),
  3937. (UINT)(n->RecvSeq + n->RecvSeqInit),
  3938. TCP_ACK | TCP_FIN, 0,
  3939. 0, NULL, 0);
  3940. n->FinSentTime = v->Now;
  3941. n->FinSentSeq = (UINT)(n->SendSeq + n->SendSeqInit);
  3942. n->FinSentCount++;
  3943. if (n->FinSentCount >= NAT_FIN_SEND_MAX_COUNT)
  3944. {
  3945. n->TcpFinished = false;
  3946. }
  3947. }
  3948. }
  3949. break;
  3950. case NAT_TCP_ESTABLISHED: // Connection established
  3951. {
  3952. UINT send_data_size;
  3953. UINT current_pointer;
  3954. UINT notice_window_size_value = 0;
  3955. UINT buf_free_bytes = 0;
  3956. // Determine the value of the window size to be notified
  3957. if (FifoSize(n->RecvFifo) < NAT_RECV_BUF_SIZE)
  3958. {
  3959. buf_free_bytes = NAT_RECV_BUF_SIZE - FifoSize(n->RecvFifo);
  3960. }
  3961. notice_window_size_value = MIN(n->TcpRecvWindowSize, buf_free_bytes);
  3962. if (n->LastSentKeepAliveTime == 0 ||
  3963. (n->LastSentKeepAliveTime + (UINT64)NAT_ACK_KEEPALIVE_SPAN) < v->Now ||
  3964. (n->LastSentKeepAliveTime > v->Now))
  3965. {
  3966. if (n->LastSentKeepAliveTime != 0)
  3967. {
  3968. // Send an ACK packet for Keep-Alive
  3969. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  3970. (UINT)(n->SendSeqInit + n->SendSeq),
  3971. (UINT)(n->RecvSeqInit + n->RecvSeq) - 1,
  3972. TCP_ACK,
  3973. notice_window_size_value,
  3974. 0,
  3975. NULL,
  3976. 0);
  3977. }
  3978. n->LastSentKeepAliveTime = v->Now;
  3979. }
  3980. if (n->TcpLastSentTime == 0 ||
  3981. (n->TcpLastSentTime > v->Now) ||
  3982. ((n->TcpLastSentTime + (UINT64)n->TcpSendTimeoutSpan) < v->Now) ||
  3983. n->SendAckNext)
  3984. {
  3985. // If there is data to send, send the data
  3986. // Calculate the segment size to be transmitted
  3987. send_data_size = n->TcpSendWindowSize;
  3988. if (send_data_size > (n->TcpSendCWnd * n->TcpSendMaxSegmentSize))
  3989. {
  3990. // Apply the cwnd value
  3991. send_data_size = n->TcpSendCWnd * n->TcpSendMaxSegmentSize;
  3992. }
  3993. if (send_data_size > n->SendFifo->size)
  3994. {
  3995. // Can not be sent over the data that is currently held
  3996. send_data_size = n->SendFifo->size;
  3997. }
  3998. if (send_data_size >= 1)
  3999. {
  4000. // Transmit the fragmented segments
  4001. current_pointer = 0;
  4002. while (send_data_size > 0)
  4003. {
  4004. UINT send_segment_size = MIN(n->TcpSendMaxSegmentSize, send_data_size);
  4005. void *send_segment = (void *)(((UCHAR *)n->SendFifo->p) + n->SendFifo->pos + current_pointer);
  4006. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  4007. (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer),
  4008. (UINT)(n->RecvSeqInit + n->RecvSeq),
  4009. TCP_ACK | TCP_PSH,
  4010. notice_window_size_value,
  4011. 0,
  4012. send_segment,
  4013. send_segment_size);
  4014. current_pointer += send_segment_size;
  4015. send_data_size -= send_segment_size;
  4016. }
  4017. // Record the transmission time
  4018. n->TcpLastSentTime = v->Now;
  4019. // Record the stream size to be transmitted this time
  4020. n->SendMissionSize = current_pointer;
  4021. n->CurrentSendingMission = true;
  4022. // RTT measurement
  4023. if (n->CalcRTTStartTime == 0)
  4024. {
  4025. n->CalcRTTStartTime = v->Now;
  4026. n->CalcRTTStartValue = n->SendSeq + current_pointer - 1;
  4027. }
  4028. if (n->RetransmissionUsedFlag == false)
  4029. {
  4030. n->RetransmissionUsedFlag = true;
  4031. }
  4032. else
  4033. {
  4034. // Congestion is detected
  4035. if (n->TcpSendCWnd > 2)
  4036. {
  4037. n->TcpSendCWnd--;
  4038. }
  4039. }
  4040. }
  4041. else if (n->SendAckNext)
  4042. {
  4043. // Send only an ACK
  4044. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  4045. (UINT)(n->SendSeqInit + n->SendSeq),
  4046. (UINT)(n->RecvSeqInit + n->RecvSeq),
  4047. TCP_ACK,
  4048. notice_window_size_value,
  4049. 0,
  4050. NULL,
  4051. 0);
  4052. }
  4053. n->SendAckNext = false;
  4054. }
  4055. if (n->TcpFinished)
  4056. {
  4057. // Disconnect if all data transmission has completed
  4058. if (n->SendFifo->size == 0)
  4059. {
  4060. n->TcpStatus = NAT_TCP_SEND_RESET;
  4061. }
  4062. }
  4063. }
  4064. break;
  4065. }
  4066. }
  4067. // Reception of TCP packets addressed to the Internet
  4068. void TcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, TCP_HEADER *tcp, void *data, UINT size, UINT max_l3_size)
  4069. {
  4070. NAT_ENTRY *n, t;
  4071. UINT seq, ack;
  4072. UINT64 seq64 = 0, ack64 = 0;
  4073. // Validate arguments
  4074. if (v == NULL || tcp == NULL || data == NULL)
  4075. {
  4076. return;
  4077. }
  4078. if (NnIsActive(v))
  4079. {
  4080. NnTcpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, tcp, data, size, max_l3_size);
  4081. return;
  4082. }
  4083. seq = Endian32(tcp->SeqNumber);
  4084. ack = Endian32(tcp->AckNumber);
  4085. if (v->HubOption != NULL && v->HubOption->DisableUserModeSecureNAT)
  4086. {
  4087. // Disable User-mode NAT
  4088. SendTcp(v, dest_ip, dest_port, src_ip, src_port,
  4089. 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0);
  4090. return;
  4091. }
  4092. // Search for a session for this packet from the NAT table
  4093. SetNat(&t, NAT_TCP, src_ip, src_port, dest_ip, dest_port, 0, 0);
  4094. n = SearchNat(v, &t);
  4095. if (n == NULL)
  4096. {
  4097. // There is no existing session
  4098. // Allow through only SYN packet
  4099. if ((tcp->Flag & TCP_SYN) && ((tcp->Flag & TCP_ACK) == false))
  4100. {
  4101. TCP_OPTION o;
  4102. // Create a new session
  4103. n = CreateNatTcp(v, src_ip, src_port, dest_ip, dest_port);
  4104. if (n == NULL)
  4105. {
  4106. // Return the RST if it was not possible to create
  4107. SendTcp(v, dest_ip, dest_port, src_ip, src_port,
  4108. 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0);
  4109. return;
  4110. }
  4111. // Get the options
  4112. ParseTcpOption(&o, ((UCHAR *)tcp) + TCP_HEADER_SIZE, TCP_GET_HEADER_SIZE(tcp) * 4 - TCP_HEADER_SIZE);
  4113. if (o.MaxSegmentSize == 0)
  4114. {
  4115. o.MaxSegmentSize = v->TcpMss;
  4116. }
  4117. Debug("TCP SYN: MSS=%u, WS=%u\n", o.MaxSegmentSize, o.WindowScaling);
  4118. // Initial sequence number
  4119. n->RecvSeqInit = (UINT64)Endian32(tcp->SeqNumber);
  4120. n->RecvSeq = 1;
  4121. n->TcpSendMaxSegmentSize = o.MaxSegmentSize;
  4122. n->TcpRecvWindowSize = NAT_TCP_RECV_WINDOW_SIZE;
  4123. n->TcpSendWindowSize = (UINT)Endian16(tcp->WindowSize);
  4124. if (o.WindowScaling != 0)
  4125. {
  4126. if (o.WindowScaling > 14)
  4127. {
  4128. o.WindowScaling = 14;
  4129. }
  4130. n->TcpSendWindowSize = (n->TcpSendWindowSize << o.WindowScaling);
  4131. }
  4132. }
  4133. }
  4134. if (n == NULL)
  4135. {
  4136. // Return a RST since a packet which is not registered in the NAT entry arrived
  4137. SendTcp(v, dest_ip, dest_port, src_ip, src_port,
  4138. ack, ack, TCP_RST, 0, 0, NULL, 0);
  4139. return;
  4140. }
  4141. n->TcpLastRecvAckTime = v->Now;
  4142. switch (n->TcpStatus)
  4143. {
  4144. case NAT_TCP_SEND_RESET: // Disconnect the connection by sending a RST
  4145. if ((tcp->Flag & TCP_ACK) && ((tcp->Flag & TCP_SYN) == false))
  4146. {
  4147. if (n->FinSentCount >= 1)
  4148. {
  4149. if (ack == (n->FinSentSeq + 1))
  4150. {
  4151. n->TcpForceReset = true;
  4152. }
  4153. }
  4154. }
  4155. break;
  4156. case NAT_TCP_CONNECTED: // Socket connection completion: SYN + ACK, ACK processing
  4157. if ((tcp->Flag & TCP_ACK) && ((tcp->Flag & TCP_SYN) == false))
  4158. {
  4159. if (seq == (UINT)(n->RecvSeqInit + n->RecvSeq) &&
  4160. ack == (UINT)(n->SendSeqInit + n->SendSeq + 1))
  4161. {
  4162. // Handshake complete since the ACK packet came back
  4163. n->SendSeq++; // SYN packet consumes the seq by 1
  4164. Debug("TCP Connection Established.\n");
  4165. n->TcpStatus = NAT_TCP_ESTABLISHED;
  4166. // Initialize the congestion window size
  4167. n->TcpSendCWnd = 1;
  4168. n->LastCommTime = v->Now;
  4169. }
  4170. else
  4171. {
  4172. goto TCP_RESET;
  4173. }
  4174. }
  4175. else if (tcp->Flag & TCP_RST)
  4176. {
  4177. TCP_RESET:
  4178. // Receive a RST
  4179. Debug("TCP Connection Reseted.\n");
  4180. n->TcpStatus = NAT_TCP_SEND_RESET;
  4181. }
  4182. break;
  4183. case NAT_TCP_ESTABLISHED: // Connection established
  4184. if (tcp->Flag & TCP_FIN)
  4185. {
  4186. // Complete the connection
  4187. n->TcpFinished = true;
  4188. }
  4189. if (tcp->Flag & TCP_RST)
  4190. {
  4191. // Receive a RST
  4192. goto TCP_RESET;
  4193. }
  4194. else if (tcp->Flag & TCP_ACK)
  4195. {
  4196. TCP_OPTION opt;
  4197. n->LastCommTime = v->Now;
  4198. // Get the options, such as window size
  4199. n->TcpSendWindowSize = Endian16(tcp->WindowSize);
  4200. ParseTcpOption(&opt, ((UCHAR *)tcp) + TCP_HEADER_SIZE, TCP_GET_HEADER_SIZE(tcp) * 4 - TCP_HEADER_SIZE);
  4201. if (opt.WindowScaling != 0)
  4202. {
  4203. if (opt.WindowScaling > 14)
  4204. {
  4205. opt.WindowScaling = 14;
  4206. }
  4207. n->TcpSendWindowSize = (n->TcpSendWindowSize << opt.WindowScaling);
  4208. }
  4209. // First, process the received ACK
  4210. // Store the end position of the stream that has received the acknowledgment to ack64
  4211. ack64 = n->SendSeq + (UINT64)ack - (n->SendSeqInit + n->SendSeq) % X32;
  4212. if ((n->SendSeqInit + n->SendSeq) % X32 > ack)
  4213. {
  4214. if (((n->SendSeqInit + n->SendSeq) % X32 - ack) >= 0x80000000)
  4215. {
  4216. ack64 = n->SendSeq + (UINT64)ack + X32 - (n->SendSeqInit + n->SendSeq) % X32;
  4217. }
  4218. }
  4219. if (ack64 > n->SendSeq)
  4220. {
  4221. // Reception of 1 byte or more seems to have been completed by the client
  4222. UINT slide_offset = (UINT)(ack64 - n->SendSeq); // Sliding size of the window
  4223. if (slide_offset == 0 || slide_offset > n->TcpSendWindowSize || slide_offset > n->SendFifo->size)
  4224. {
  4225. // Ignore because the offset value of acknowledgment is
  4226. // larger than the size that should have been sent so far
  4227. }
  4228. else
  4229. {
  4230. // RTT measurement
  4231. if (n->CalcRTTStartTime != 0)
  4232. {
  4233. if (n->CalcRTTStartValue < ack64)
  4234. {
  4235. UINT time_span;
  4236. if (v->Now > n->CalcRTTStartTime)
  4237. {
  4238. time_span = (UINT)(v->Now - n->CalcRTTStartTime);
  4239. }
  4240. else
  4241. {
  4242. time_span = 100;
  4243. }
  4244. n->CalcRTTStartTime = 0;
  4245. // Smoothing
  4246. n->CurrentRTT =
  4247. (UINT)
  4248. (
  4249. ((UINT64)n->CurrentRTT * (UINT64)9 +
  4250. (UINT64)time_span * (UINT64)1) / (UINT64)10
  4251. );
  4252. n->TcpSendTimeoutSpan = n->CurrentRTT * 2;
  4253. }
  4254. }
  4255. // Reduce the transmission size
  4256. n->SendMissionSize -= slide_offset;
  4257. if (n->SendMissionSize == 0)
  4258. {
  4259. // Try to increase the transmission segment size because
  4260. // all segments to be sent this time have been sent
  4261. if (n->TcpSendCWnd < 65536)
  4262. {
  4263. n->TcpSendCWnd++;
  4264. }
  4265. n->CurrentSendingMission = false;
  4266. n->TcpLastSentTime = 0;
  4267. n->RetransmissionUsedFlag = false;
  4268. }
  4269. // Slide the buffer
  4270. n->SendSeq += slide_offset;
  4271. ReadFifo(n->SendFifo, NULL, slide_offset);
  4272. // Send further by the size of confirmed transmission completion by the ACK this time
  4273. if (n->SendMissionSize != 0 && false)
  4274. {
  4275. UINT notice_window_size_value = 0;
  4276. UINT send_data_size;
  4277. UINT buf_free_bytes;
  4278. UINT send_offset = n->SendMissionSize;
  4279. // Determine the value of the window size to be notified
  4280. if (FifoSize(n->RecvFifo) < NAT_RECV_BUF_SIZE)
  4281. {
  4282. buf_free_bytes = NAT_RECV_BUF_SIZE - FifoSize(n->RecvFifo);
  4283. }
  4284. notice_window_size_value = MIN(n->TcpRecvWindowSize, buf_free_bytes);
  4285. // Calculate the segment size to be transmitted
  4286. send_data_size = n->TcpSendWindowSize;
  4287. if (send_data_size > (n->TcpSendCWnd * n->TcpSendMaxSegmentSize))
  4288. {
  4289. // Apply the cwnd value
  4290. send_data_size = n->TcpSendCWnd * n->TcpSendMaxSegmentSize;
  4291. }
  4292. if (n->SendFifo->size > send_offset)
  4293. {
  4294. send_data_size = MIN(send_data_size, n->SendFifo->size - send_offset);
  4295. send_data_size = MIN(send_data_size, slide_offset);
  4296. }
  4297. else
  4298. {
  4299. send_data_size = 0;
  4300. }
  4301. if (send_data_size >= 1)
  4302. {
  4303. // Transmit the fragmented segments
  4304. UINT current_pointer = 0;
  4305. while (send_data_size > 0)
  4306. {
  4307. UINT send_segment_size = MIN(n->TcpSendMaxSegmentSize, send_data_size);
  4308. void *send_segment = (void *)((
  4309. (UCHAR *)n->SendFifo->p) + n->SendFifo->pos +
  4310. current_pointer + send_offset);
  4311. SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort,
  4312. (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer
  4313. + (UINT)send_offset),
  4314. (UINT)(n->RecvSeqInit + n->RecvSeq),
  4315. TCP_ACK | TCP_PSH,
  4316. notice_window_size_value,
  4317. 0,
  4318. send_segment,
  4319. send_segment_size);
  4320. current_pointer += send_segment_size;
  4321. send_data_size -= send_segment_size;
  4322. }
  4323. n->SendMissionSize += current_pointer;
  4324. n->CurrentSendingMission = true;
  4325. n->TcpLastSentTime = v->Now;
  4326. // RTT measurement
  4327. if (n->CalcRTTStartTime == 0)
  4328. {
  4329. n->CalcRTTStartTime = v->Now;
  4330. n->CalcRTTStartValue = n->SendSeq + current_pointer - 1;
  4331. }
  4332. }
  4333. }
  4334. // Event occurs
  4335. SetSockEvent(v->SockEvent);
  4336. }
  4337. }
  4338. // Next, receive the data
  4339. seq64 = n->RecvSeq + (UINT64)seq - (n->RecvSeqInit + n->RecvSeq) % X32;
  4340. if ((n->RecvSeqInit + n->RecvSeq) % X32 > seq)
  4341. {
  4342. if (((n->RecvSeqInit + n->RecvSeq) % X32 - ack) >= 0x80000000)
  4343. {
  4344. seq64 = n->RecvSeq + (UINT64)seq + X32 - (n->RecvSeqInit + n->RecvSeq) % X32;
  4345. }
  4346. }
  4347. // Position of the starting point of the data from the client is in the seq64 at this time
  4348. if (seq64 >= n->RecvSeq && (seq64 + size) <= (n->RecvSeq + n->TcpRecvWindowSize))
  4349. {
  4350. if (size >= 1)
  4351. {
  4352. // One or more bytes of data has been received within the receive window
  4353. UINT offset = (UINT)(seq64 - n->RecvSeq);
  4354. UINT i;
  4355. IP_PART *me;
  4356. if (n->TcpRecvWindow == NULL)
  4357. {
  4358. n->TcpRecvWindow = NewFifo();
  4359. }
  4360. if (n->TcpRecvList == NULL)
  4361. {
  4362. n->TcpRecvList = NewListFast(NULL);
  4363. }
  4364. // Add to the list by overwriting arriving packets to the buffer
  4365. if (FifoSize(n->TcpRecvWindow) < (offset + size))
  4366. {
  4367. // Buffer size expansion
  4368. WriteFifo(n->TcpRecvWindow, NULL, offset + size - FifoSize(n->TcpRecvWindow));
  4369. }
  4370. Copy(((UCHAR *)n->TcpRecvWindow->p) + n->TcpRecvWindow->pos +
  4371. offset, data, size);
  4372. me = ZeroMalloc(sizeof(IP_PART));
  4373. me->Offset = offset;
  4374. me->Size = size;
  4375. for (i = 0;i < LIST_NUM(n->TcpRecvList);i++)
  4376. {
  4377. IP_PART *p = LIST_DATA(n->TcpRecvList, i);
  4378. // If there are overlapped region, remove these
  4379. if (p->Size != 0)
  4380. {
  4381. if (me->Offset <= p->Offset && (me->Offset + me->Size) >= (p->Offset + p->Size))
  4382. {
  4383. // This packet completely overwrite the existing packet
  4384. p->Size = 0;
  4385. }
  4386. else if (me->Offset >= p->Offset && (me->Offset + me->Size) <= (p->Offset + p->Size))
  4387. {
  4388. // Existing packet completely override this packet
  4389. me->Size = 0;
  4390. }
  4391. else if (me->Offset > p->Offset && me->Offset < (p->Offset + p->Size) &&
  4392. (me->Offset + me->Size) > (p->Offset + p->Size))
  4393. {
  4394. // Partially overlapped
  4395. p->Size -= p->Offset + p->Size - me->Offset;
  4396. }
  4397. else if (me->Offset < p->Offset && (me->Offset + size) > p->Offset && (me->Offset + size) < (p->Offset + p->Size))
  4398. {
  4399. // Partially overlapped
  4400. me->Size -= me->Offset + me->Size - p->Offset;
  4401. }
  4402. }
  4403. }
  4404. if (me->Size == 0)
  4405. {
  4406. Free(me);
  4407. }
  4408. else
  4409. {
  4410. Add(n->TcpRecvList, me);
  4411. }
  4412. KILL_NULL_FIRST:
  4413. // Remove all blank items from reception list
  4414. for (i = 0;i < LIST_NUM(n->TcpRecvList);i++)
  4415. {
  4416. IP_PART *p = LIST_DATA(n->TcpRecvList, i);
  4417. if (p->Size == 0)
  4418. {
  4419. Delete(n->TcpRecvList, p);
  4420. Free(p);
  4421. goto KILL_NULL_FIRST;
  4422. }
  4423. }
  4424. SCAN_FIRST:
  4425. // Extract if there is something starting at offset 0 in the received list
  4426. for (i = 0;i < LIST_NUM(n->TcpRecvList);i++)
  4427. {
  4428. IP_PART *p = LIST_DATA(n->TcpRecvList, i);
  4429. UINT sz;
  4430. if (p->Offset == 0)
  4431. {
  4432. // Since a data block starts with 0 is found,
  4433. // slide it left by that amount and write the buffer
  4434. // for extracting data to the FIFO
  4435. sz = p->Size;
  4436. WriteFifo(n->RecvFifo, ((UCHAR *)n->TcpRecvWindow->p) + n->TcpRecvWindow->pos, sz);
  4437. // Release from the list
  4438. Delete(n->TcpRecvList, p);
  4439. Free(p);
  4440. ReadFifo(n->TcpRecvWindow, NULL, sz);
  4441. // Slide all the items to the left
  4442. for (i = 0;i < LIST_NUM(n->TcpRecvList);i++)
  4443. {
  4444. p = LIST_DATA(n->TcpRecvList, i);
  4445. p->Offset -= sz;
  4446. }
  4447. // Update the parameters of the TCB
  4448. n->RecvSeq += (UINT64)sz;
  4449. SetSockEvent(v->SockEvent);
  4450. n->SendAckNext = true;
  4451. // Re-scan from the beginning
  4452. goto SCAN_FIRST;
  4453. }
  4454. }
  4455. }
  4456. }
  4457. }
  4458. break;
  4459. }
  4460. SetSockEvent(v->SockEvent);
  4461. }
  4462. // Parse the TCP options
  4463. void ParseTcpOption(TCP_OPTION *o, void *data, UINT size)
  4464. {
  4465. UCHAR *buf = (UCHAR *)data;
  4466. UINT i;
  4467. UINT value_size = 0;
  4468. UINT value_id = 0;
  4469. UCHAR value[128];
  4470. // Validate arguments
  4471. if (o == NULL || data == NULL)
  4472. {
  4473. return;
  4474. }
  4475. Zero(o, sizeof(TCP_OPTION));
  4476. for (i = 0;i < size;i++)
  4477. {
  4478. if (buf[i] == 0)
  4479. {
  4480. return;
  4481. }
  4482. if (buf[i] != 1)
  4483. {
  4484. value_id = buf[i];
  4485. i++;
  4486. if (i >= size)
  4487. {
  4488. return;
  4489. }
  4490. value_size = buf[i];
  4491. if (value_size <= 1 || value_size > sizeof(value))
  4492. {
  4493. return;
  4494. }
  4495. i++;
  4496. if (i >= size)
  4497. {
  4498. return;
  4499. }
  4500. value_size -= 2;
  4501. Copy(value, &buf[i], value_size);
  4502. i += value_size;
  4503. if (i >= size)
  4504. {
  4505. return;
  4506. }
  4507. switch (value_id)
  4508. {
  4509. case 2: // MSS
  4510. if (value_size == 2)
  4511. {
  4512. USHORT *mss = (USHORT *)value;
  4513. o->MaxSegmentSize = Endian16(*mss);
  4514. }
  4515. break;
  4516. case 3: // WSS
  4517. if (value_size == 1)
  4518. {
  4519. UCHAR *wss = (UCHAR *)value;
  4520. o->WindowScaling = Endian16(*wss);
  4521. }
  4522. break;
  4523. }
  4524. }
  4525. }
  4526. }
  4527. // Create a new NAT TCP session
  4528. NAT_ENTRY *CreateNatTcp(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port)
  4529. {
  4530. NAT_ENTRY *n;
  4531. HUB_OPTION *o;
  4532. // Validate arguments
  4533. if (v == NULL)
  4534. {
  4535. return NULL;
  4536. }
  4537. if (CanCreateNewNatEntry(v) == false)
  4538. {
  4539. return NULL;
  4540. }
  4541. o = NatGetHubOption(v);
  4542. // Fail immediately if the connection with SYN_SENT are too many
  4543. if (o != NULL && o->SecureNAT_MaxTcpSynSentPerIp != 0)
  4544. {
  4545. if (GetNumNatEntriesPerIp(v, src_ip, NAT_TCP, true) >= o->SecureNAT_MaxTcpSynSentPerIp)
  4546. {
  4547. return NULL;
  4548. }
  4549. }
  4550. // If the connections other than SYN_SENT are too many, delete old ones
  4551. if (o != NULL && o->SecureNAT_MaxTcpSessionsPerIp != 0)
  4552. {
  4553. if (GetNumNatEntriesPerIp(v, src_ip, NAT_TCP, false) >= o->SecureNAT_MaxTcpSessionsPerIp)
  4554. {
  4555. NAT_ENTRY *oldest = GetOldestNatEntryOfIp(v, src_ip, NAT_TCP);
  4556. if (oldest != NULL)
  4557. {
  4558. DisconnectNatEntryNow(v, oldest);
  4559. }
  4560. }
  4561. }
  4562. // Create a NAT entry
  4563. n = ZeroMalloc(sizeof(NAT_ENTRY));
  4564. n->Id = Inc(v->Counter);
  4565. n->v = v;
  4566. n->lock = NewLock();
  4567. n->Protocol = NAT_TCP;
  4568. n->SrcIp = src_ip;
  4569. n->SrcPort = src_port;
  4570. n->DestIp = dest_ip;
  4571. n->DestPort = dest_port;
  4572. n->CreatedTime = n->LastCommTime = v->Now;
  4573. n->TcpLastRecvAckTime = v->Now;
  4574. n->Sock = NULL;
  4575. n->DisconnectNow = false;
  4576. n->TcpSendMaxSegmentSize = n->TcpRecvMaxSegmentSize = v->TcpMss;
  4577. n->SendFifo = NewFifo();
  4578. n->RecvFifo = NewFifo();
  4579. n->TcpStatus = NAT_TCP_CONNECTING;
  4580. n->SendSeqInit = Rand32();
  4581. n->CurrentRTT = NAT_INITIAL_RTT_VALUE;
  4582. n->TcpSendTimeoutSpan = n->CurrentRTT * 2;
  4583. // Add to the NAT table
  4584. Add(v->NatTable, n);
  4585. #if 1
  4586. {
  4587. IP ip1, ip2;
  4588. char s1[MAX_SIZE], s2[MAX_SIZE];
  4589. UINTToIP(&ip1, src_ip);
  4590. UINTToIP(&ip2, dest_ip);
  4591. IPToStr(s1, 0, &ip1);
  4592. IPToStr(s2, 0, &ip2);
  4593. Debug("NAT_ENTRY: CreateNatTcp %s %u -> %s %u\n", s1, src_port, s2, dest_port);
  4594. NLog(v, "LH_NAT_TCP_CREATED", n->Id, s1, src_port, s2, dest_port);
  4595. }
  4596. #endif
  4597. return n;
  4598. }
  4599. // Received TCP packets from the virtual network
  4600. void VirtualTcpReceived(VH *v, UINT src_ip, UINT dest_ip, void *data, UINT size, UINT max_l3_size)
  4601. {
  4602. TCP_HEADER *tcp;
  4603. UINT src_port, dest_port;
  4604. UINT header_size, buf_size;
  4605. void *buf;
  4606. IP ip1, ip2;
  4607. // Validate arguments
  4608. if (v == NULL || data == NULL)
  4609. {
  4610. return;
  4611. }
  4612. // Get the header
  4613. if (size < TCP_HEADER_SIZE)
  4614. {
  4615. // Size is too small
  4616. return;
  4617. }
  4618. tcp = (TCP_HEADER *)data;
  4619. src_port = Endian16(tcp->SrcPort);
  4620. dest_port = Endian16(tcp->DstPort);
  4621. if (src_port == 0 || dest_port == 0)
  4622. {
  4623. // Port number is invalid
  4624. return;
  4625. }
  4626. if (src_ip == dest_ip || src_ip == 0 || src_ip == 0xffffffff || dest_ip == 0 || dest_ip == 0xffffffff)
  4627. {
  4628. // IP address is invalid
  4629. return;
  4630. }
  4631. UINTToIP(&ip1, src_ip);
  4632. UINTToIP(&ip2, dest_ip);
  4633. if (ip1.addr[0] == 127 || ip2.addr[0] == 127)
  4634. {
  4635. // Loopback IP address can not be specified
  4636. return;
  4637. }
  4638. if (IsInNetwork(dest_ip, v->HostIP, v->HostMask))
  4639. {
  4640. // Ignore the packets toward the network of the virtual LAN side
  4641. return;
  4642. }
  4643. // Get the header size
  4644. header_size = TCP_GET_HEADER_SIZE(tcp) * 4;
  4645. if (size < header_size)
  4646. {
  4647. // Header size is invalid
  4648. return;
  4649. }
  4650. // Get the address and size of the buffer
  4651. buf_size = size - header_size;
  4652. buf = (void *)(((UCHAR *)data) + header_size);
  4653. TcpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, tcp, buf, buf_size, max_l3_size);
  4654. }
  4655. // NAT ICMP polling
  4656. void PollingNatIcmp(VH *v, NAT_ENTRY *n)
  4657. {
  4658. // Validate arguments
  4659. if (v == NULL || n == NULL)
  4660. {
  4661. return;
  4662. }
  4663. // Process if there are any packets in the receive queue
  4664. if (n->UdpRecvQueue->num_item != 0)
  4665. {
  4666. BLOCK *block;
  4667. // Send all ICMP packets to the virtual network
  4668. while (block = GetNext(n->UdpRecvQueue))
  4669. {
  4670. // Rewrite the destination IP address of the returned packet to the IP address of the client
  4671. UCHAR *data;
  4672. UINT size;
  4673. data = (UCHAR *)block->Buf;
  4674. size = block->Size;
  4675. if (size >= sizeof(IPV4_HEADER))
  4676. {
  4677. IPV4_HEADER *ipv4 = (IPV4_HEADER *)data;
  4678. UINT ipv4_header_size = GetIpHeaderSize((UCHAR *)ipv4, size);
  4679. if (ipv4_header_size >= sizeof(IPV4_HEADER) && (Endian16(ipv4->TotalLength) >= ipv4_header_size))
  4680. {
  4681. UCHAR *ipv4_payload = data + ipv4_header_size;
  4682. UINT ipv4_payload_size = Endian16(ipv4->TotalLength) - ipv4_header_size;
  4683. if (ipv4_payload_size >= sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO))
  4684. {
  4685. ICMP_HEADER *icmp = (ICMP_HEADER *)(data + ipv4_header_size);
  4686. UINT icmp_size = ipv4_payload_size;
  4687. if (icmp->Type == ICMP_TYPE_DESTINATION_UNREACHABLE || icmp->Type == ICMP_TYPE_TIME_EXCEEDED)
  4688. {
  4689. // Rewrite the Src IP of the IPv4 header of the ICMP response packet
  4690. if (icmp_size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + sizeof(IPV4_HEADER)))
  4691. {
  4692. IPV4_HEADER *orig_ipv4 = (IPV4_HEADER *)(data + ipv4_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  4693. UINT orig_ipv4_size = icmp_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
  4694. UINT orig_ipv4_header_size = GetIpHeaderSize((UCHAR *)orig_ipv4, orig_ipv4_size);
  4695. if (orig_ipv4_header_size >= sizeof(IPV4_HEADER))
  4696. {
  4697. orig_ipv4->SrcIP = n->SrcIp;
  4698. orig_ipv4->Checksum = 0;
  4699. orig_ipv4->Checksum = IpChecksum(orig_ipv4, orig_ipv4_header_size);
  4700. }
  4701. }
  4702. }
  4703. // Recalculate the checksum of ICMP
  4704. icmp->Checksum = IpChecksum(icmp, icmp_size);
  4705. SendIpEx(v, n->SrcIp, ipv4->SrcIP, ipv4->Protocol, ipv4_payload, ipv4_payload_size,
  4706. MAX(ipv4->TimeToLive - 1, 1));
  4707. }
  4708. }
  4709. }
  4710. FreeBlock(block);
  4711. }
  4712. if (v->IcmpRawSocketOk == false)
  4713. {
  4714. // Release the NAT entry as soon as the results is received in the case of using ICMP API
  4715. n->DisconnectNow = true;
  4716. }
  4717. }
  4718. }
  4719. // NAT UDP polling
  4720. void PoolingNatUdp(VH *v, NAT_ENTRY *n)
  4721. {
  4722. // Validate arguments
  4723. if (v == NULL || n == NULL)
  4724. {
  4725. return;
  4726. }
  4727. // Process if there are any packets in the receive queue
  4728. if (n->UdpRecvQueue->num_item != 0)
  4729. {
  4730. BLOCK *block;
  4731. // Send all UDP packets to the virtual network
  4732. while (block = GetNext(n->UdpRecvQueue))
  4733. {
  4734. UINT src_ip = n->DestIp;
  4735. if (src_ip == 0xFFFFFFFF)
  4736. {
  4737. src_ip = v->HostIP;
  4738. }
  4739. if (block->Param1 != 0)
  4740. {
  4741. src_ip = block->Param1;
  4742. }
  4743. SendUdp(v, n->SrcIp, n->SrcPort, src_ip, n->DestPort,
  4744. block->Buf, block->Size);
  4745. FreeBlock(block);
  4746. }
  4747. }
  4748. }
  4749. // NAT polling
  4750. void PoolingNat(VH *v)
  4751. {
  4752. UINT i;
  4753. // Validate arguments
  4754. if (v == NULL)
  4755. {
  4756. return;
  4757. }
  4758. if (NnIsActive(v))
  4759. {
  4760. // Poll whether the packet comes from native NAT
  4761. NnPoll(v->NativeNat);
  4762. }
  4763. // Process by scanning the all NAT entries
  4764. for (i = 0;i < LIST_NUM(v->NatTable);i++)
  4765. {
  4766. NAT_ENTRY *n = LIST_DATA(v->NatTable, i);
  4767. switch (n->Protocol)
  4768. {
  4769. case NAT_TCP:
  4770. PollingNatTcp(v, n);
  4771. break;
  4772. case NAT_UDP:
  4773. PoolingNatUdp(v, n);
  4774. break;
  4775. case NAT_ICMP:
  4776. PollingNatIcmp(v, n);
  4777. break;
  4778. case NAT_DNS:
  4779. PollingNatDns(v, n);
  4780. break;
  4781. }
  4782. }
  4783. }
  4784. // Comparison function of the NAT table entry
  4785. int CompareNat(void *p1, void *p2)
  4786. {
  4787. NAT_ENTRY *n1, *n2;
  4788. if (p1 == NULL || p2 == NULL)
  4789. {
  4790. return 0;
  4791. }
  4792. n1 = *(NAT_ENTRY **)p1;
  4793. n2 = *(NAT_ENTRY **)p2;
  4794. if (n1 == n2)
  4795. {
  4796. return 0;
  4797. }
  4798. if (n1->SrcIp > n2->SrcIp) return 1;
  4799. else if (n1->SrcIp < n2->SrcIp) return -1;
  4800. else if (n1->DestIp > n2->DestIp) return 1;
  4801. else if (n1->DestIp < n2->DestIp) return -1;
  4802. else if (n1->SrcPort > n2->SrcPort) return 1;
  4803. else if (n1->SrcPort < n2->SrcPort) return -1;
  4804. else if (n1->DestPort > n2->DestPort) return 1;
  4805. else if (n1->DestPort < n2->DestPort) return -1;
  4806. else if (n1->Protocol > n2->Protocol) return 1;
  4807. else if (n1->Protocol < n2->Protocol) return -1;
  4808. else return 0;
  4809. }
  4810. // Configure the NAT structure
  4811. void SetNat(NAT_ENTRY *n, UINT protocol, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, UINT public_ip, UINT public_port)
  4812. {
  4813. // Validate arguments
  4814. if (n == NULL)
  4815. {
  4816. return;
  4817. }
  4818. n->Protocol = protocol;
  4819. n->SrcIp = src_ip;
  4820. n->SrcPort = src_port;
  4821. n->DestIp = dest_ip;
  4822. n->DestPort = dest_port;
  4823. n->PublicIp = public_ip;
  4824. n->PublicPort = public_port;
  4825. }
  4826. // Initialize the NAT
  4827. void InitNat(VH *v)
  4828. {
  4829. // Validate arguments
  4830. if (v == NULL)
  4831. {
  4832. return;
  4833. }
  4834. // Create a NAT table
  4835. v->NatTable = NewList(CompareNat);
  4836. // Create a socket event
  4837. v->SockEvent = NewSockEvent();
  4838. // Create the NAT thread
  4839. v->HaltNat = false;
  4840. v->NatThread = NewThread(NatThread, (void *)v);
  4841. WaitThreadInit(v->NatThread);
  4842. if (IsEthSupported())
  4843. {
  4844. // Start a native NAT if access to the layer 2 Ethernet is supported
  4845. v->NativeNat = NewNativeNat(v);
  4846. }
  4847. }
  4848. // Release the NAT
  4849. void FreeNat(VH *v)
  4850. {
  4851. // Validate arguments
  4852. if (v == NULL)
  4853. {
  4854. return;
  4855. }
  4856. // Stop the native NAT
  4857. if (v->NativeNat != NULL)
  4858. {
  4859. FreeNativeNat(v->NativeNat);
  4860. v->NativeNat = NULL;
  4861. }
  4862. // Stop the NAT thread
  4863. v->HaltNat = true;
  4864. SetSockEvent(v->SockEvent);
  4865. WaitThread(v->NatThread, INFINITE);
  4866. ReleaseThread(v->NatThread);
  4867. v->NatThread = NULL;
  4868. ReleaseSockEvent(v->SockEvent);
  4869. v->SockEvent = NULL;
  4870. // Release the NAT table
  4871. ReleaseList(v->NatTable);
  4872. }
  4873. // Search the NAT table
  4874. NAT_ENTRY *SearchNat(VH *v, NAT_ENTRY *target)
  4875. {
  4876. NAT_ENTRY *n;
  4877. // Validate arguments
  4878. if (v == NULL || target == NULL)
  4879. {
  4880. return NULL;
  4881. }
  4882. // Binary search
  4883. n = (NAT_ENTRY *)Search(v->NatTable, target);
  4884. return n;
  4885. }
  4886. // Delete the UDP NAT entry
  4887. void DeleteNatUdp(VH *v, NAT_ENTRY *n)
  4888. {
  4889. BLOCK *block;
  4890. // Validate arguments
  4891. if (v == NULL || n == NULL)
  4892. {
  4893. return;
  4894. }
  4895. NLog(v, "LH_NAT_UDP_DELETED", n->Id);
  4896. // Release all queues
  4897. while (block = GetNext(n->UdpRecvQueue))
  4898. {
  4899. FreeBlock(block);
  4900. }
  4901. ReleaseQueue(n->UdpRecvQueue);
  4902. while (block = GetNext(n->UdpSendQueue))
  4903. {
  4904. FreeBlock(block);
  4905. }
  4906. ReleaseQueue(n->UdpSendQueue);
  4907. // Release the socket
  4908. if (n->Sock != NULL)
  4909. {
  4910. Disconnect(n->Sock);
  4911. ReleaseSock(n->Sock);
  4912. n->Sock = NULL;
  4913. }
  4914. DeleteLock(n->lock);
  4915. // Remove from the table
  4916. Delete(v->NatTable, n);
  4917. // Release the memory
  4918. Free(n);
  4919. Debug("NAT: DeleteNatUdp\n");
  4920. }
  4921. // Delete the ICMP NAT entry
  4922. void DeleteNatIcmp(VH *v, NAT_ENTRY *n)
  4923. {
  4924. BLOCK *block;
  4925. // Validate arguments
  4926. if (v == NULL || n == NULL)
  4927. {
  4928. return;
  4929. }
  4930. //NLog(v, "LH_NAT_ICMP_DELETED", n->Id);
  4931. // Release all queues
  4932. while (block = GetNext(n->UdpRecvQueue))
  4933. {
  4934. FreeBlock(block);
  4935. }
  4936. ReleaseQueue(n->UdpRecvQueue);
  4937. while (block = GetNext(n->UdpSendQueue))
  4938. {
  4939. FreeBlock(block);
  4940. }
  4941. ReleaseQueue(n->UdpSendQueue);
  4942. if (n->IcmpQueryBlock != NULL)
  4943. {
  4944. FreeBlock(n->IcmpQueryBlock);
  4945. }
  4946. if (n->IcmpResponseBlock != NULL)
  4947. {
  4948. FreeBlock(n->IcmpResponseBlock);
  4949. }
  4950. if (n->IcmpOriginalCopy != NULL)
  4951. {
  4952. Free(n->IcmpOriginalCopy);
  4953. }
  4954. // Release the socket
  4955. if (n->Sock != NULL)
  4956. {
  4957. Disconnect(n->Sock);
  4958. ReleaseSock(n->Sock);
  4959. n->Sock = NULL;
  4960. }
  4961. DeleteLock(n->lock);
  4962. // Remove from the table
  4963. Delete(v->NatTable, n);
  4964. // Release the memory
  4965. Free(n);
  4966. Debug("NAT: DeleteNatIcmp\n");
  4967. }
  4968. // Create a NAT ICMP entry
  4969. NAT_ENTRY *CreateNatIcmp(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, UCHAR *original_copy, UINT original_copy_size)
  4970. {
  4971. NAT_ENTRY *n;
  4972. HUB_OPTION *o;
  4973. // Validate arguments
  4974. if (v == NULL || original_copy == NULL || original_copy_size == 0)
  4975. {
  4976. return NULL;
  4977. }
  4978. if (CanCreateNewNatEntry(v) == false)
  4979. {
  4980. return NULL;
  4981. }
  4982. o = NatGetHubOption(v);
  4983. if (o != NULL && o->SecureNAT_MaxIcmpSessionsPerIp != 0)
  4984. {
  4985. if (GetNumNatEntriesPerIp(v, src_ip, NAT_ICMP, false) >= o->SecureNAT_MaxIcmpSessionsPerIp)
  4986. {
  4987. NAT_ENTRY *oldest = GetOldestNatEntryOfIp(v, src_ip, NAT_ICMP);
  4988. if (oldest != NULL)
  4989. {
  4990. DisconnectNatEntryNow(v, oldest);
  4991. }
  4992. }
  4993. }
  4994. n = ZeroMalloc(sizeof(NAT_ENTRY));
  4995. n->Id = Inc(v->Counter);
  4996. n->v = v;
  4997. n->lock = NewLock();
  4998. n->Protocol = NAT_ICMP;
  4999. n->SrcIp = src_ip;
  5000. n->SrcPort = src_port;
  5001. n->DestIp = dest_ip;
  5002. n->DestPort = dest_port;
  5003. n->CreatedTime = n->LastCommTime = v->Now;
  5004. n->UdpSendQueue = NewQueue();
  5005. n->UdpRecvQueue = NewQueue();
  5006. n->UdpSocketCreated = false;
  5007. n->IcmpOriginalCopy = Clone(original_copy, original_copy_size);
  5008. n->IcmpOriginalCopySize = original_copy_size;
  5009. SetSockEvent(v->SockEvent);
  5010. #if 1
  5011. {
  5012. IP ip1, ip2;
  5013. char s1[MAX_SIZE], s2[MAX_SIZE];
  5014. UINTToIP(&ip1, src_ip);
  5015. UINTToIP(&ip2, dest_ip);
  5016. IPToStr(s1, 0, &ip1);
  5017. IPToStr(s2, 0, &ip2);
  5018. Debug("NAT_ENTRY: CreateNatIcmp %s %u -> %s %u\n", s1, src_port, s2, dest_port);
  5019. //NLog(v, "LH_NAT_ICMP_CREATED", n->Id, s1, s2, src_port);
  5020. }
  5021. #endif
  5022. Add(v->NatTable, n);
  5023. return n;
  5024. }
  5025. // Create a NAT UDP entry
  5026. NAT_ENTRY *CreateNatUdp(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, UINT dns_proxy_ip)
  5027. {
  5028. NAT_ENTRY *n;
  5029. HUB_OPTION *o;
  5030. // Validate arguments
  5031. if (v == NULL)
  5032. {
  5033. return NULL;
  5034. }
  5035. if (CanCreateNewNatEntry(v) == false)
  5036. {
  5037. return NULL;
  5038. }
  5039. o = NatGetHubOption(v);
  5040. if (o != NULL && o->SecureNAT_MaxTcpSessionsPerIp != 0)
  5041. {
  5042. if (GetNumNatEntriesPerIp(v, src_ip, NAT_UDP, false) >= o->SecureNAT_MaxUdpSessionsPerIp)
  5043. {
  5044. NAT_ENTRY *oldest = GetOldestNatEntryOfIp(v, src_ip, NAT_UDP);
  5045. if (oldest != NULL)
  5046. {
  5047. DisconnectNatEntryNow(v, oldest);
  5048. }
  5049. }
  5050. }
  5051. n = ZeroMalloc(sizeof(NAT_ENTRY));
  5052. n->Id = Inc(v->Counter);
  5053. n->v = v;
  5054. n->lock = NewLock();
  5055. n->Protocol = NAT_UDP;
  5056. n->SrcIp = src_ip;
  5057. n->SrcPort = src_port;
  5058. n->DestIp = dest_ip;
  5059. n->DestPort = dest_port;
  5060. if (dns_proxy_ip != 0)
  5061. {
  5062. n->ProxyDns = true;
  5063. n->DestIpProxy = dns_proxy_ip;
  5064. }
  5065. n->CreatedTime = n->LastCommTime = v->Now;
  5066. n->UdpSendQueue = NewQueue();
  5067. n->UdpRecvQueue = NewQueue();
  5068. n->UdpSocketCreated = false;
  5069. SetSockEvent(v->SockEvent);
  5070. #if 1
  5071. {
  5072. IP ip1, ip2;
  5073. char s1[MAX_SIZE], s2[MAX_SIZE];
  5074. UINTToIP(&ip1, src_ip);
  5075. UINTToIP(&ip2, dest_ip);
  5076. IPToStr(s1, 0, &ip1);
  5077. IPToStr(s2, 0, &ip2);
  5078. Debug("NAT_ENTRY: CreateNatUdp %s %u -> %s %u\n", s1, src_port, s2, dest_port);
  5079. NLog(v, "LH_NAT_UDP_CREATED", n->Id, s1, src_port, s2, dest_port);
  5080. }
  5081. #endif
  5082. Add(v->NatTable, n);
  5083. return n;
  5084. }
  5085. // Ignore for NetBIOS name registration packet
  5086. bool IsNetbiosRegistrationPacket(UCHAR *buf, UINT size)
  5087. {
  5088. // Validate arguments
  5089. if (buf == NULL || size == 0)
  5090. {
  5091. return false;
  5092. }
  5093. if (size >= 4)
  5094. {
  5095. USHORT us = *((USHORT *)(buf + 2));
  5096. us = Endian16(us);
  5097. if (((us & 0x7800) >> 11) == 5)
  5098. {
  5099. return true;
  5100. }
  5101. }
  5102. return false;
  5103. }
  5104. // Generate the encoded NetBIOS name
  5105. void EncodeNetBiosName(UCHAR *dst, char *src)
  5106. {
  5107. char tmp[17];
  5108. UINT i;
  5109. UINT copy_len;
  5110. UINT wp;
  5111. // Validate arguments
  5112. if (dst == NULL || src == NULL)
  5113. {
  5114. return;
  5115. }
  5116. for (i = 0;i < 16;i++)
  5117. {
  5118. tmp[i] = ' ';
  5119. }
  5120. tmp[16] = 0;
  5121. copy_len = StrLen(src);
  5122. if (copy_len > 16)
  5123. {
  5124. copy_len = 16;
  5125. }
  5126. Copy(tmp, src, StrLen(src));
  5127. wp = 0;
  5128. tmp[15] = 0;
  5129. for (i = 0;i < 16;i++)
  5130. {
  5131. char c = tmp[i];
  5132. char *s = CharToNetBiosStr(c);
  5133. dst[wp++] = s[0];
  5134. dst[wp++] = s[1];
  5135. }
  5136. }
  5137. // Convert the string to NetBIOS characters
  5138. char *CharToNetBiosStr(char c)
  5139. {
  5140. c = ToUpper(c);
  5141. switch (c)
  5142. {
  5143. case '\0': return "AA";
  5144. case 'A': return "EB";
  5145. case 'B': return "EC";
  5146. case 'C': return "ED";
  5147. case 'D': return "EE";
  5148. case 'E': return "EF";
  5149. case 'F': return "EG";
  5150. case 'G': return "EH";
  5151. case 'H': return "EI";
  5152. case 'I': return "EJ";
  5153. case 'J': return "EK";
  5154. case 'K': return "EL";
  5155. case 'L': return "EM";
  5156. case 'M': return "EN";
  5157. case 'N': return "EO";
  5158. case 'O': return "EP";
  5159. case 'P': return "FA";
  5160. case 'Q': return "FB";
  5161. case 'R': return "FC";
  5162. case 'S': return "FD";
  5163. case 'T': return "FE";
  5164. case 'U': return "FF";
  5165. case 'V': return "FG";
  5166. case 'W': return "FH";
  5167. case 'X': return "FI";
  5168. case 'Y': return "FJ";
  5169. case 'Z': return "FK";
  5170. case '0': return "DA";
  5171. case '1': return "DB";
  5172. case '2': return "DC";
  5173. case '3': return "DD";
  5174. case '4': return "DE";
  5175. case '5': return "DF";
  5176. case '6': return "DG";
  5177. case '7': return "DH";
  5178. case '8': return "DI";
  5179. case '9': return "DJ";
  5180. case ' ': return "CA";
  5181. case '!': return "CB";
  5182. case '\"': return "CC";
  5183. case '#': return "CD";
  5184. case '$': return "CE";
  5185. case '%': return "CF";
  5186. case '&': return "CG";
  5187. case '\'': return "CH";
  5188. case '(': return "CI";
  5189. case ')': return "CJ";
  5190. case '*': return "CK";
  5191. case '+': return "CL";
  5192. case ',': return "CM";
  5193. case '-': return "CN";
  5194. case '.': return "CO";
  5195. case '=': return "DN";
  5196. case ':': return "DK";
  5197. case ';': return "DL";
  5198. case '@': return "EA";
  5199. case '^': return "FO";
  5200. case '_': return "FP";
  5201. case '{': return "HL";
  5202. case '}': return "HN";
  5203. case '~': return "HO";
  5204. }
  5205. return "CA";
  5206. }
  5207. // Process if a NetBIOS name resolution packet for the my host name
  5208. bool ProcessNetBiosNameQueryPacketForMyself(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5209. {
  5210. BUF *rb;
  5211. USHORT tran_id;
  5212. USHORT flags;
  5213. USHORT num_query;
  5214. USHORT zero1, zero2, zero3;
  5215. UCHAR name_size;
  5216. UCHAR encoded_name[32];
  5217. UCHAR node_type;
  5218. USHORT type, classid;
  5219. UCHAR my_pc_encoded_name[32];
  5220. bool ret = false;
  5221. // Validate arguments
  5222. if (v == NULL || data == NULL)
  5223. {
  5224. return false;
  5225. }
  5226. rb = NewBufFromMemory(data, size);
  5227. ReadBuf(rb, &tran_id, sizeof(USHORT));
  5228. ReadBuf(rb, &flags, sizeof(USHORT));
  5229. flags = Endian16(flags);
  5230. ReadBuf(rb, &num_query, sizeof(USHORT));
  5231. num_query = Endian16(num_query);
  5232. ReadBuf(rb, &zero1, sizeof(USHORT));
  5233. ReadBuf(rb, &zero2, sizeof(USHORT));
  5234. ReadBuf(rb, &zero3, sizeof(USHORT));
  5235. ReadBuf(rb, &name_size, 1);
  5236. ReadBuf(rb, encoded_name, 32);
  5237. ReadBuf(rb, &node_type, 1);
  5238. ReadBuf(rb, &type, sizeof(USHORT));
  5239. type = Endian16(type);
  5240. if (ReadBuf(rb, &classid, sizeof(USHORT)) == sizeof(USHORT))
  5241. {
  5242. classid = Endian16(classid);
  5243. if (((flags >> 11) & 0x0F) == 0 &&
  5244. num_query == 1 && name_size == 0x20 &&
  5245. zero1 == 0 && zero2 == 0 && zero3 == 0 && node_type == 0 && type == 0x0020 && classid == 0x0001)
  5246. {
  5247. char my_pcname[MAX_SIZE];
  5248. // Get the encoded name of this PC
  5249. Zero(my_pcname, sizeof(my_pcname));
  5250. GetMachineHostName(my_pcname, sizeof(my_pcname));
  5251. EncodeNetBiosName(my_pc_encoded_name, my_pcname);
  5252. if (Cmp(my_pc_encoded_name, encoded_name, 30) == 0)
  5253. {
  5254. // Assemble the response packet since the name resolution packet which targets this PC name received
  5255. BUF *sb = NewBuf();
  5256. USHORT us;
  5257. UINT ui;
  5258. LIST *ip_list;
  5259. BUF *ip_list_buf;
  5260. bool found = false;
  5261. WriteBuf(sb, &tran_id, sizeof(USHORT));
  5262. flags = Endian16(0x8500);
  5263. WriteBuf(sb, &flags, sizeof(USHORT));
  5264. num_query = 0;
  5265. WriteBuf(sb, &num_query, sizeof(USHORT));
  5266. us = Endian16(1);
  5267. WriteBuf(sb, &us, sizeof(USHORT));
  5268. us = 0;
  5269. WriteBuf(sb, &us, sizeof(USHORT));
  5270. WriteBuf(sb, &us, sizeof(USHORT));
  5271. name_size = 0x20;
  5272. WriteBuf(sb, &name_size, 1);
  5273. WriteBuf(sb, encoded_name, 32);
  5274. node_type = 0;
  5275. WriteBuf(sb, &node_type, 1);
  5276. type = Endian16(type);
  5277. classid = Endian16(classid);
  5278. WriteBuf(sb, &type, sizeof(USHORT));
  5279. WriteBuf(sb, &classid, sizeof(USHORT));
  5280. ui = Endian32((UINT)(Tick64() / 1000ULL));
  5281. WriteBuf(sb, &ui, sizeof(UINT));
  5282. ip_list_buf = NewBuf();
  5283. ip_list = GetHostIPAddressList();
  5284. if (ip_list != NULL)
  5285. {
  5286. UINT i;
  5287. // Return only private IP if there is a private IP
  5288. for (i = 0;i < LIST_NUM(ip_list);i++)
  5289. {
  5290. IP *ip = LIST_DATA(ip_list, i);
  5291. if (IsIP4(ip) && IsLocalHostIP4(ip) == false && IsZeroIp(ip) == false)
  5292. {
  5293. if (IsIPPrivate(ip))
  5294. {
  5295. USHORT flags = Endian16(0x4000);
  5296. UINT ip_uint = IPToUINT(ip);
  5297. WriteBuf(ip_list_buf, &flags, sizeof(USHORT));
  5298. WriteBuf(ip_list_buf, &ip_uint, sizeof(UINT));
  5299. found = true;
  5300. }
  5301. }
  5302. }
  5303. if (found == false)
  5304. {
  5305. // Return all IP if no private IP are found
  5306. for (i = 0;i < LIST_NUM(ip_list);i++)
  5307. {
  5308. IP *ip = LIST_DATA(ip_list, i);
  5309. if (IsIP4(ip) && IsLocalHostIP4(ip) == false && IsZeroIp(ip) == false)
  5310. {
  5311. USHORT flags = Endian16(0x4000);
  5312. UINT ip_uint = IPToUINT(ip);
  5313. WriteBuf(ip_list_buf, &flags, sizeof(USHORT));
  5314. WriteBuf(ip_list_buf, &ip_uint, sizeof(UINT));
  5315. found = true;
  5316. }
  5317. }
  5318. }
  5319. FreeHostIPAddressList(ip_list);
  5320. }
  5321. us = Endian16(ip_list_buf->Size);
  5322. WriteBuf(sb, &us, sizeof(USHORT));
  5323. WriteBufBuf(sb, ip_list_buf);
  5324. SendUdp(v, src_ip, src_port, v->HostIP, dest_port, sb->Buf, sb->Size);
  5325. FreeBuf(ip_list_buf);
  5326. FreeBuf(sb);
  5327. WHERE;
  5328. }
  5329. }
  5330. }
  5331. FreeBuf(rb);
  5332. return ret;
  5333. }
  5334. // Process the NetBIOS broadcast packet
  5335. void UdpRecvForNetBiosBroadcast(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size, bool dns_proxy, bool unicast)
  5336. {
  5337. // Validate arguments
  5338. if (data == NULL || v == NULL)
  5339. {
  5340. return;
  5341. }
  5342. // Ignore for NetBIOS name registration packet
  5343. if (IsNetbiosRegistrationPacket(data, size) == false)
  5344. {
  5345. if (unicast == false)
  5346. {
  5347. dest_ip = 0xFFFFFFFF;
  5348. }
  5349. if (ProcessNetBiosNameQueryPacketForMyself(v, src_ip, src_port, dest_ip, dest_port, data, size) == false)
  5350. {
  5351. UdpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, data, size, false);
  5352. }
  5353. }
  5354. }
  5355. // Process the UDP packet to the Internet
  5356. void UdpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size, bool dns_proxy)
  5357. {
  5358. NAT_ENTRY *n, t;
  5359. BLOCK *block;
  5360. void *buf;
  5361. UINT dns_ip = 0;
  5362. // Validate arguments
  5363. if (data == NULL || v == NULL)
  5364. {
  5365. return;
  5366. }
  5367. if (dns_proxy)
  5368. {
  5369. // Get the DNS server of the proxy to connect to
  5370. IP ip;
  5371. char tmp[MAX_SIZE];
  5372. if (GetDefaultDns(&ip) == false)
  5373. {
  5374. // Failure
  5375. Debug("Failed to GetDefaultDns()\n");
  5376. return;
  5377. }
  5378. dns_ip = IPToUINT(&ip);
  5379. IPToStr(tmp, sizeof(tmp), &ip);
  5380. Debug("Redirect to DNS Server %s\n", tmp);
  5381. }
  5382. // Examine whether the NAT entry for this packet has already been created
  5383. SetNat(&t, NAT_UDP, src_ip, src_port, dest_ip, dest_port, 0, 0);
  5384. n = SearchNat(v, &t);
  5385. if (n == NULL)
  5386. {
  5387. // Create a NAT entry because it is the first packet
  5388. n = CreateNatUdp(v, src_ip, src_port, dest_ip, dest_port, dns_proxy ? dns_ip : 0);
  5389. if (n == NULL)
  5390. {
  5391. // Entry creation failed
  5392. return;
  5393. }
  5394. if (dns_proxy)
  5395. {
  5396. n->ProxyDns = true;
  5397. n->DestIpProxy = dns_ip;
  5398. }
  5399. }
  5400. // Set the event by inserting the packet into the queue
  5401. buf = Malloc(size);
  5402. Copy(buf, data, size);
  5403. block = NewBlock(buf, size, 0);
  5404. InsertQueue(n->UdpSendQueue, block);
  5405. SetSockEvent(v->SockEvent);
  5406. }
  5407. // Attempt to interpret the DNS packet
  5408. bool ParseDnsPacket(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5409. {
  5410. return ParseDnsPacketEx(v, src_ip, src_port, dest_ip, dest_port, data, size, NULL);
  5411. }
  5412. bool ParseDnsPacketEx(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size, DNS_PARSED_PACKET *parsed_result)
  5413. {
  5414. DNSV4_HEADER *dns;
  5415. NAT_ENTRY *nat;
  5416. UINT transaction_id;
  5417. void *query_data;
  5418. UINT query_data_size;
  5419. char hostname[256];
  5420. // Validate arguments
  5421. if (v == NULL || data == NULL || size == 0)
  5422. {
  5423. return false;
  5424. }
  5425. // Check the header size
  5426. if (size < sizeof(DNSV4_HEADER))
  5427. {
  5428. // Undersize
  5429. return false;
  5430. }
  5431. // DNS header acquisition
  5432. dns = (DNSV4_HEADER *)data;
  5433. transaction_id = Endian16(dns->TransactionId);
  5434. if ((dns->Flag1 & 78) != 0 || (dns->Flag1 & 0x80) != 0)
  5435. {
  5436. // Illegal opcode
  5437. return false;
  5438. }
  5439. if (Endian16(dns->NumQuery) != 1)
  5440. {
  5441. // Number of queries is invalid
  5442. return false;
  5443. }
  5444. query_data = ((UCHAR *)dns) + sizeof(DNSV4_HEADER);
  5445. query_data_size = size - sizeof(DNSV4_HEADER);
  5446. // Interpret the query
  5447. if (ParseDnsQuery(hostname, sizeof(hostname), query_data, query_data_size) == false)
  5448. {
  5449. // Interpretation fails
  5450. return false;
  5451. }
  5452. if (parsed_result != NULL)
  5453. {
  5454. // Only analyse without processing
  5455. Zero(parsed_result, sizeof(DNS_PARSED_PACKET));
  5456. StrCpy(parsed_result->Hostname, sizeof(parsed_result->Hostname), hostname);
  5457. parsed_result->TransactionId = transaction_id;
  5458. return true;
  5459. }
  5460. // Create a DNS entry
  5461. nat = CreateNatDns(v, src_ip, src_port, dest_ip, dest_port, transaction_id,
  5462. false, hostname);
  5463. if (nat == false)
  5464. {
  5465. return false;
  5466. }
  5467. return true;
  5468. }
  5469. // Send the NAT DNS response packet
  5470. void SendNatDnsResponse(VH *v, NAT_ENTRY *n)
  5471. {
  5472. BUF *b;
  5473. UINT dns_header_size;
  5474. DNSV4_HEADER *dns;
  5475. UINT src_ip;
  5476. // Validate arguments
  5477. if (n == NULL || v == NULL)
  5478. {
  5479. return;
  5480. }
  5481. // Generate the data
  5482. b = NewBuf();
  5483. // Add a Query
  5484. if (n->DnsGetIpFromHost == false)
  5485. {
  5486. BuildDnsQueryPacket(b, n->DnsTargetHostName, false);
  5487. }
  5488. else
  5489. {
  5490. BuildDnsQueryPacket(b, n->DnsTargetHostName, true);
  5491. }
  5492. // Add a Response
  5493. if (n->DnsOk)
  5494. {
  5495. if (n->DnsGetIpFromHost == false)
  5496. {
  5497. BuildDnsResponsePacketA(b, &n->DnsResponseIp);
  5498. }
  5499. else
  5500. {
  5501. BuildDnsResponsePacketPtr(b, n->DnsResponseHostName);
  5502. }
  5503. }
  5504. // Generate a DNS header
  5505. dns_header_size = sizeof(DNSV4_HEADER) + b->Size;
  5506. dns = ZeroMalloc(dns_header_size);
  5507. dns->TransactionId = Endian16((USHORT)n->DnsTransactionId);
  5508. // Generate a response flag
  5509. if (n->DnsOk)
  5510. {
  5511. dns->Flag1 = 0x85;
  5512. dns->Flag2 = 0x80;
  5513. }
  5514. else
  5515. {
  5516. dns->Flag1 = 0x85;
  5517. dns->Flag2 = 0x83;
  5518. }
  5519. dns->NumQuery = Endian16(1);
  5520. dns->AnswerRRs = Endian16(n->DnsOk != false ? 1 : 0);
  5521. dns->AuthorityRRs = 0;
  5522. dns->AdditionalRRs = 0;
  5523. // Settings, such as the source IP address
  5524. src_ip = n->DestIp;
  5525. if (src_ip == Endian32(SPECIAL_IPV4_ADDR_LLMNR_DEST) && n->DestPort == SPECIAL_UDP_PORT_LLMNR)
  5526. {
  5527. // Make a unicast response in the case of LLMNR packet
  5528. src_ip = v->HostIP;
  5529. dns->Flag1 = 0x84;
  5530. dns->Flag2 = 0x00;
  5531. }
  5532. // Copy data
  5533. Copy(((UCHAR *)dns) + sizeof(DNSV4_HEADER), b->Buf, b->Size);
  5534. // Send this packet
  5535. SendUdp(v, n->SrcIp, n->SrcPort, src_ip, n->DestPort, dns, dns_header_size);
  5536. // Release the memory
  5537. Free(dns);
  5538. FreeBuf(b);
  5539. }
  5540. // Generate a DNS response packet (host name)
  5541. void BuildDnsResponsePacketPtr(BUF *b, char *hostname)
  5542. {
  5543. USHORT magic;
  5544. USHORT type, clas;
  5545. UINT ttl;
  5546. USHORT len;
  5547. BUF *c;
  5548. // Validate arguments
  5549. if (b == NULL || hostname == NULL)
  5550. {
  5551. return;
  5552. }
  5553. magic = Endian16(0xc00c);
  5554. type = Endian16(0x000c);
  5555. clas = Endian16(0x0001);
  5556. ttl = Endian32(NAT_DNS_RESPONSE_TTL);
  5557. c = BuildDnsHostName(hostname);
  5558. if (c == NULL)
  5559. {
  5560. return;
  5561. }
  5562. len = Endian16((USHORT)c->Size);
  5563. WriteBuf(b, &magic, 2);
  5564. WriteBuf(b, &type, 2);
  5565. WriteBuf(b, &clas, 2);
  5566. WriteBuf(b, &ttl, 4);
  5567. WriteBuf(b, &len, 2);
  5568. WriteBuf(b, c->Buf, c->Size);
  5569. FreeBuf(c);
  5570. }
  5571. // Generate a DNS response packet (host IP address)
  5572. void BuildDnsResponsePacketA(BUF *b, IP *ip)
  5573. {
  5574. UINT ip_addr;
  5575. USHORT magic;
  5576. USHORT type, clas;
  5577. UINT ttl;
  5578. USHORT len;
  5579. // Validate arguments
  5580. if (b == NULL || ip == NULL)
  5581. {
  5582. return;
  5583. }
  5584. ip_addr = IPToUINT(ip);
  5585. magic = Endian16(0xc00c);
  5586. type = Endian16(0x0001);
  5587. clas = Endian16(0x0001);
  5588. ttl = Endian32(NAT_DNS_RESPONSE_TTL);
  5589. len = Endian16((USHORT)sizeof(ttl));
  5590. WriteBuf(b, &magic, sizeof(magic));
  5591. WriteBuf(b, &type, sizeof(type));
  5592. WriteBuf(b, &clas, sizeof(clas));
  5593. WriteBuf(b, &ttl, sizeof(ttl));
  5594. WriteBuf(b, &len, sizeof(len));
  5595. WriteBuf(b, &ip_addr, sizeof(ip_addr));
  5596. }
  5597. // Generate a DNS query data packet
  5598. void BuildDnsQueryPacket(BUF *b, char *hostname, bool ptr)
  5599. {
  5600. USHORT val;
  5601. BUF *c;
  5602. // Validate arguments
  5603. if (b == NULL || hostname == NULL)
  5604. {
  5605. return;
  5606. }
  5607. // Convert the host name to a buffer
  5608. c = BuildDnsHostName(hostname);
  5609. if (c == NULL)
  5610. {
  5611. return;
  5612. }
  5613. WriteBuf(b, c->Buf, c->Size);
  5614. FreeBuf(c);
  5615. // Type and class
  5616. if (ptr == false)
  5617. {
  5618. val = Endian16(0x0001);
  5619. }
  5620. else
  5621. {
  5622. val = Endian16(0x000c);
  5623. }
  5624. WriteBuf(b, &val, 2);
  5625. val = Endian16(0x0001);
  5626. WriteBuf(b, &val, 2);
  5627. }
  5628. // Generate a DNS host name buffer
  5629. BUF *BuildDnsHostName(char *hostname)
  5630. {
  5631. UINT i;
  5632. UCHAR size;
  5633. TOKEN_LIST *token;
  5634. BUF *b;
  5635. // Validate arguments
  5636. if (hostname == NULL)
  5637. {
  5638. return NULL;
  5639. }
  5640. // Split the host name into tokens
  5641. token = ParseToken(hostname, ".");
  5642. if (token == NULL)
  5643. {
  5644. return NULL;
  5645. }
  5646. b = NewBuf();
  5647. // Add a host string
  5648. for (i = 0;i < token->NumTokens;i++)
  5649. {
  5650. size = (UCHAR)StrLen(token->Token[i]);
  5651. WriteBuf(b, &size, 1);
  5652. WriteBuf(b, token->Token[i], size);
  5653. }
  5654. // NULL character
  5655. size = 0;
  5656. WriteBuf(b, &size, 1);
  5657. SeekBuf(b, 0, 0);
  5658. FreeToken(token);
  5659. return b;
  5660. }
  5661. // Process the NAT DNS entry
  5662. void PollingNatDns(VH *v, NAT_ENTRY *n)
  5663. {
  5664. // Validate arguments
  5665. if (v == NULL || n == NULL)
  5666. {
  5667. return;
  5668. }
  5669. if (n->DnsFinished)
  5670. {
  5671. if (n->DnsPollingFlag == false)
  5672. {
  5673. n->DnsPollingFlag = true;
  5674. // Process has been completed
  5675. SendNatDnsResponse(v, n);
  5676. // Terminating
  5677. n->DisconnectNow = true;
  5678. }
  5679. }
  5680. }
  5681. // Create a NAT DNS entry
  5682. NAT_ENTRY *CreateNatDns(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port,
  5683. UINT transaction_id, bool dns_get_ip_from_host, char *dns_target_host_name)
  5684. {
  5685. NAT_ENTRY *n;
  5686. HUB_OPTION *o;
  5687. // Validate arguments
  5688. if (v == NULL || dns_target_host_name == NULL)
  5689. {
  5690. return NULL;
  5691. }
  5692. if (CanCreateNewNatEntry(v) == false)
  5693. {
  5694. return NULL;
  5695. }
  5696. o = NatGetHubOption(v);
  5697. if (o != NULL && o->SecureNAT_MaxDnsSessionsPerIp != 0)
  5698. {
  5699. if (GetNumNatEntriesPerIp(v, src_ip, NAT_DNS, false) >= o->SecureNAT_MaxDnsSessionsPerIp)
  5700. {
  5701. NAT_ENTRY *oldest = GetOldestNatEntryOfIp(v, src_ip, NAT_DNS);
  5702. if (oldest != NULL)
  5703. {
  5704. DisconnectNatEntryNow(v, oldest);
  5705. }
  5706. }
  5707. }
  5708. n = ZeroMalloc(sizeof(NAT_ENTRY));
  5709. n->Id = Inc(v->Counter);
  5710. n->v = v;
  5711. n->lock = NewLock();
  5712. n->Protocol = NAT_DNS;
  5713. n->SrcIp = src_ip;
  5714. n->SrcPort = src_port;
  5715. n->DestIp = dest_ip;
  5716. n->DestPort = dest_port;
  5717. n->DnsTransactionId = transaction_id;
  5718. n->CreatedTime = n->LastCommTime = v->Now;
  5719. n->DisconnectNow = false;
  5720. n->DnsGetIpFromHost = false;
  5721. n->DnsTargetHostName = CopyStr(dns_target_host_name);
  5722. Add(v->NatTable, n);
  5723. #if 1
  5724. {
  5725. IP ip1, ip2;
  5726. char s1[MAX_SIZE], s2[MAX_SIZE];
  5727. UINTToIP(&ip1, src_ip);
  5728. UINTToIP(&ip2, dest_ip);
  5729. IPToStr(s1, 0, &ip1);
  5730. IPToStr(s2, 0, &ip2);
  5731. Debug("NAT_ENTRY: CreateNatDns %s %u -> %s %u\n", s1, src_port, s2, dest_port);
  5732. }
  5733. #endif
  5734. return n;
  5735. }
  5736. // Get the next byte
  5737. UCHAR GetNextByte(BUF *b)
  5738. {
  5739. UCHAR c = 0;
  5740. // Validate arguments
  5741. if (b == NULL)
  5742. {
  5743. return 0;
  5744. }
  5745. if (ReadBuf(b, &c, 1) != 1)
  5746. {
  5747. return 0;
  5748. }
  5749. return c;
  5750. }
  5751. // Interpret the DNS query
  5752. bool ParseDnsQuery(char *name, UINT name_size, void *data, UINT data_size)
  5753. {
  5754. BUF *b;
  5755. char tmp[257];
  5756. bool ok = true;
  5757. USHORT val;
  5758. // Validate arguments
  5759. if (name == NULL || data == NULL || data_size == 0)
  5760. {
  5761. return false;
  5762. }
  5763. StrCpy(name, name_size, "");
  5764. b = NewBuf();
  5765. WriteBuf(b, data, data_size);
  5766. SeekBuf(b, 0, 0);
  5767. while (true)
  5768. {
  5769. UINT next_len = (UINT)GetNextByte(b);
  5770. if (next_len > 0)
  5771. {
  5772. // Read only the specified length
  5773. Zero(tmp, sizeof(tmp));
  5774. if (ReadBuf(b, tmp, next_len) != next_len)
  5775. {
  5776. ok = false;
  5777. break;
  5778. }
  5779. // Append
  5780. if (StrLen(name) != 0)
  5781. {
  5782. StrCat(name, name_size, ".");
  5783. }
  5784. StrCat(name, name_size, tmp);
  5785. }
  5786. else
  5787. {
  5788. // Read all
  5789. break;
  5790. }
  5791. }
  5792. if (ReadBuf(b, &val, sizeof(val)) != sizeof(val))
  5793. {
  5794. ok = false;
  5795. }
  5796. else
  5797. {
  5798. if (Endian16(val) != 0x01 && Endian16(val) != 0x0c)
  5799. {
  5800. ok = false;
  5801. }
  5802. }
  5803. if (ReadBuf(b, &val, sizeof(val)) != sizeof(val))
  5804. {
  5805. ok = false;
  5806. }
  5807. else
  5808. {
  5809. if (Endian16(val) != 0x01)
  5810. {
  5811. ok = false;
  5812. }
  5813. }
  5814. FreeBuf(b);
  5815. if (ok == false || StrLen(name) == 0)
  5816. {
  5817. return false;
  5818. }
  5819. else
  5820. {
  5821. return true;
  5822. }
  5823. }
  5824. // Set the VGS host name
  5825. void SetDnsProxyVgsHostname(char *hostname)
  5826. {
  5827. // Validate arguments
  5828. if (hostname == NULL)
  5829. {
  5830. return;
  5831. }
  5832. StrCpy(v_vgs_hostname, sizeof(v_vgs_hostname), hostname);
  5833. }
  5834. // Operate as a DNS proxy
  5835. void DnsProxy(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5836. {
  5837. // Validate arguments
  5838. if (v == NULL || data == NULL || size == 0)
  5839. {
  5840. return;
  5841. }
  5842. if (dest_port == SPECIAL_UDP_PORT_LLMNR)
  5843. {
  5844. // Process by analyzing the DNS query in the case of LLMNR
  5845. ParseDnsPacket(v, src_ip, src_port, dest_ip, dest_port, data, size);
  5846. }
  5847. else
  5848. {
  5849. // Forward the packet as it is in the case of a normal DNS packet
  5850. if (IsEmptyStr(v_vgs_hostname) == false)
  5851. {
  5852. // Response by proxy in the case of trying to get the IP of the VGS
  5853. DNS_PARSED_PACKET p;
  5854. Zero(&p, sizeof(p));
  5855. if (ParseDnsPacketEx(v, src_ip, src_port, dest_ip, dest_port, data, size, &p))
  5856. {
  5857. if (StrCmpi(p.Hostname, "254.254.211.10.in-addr.arpa") == 0)
  5858. {
  5859. NAT_ENTRY n;
  5860. Zero(&n, sizeof(n));
  5861. n.DnsTargetHostName = p.Hostname;
  5862. n.DnsGetIpFromHost = true;
  5863. n.DnsResponseHostName = v_vgs_hostname;
  5864. n.DnsTransactionId = p.TransactionId;
  5865. n.DnsOk = true;
  5866. n.DestIp = dest_ip;
  5867. n.SrcIp = src_ip;
  5868. n.DestPort = dest_port;
  5869. n.SrcPort = src_port;
  5870. SendNatDnsResponse(v, &n);
  5871. return;
  5872. }
  5873. }
  5874. }
  5875. UdpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, data, size, true);
  5876. }
  5877. }
  5878. // Process the LLMNR query
  5879. void UdpRecvLlmnr(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5880. {
  5881. // Validate arguments
  5882. if (data == NULL || v == NULL)
  5883. {
  5884. return;
  5885. }
  5886. if (dest_port == SPECIAL_UDP_PORT_LLMNR)
  5887. {
  5888. // DNS proxy start
  5889. DnsProxy(v, src_ip, src_port, dest_ip, dest_port, data, size);
  5890. }
  5891. }
  5892. // Process the UDP packet to the virtual host
  5893. void UdpRecvForMe(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5894. {
  5895. // Validate arguments
  5896. if (data == NULL || v == NULL)
  5897. {
  5898. return;
  5899. }
  5900. if (dest_port == NAT_DNS_PROXY_PORT)
  5901. {
  5902. // DNS proxy start
  5903. DnsProxy(v, src_ip, src_port, dest_ip, dest_port, data, size);
  5904. }
  5905. }
  5906. // Process the UDP broadcast packet
  5907. void UdpRecvForBroadcast(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, void *data, UINT size)
  5908. {
  5909. // Validate arguments
  5910. if (data == NULL || v == NULL)
  5911. {
  5912. return;
  5913. }
  5914. }
  5915. // An UDP packet has been received
  5916. void VirtualUdpReceived(VH *v, UINT src_ip, UINT dest_ip, void *data, UINT size, bool mac_broadcast, bool is_localmac, UINT max_l3_size)
  5917. {
  5918. UDP_HEADER *udp;
  5919. UINT packet_length;
  5920. void *buf;
  5921. UINT buf_size;
  5922. UINT src_port, dest_port;
  5923. // Validate arguments
  5924. if (v == NULL || data == NULL)
  5925. {
  5926. return;
  5927. }
  5928. // Check the header
  5929. udp = (UDP_HEADER *)data;
  5930. if (size < UDP_HEADER_SIZE)
  5931. {
  5932. return;
  5933. }
  5934. packet_length = Endian16(udp->PacketLength);
  5935. if (packet_length != size)
  5936. {
  5937. return;
  5938. }
  5939. buf = ((UCHAR *)data) + UDP_HEADER_SIZE;
  5940. buf_size = size - UDP_HEADER_SIZE;
  5941. src_port = Endian16(udp->SrcPort);
  5942. dest_port = Endian16(udp->DstPort);
  5943. // Check the port number
  5944. if (dest_port == 0)
  5945. {
  5946. // Port number is invalid
  5947. return;
  5948. }
  5949. // Determine whether it's broadcast packet or packet addressed to myself
  5950. if (dest_ip == v->HostIP)
  5951. {
  5952. // IP packet addressed to myself has arrived
  5953. UdpRecvForMe(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size);
  5954. }
  5955. else if ((mac_broadcast || dest_ip == Endian32(0xE00000FC)) && dest_port == SPECIAL_UDP_PORT_LLMNR)
  5956. {
  5957. if (is_localmac == false)
  5958. {
  5959. // Packet addressed to 224.0.0.252 (LLMNR) arrives
  5960. UdpRecvLlmnr(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size);
  5961. }
  5962. }
  5963. else if (mac_broadcast && (dest_port == SPECIAL_UDP_PORT_WSD || dest_port == SPECIAL_UDP_PORT_SSDP))
  5964. {
  5965. if (is_localmac == false)
  5966. {
  5967. // WS-Discovery packet arrives
  5968. UdpRecvForInternet(v, src_ip, src_port, 0xFFFFFFFF, dest_port, buf, buf_size, false);
  5969. }
  5970. }
  5971. else if (mac_broadcast && (dest_port == SPECIAL_UDP_PORT_NBTDGM || dest_port == SPECIAL_UDP_PORT_NBTNS))
  5972. {
  5973. if (is_localmac == false)
  5974. {
  5975. // NetBIOS Broadcast packet arrived
  5976. UdpRecvForNetBiosBroadcast(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size, false, false);
  5977. }
  5978. }
  5979. else if (mac_broadcast || dest_ip == 0xffffffff || dest_ip == GetBroadcastAddress(v->HostIP, v->HostMask))
  5980. {
  5981. if (is_localmac == false)
  5982. {
  5983. // Broadcast packet arrived
  5984. UdpRecvForBroadcast(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size);
  5985. }
  5986. }
  5987. else if (IsInNetwork(dest_ip, v->HostIP, v->HostMask) == false)
  5988. {
  5989. // Packets to other than local address (that is on the Internet) has been received
  5990. if (NnIsActive(v) == false)
  5991. {
  5992. if (v->HubOption != NULL && v->HubOption->DisableUserModeSecureNAT)
  5993. {
  5994. // User-mode NAT is disabled
  5995. return;
  5996. }
  5997. // User-mode NAT
  5998. UdpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size, false);
  5999. }
  6000. else
  6001. {
  6002. // Kernel-mode NAT
  6003. NnUdpRecvForInternet(v, src_ip, src_port, dest_ip, dest_port, buf, buf_size, max_l3_size);
  6004. }
  6005. }
  6006. else
  6007. {
  6008. // Local address has arrived. Ignore it
  6009. }
  6010. }
  6011. // Determine the network address of the subnet to which the specified IP address belongs
  6012. UINT GetNetworkAddress(UINT addr, UINT mask)
  6013. {
  6014. return (addr & mask);
  6015. }
  6016. // Determine the broadcast address of the subnet to which the specified IP address belongs
  6017. UINT GetBroadcastAddress(UINT addr, UINT mask)
  6018. {
  6019. return ((addr & mask) | (~mask));
  6020. }
  6021. void GetBroadcastAddress4(IP *dst, IP *addr, IP *mask)
  6022. {
  6023. // Validate arguments
  6024. if (dst == NULL || IsIP4(addr) == false || IsIP4(mask) == false)
  6025. {
  6026. Zero(dst, sizeof(IP));
  6027. return;
  6028. }
  6029. UINTToIP(dst, GetBroadcastAddress(IPToUINT(addr), IPToUINT(mask)));
  6030. }
  6031. // Determine whether the specified IP address belongs to the sub-network that is
  6032. // represented by a another specified network address and a subnet mask
  6033. bool IsInNetwork(UINT uni_addr, UINT network_addr, UINT mask)
  6034. {
  6035. if (GetNetworkAddress(uni_addr, mask) == GetNetworkAddress(network_addr, mask))
  6036. {
  6037. return true;
  6038. }
  6039. return false;
  6040. }
  6041. // Send an UDP packet
  6042. void SendUdp(VH *v, UINT dest_ip, UINT dest_port, UINT src_ip, UINT src_port, void *data, UINT size)
  6043. {
  6044. UDPV4_PSEUDO_HEADER *vh;
  6045. UDP_HEADER *udp;
  6046. UINT udp_packet_length = UDP_HEADER_SIZE + size;
  6047. USHORT checksum;
  6048. // Validate arguments
  6049. if (v == NULL || data == NULL)
  6050. {
  6051. return;
  6052. }
  6053. if (udp_packet_length > 65536)
  6054. {
  6055. return;
  6056. }
  6057. // Generate a virtual header
  6058. vh = Malloc(sizeof(UDPV4_PSEUDO_HEADER) + size);
  6059. udp = (UDP_HEADER *)(((UCHAR *)vh) + 12);
  6060. vh->SrcIP = src_ip;
  6061. vh->DstIP = dest_ip;
  6062. vh->Reserved = 0;
  6063. vh->Protocol = IP_PROTO_UDP;
  6064. vh->PacketLength1 = Endian16((USHORT)udp_packet_length);
  6065. udp->SrcPort = Endian16((USHORT)src_port);
  6066. udp->DstPort = Endian16((USHORT)dest_port);
  6067. udp->PacketLength = Endian16((USHORT)udp_packet_length);
  6068. udp->Checksum = 0;
  6069. // Copy data
  6070. Copy(((UCHAR *)udp) + UDP_HEADER_SIZE, data, size);
  6071. // Calculate the checksum
  6072. checksum = IpChecksum(vh, udp_packet_length + 12);
  6073. if (checksum == 0x0000)
  6074. {
  6075. checksum = 0xffff;
  6076. }
  6077. udp->Checksum = checksum;
  6078. // Send a packet
  6079. SendIp(v, dest_ip, src_ip, IP_PROTO_UDP, udp, udp_packet_length);
  6080. // Release the memory
  6081. Free(vh);
  6082. }
  6083. // Poll the IP combining object
  6084. void PollingIpCombine(VH *v)
  6085. {
  6086. LIST *o;
  6087. UINT i;
  6088. // Validate arguments
  6089. if (v == NULL)
  6090. {
  6091. return;
  6092. }
  6093. // Discard the old combining object
  6094. o = NULL;
  6095. for (i = 0;i < LIST_NUM(v->IpCombine);i++)
  6096. {
  6097. IP_COMBINE *c = LIST_DATA(v->IpCombine, i);
  6098. if (c->Expire < v->Now)
  6099. {
  6100. if (o == NULL)
  6101. {
  6102. o = NewListFast(NULL);
  6103. }
  6104. Add(o, c);
  6105. }
  6106. }
  6107. if (o != NULL)
  6108. {
  6109. for (i = 0;i < LIST_NUM(o);i++)
  6110. {
  6111. IP_COMBINE *c = LIST_DATA(o, i);
  6112. // Remove from the list
  6113. Delete(v->IpCombine, c);
  6114. // Release the memory
  6115. FreeIpCombine(v, c);
  6116. }
  6117. ReleaseList(o);
  6118. }
  6119. }
  6120. // Send an ICMP packet
  6121. void VirtualIcmpSend(VH *v, UINT src_ip, UINT dst_ip, void *data, UINT size)
  6122. {
  6123. ICMP_HEADER *icmp;
  6124. void *data_buf;
  6125. // Validate arguments
  6126. if (v == NULL || data == NULL)
  6127. {
  6128. return;
  6129. }
  6130. // Build the header
  6131. icmp = ZeroMalloc(sizeof(ICMP_HEADER) + size);
  6132. // Data copy
  6133. data_buf = ((UCHAR *)icmp) + sizeof(ICMP_HEADER);
  6134. Copy(data_buf, data, size);
  6135. // Other
  6136. icmp->Checksum = 0;
  6137. icmp->Code = 0;
  6138. icmp->Type = ICMP_TYPE_ECHO_RESPONSE;
  6139. // Checksum
  6140. icmp->Checksum = IpChecksum(icmp, sizeof(ICMP_HEADER) + size);
  6141. // IP packet transmission
  6142. SendIp(v, dst_ip, src_ip, IP_PROTO_ICMPV4, icmp, sizeof(ICMP_HEADER) + size);
  6143. // Release the memory
  6144. Free(icmp);
  6145. }
  6146. // Send the ICMP Echo Response packet
  6147. void VirtualIcmpEchoSendResponse(VH *v, UINT src_ip, UINT dst_ip, USHORT id, USHORT seq_no, void *data, UINT size)
  6148. {
  6149. ICMP_ECHO *e;
  6150. // Validate arguments
  6151. if (v == NULL || data == NULL)
  6152. {
  6153. return;
  6154. }
  6155. // Build the header
  6156. e = ZeroMalloc(sizeof(ICMP_ECHO) + size);
  6157. e->Identifier = Endian16(id);
  6158. e->SeqNo = Endian16(seq_no);
  6159. // Data copy
  6160. Copy(((UCHAR *)e) + sizeof(ICMP_ECHO), data, size);
  6161. // Send an ICMP
  6162. VirtualIcmpSend(v, src_ip, dst_ip, e, sizeof(ICMP_ECHO) + size);
  6163. // Release the memory
  6164. Free(e);
  6165. }
  6166. // Treat the ICMP Echo Request packet with a Raw Socket
  6167. void VirtualIcmpEchoRequestReceivedRaw(VH *v, UINT src_ip, UINT dst_ip, void *data, UINT size, UCHAR ttl, void *icmp_data, UINT icmp_size, UCHAR *ip_header, UINT ip_header_size)
  6168. {
  6169. ICMP_ECHO *echo;
  6170. UINT data_size;
  6171. void *data_buf;
  6172. USHORT id, seq_no;
  6173. void *buf;
  6174. BLOCK *block;
  6175. // Validate arguments
  6176. if (v == NULL || data == NULL || icmp_data == NULL || ip_header == NULL)
  6177. {
  6178. return;
  6179. }
  6180. if (ttl == 0)
  6181. {
  6182. ttl = 1;
  6183. }
  6184. echo = (ICMP_ECHO *)data;
  6185. // Echo size check
  6186. if (size < sizeof(ICMP_ECHO))
  6187. {
  6188. // Insufficient data
  6189. return;
  6190. }
  6191. id = Endian16(echo->Identifier);
  6192. seq_no = Endian16(echo->SeqNo);
  6193. // Data size
  6194. data_size = size - sizeof(ICMP_ECHO);
  6195. // Data body
  6196. data_buf = ((UCHAR *)data) + sizeof(ICMP_ECHO);
  6197. if (dst_ip == v->HostIP)
  6198. {
  6199. // Respond because it is addressed to me
  6200. VirtualIcmpEchoSendResponse(v, v->HostIP, src_ip, id, seq_no, data_buf, data_size);
  6201. }
  6202. else if (IsInNetwork(dst_ip, v->HostIP, v->HostMask) == false)
  6203. {
  6204. NAT_ENTRY *n = NULL, t;
  6205. // Process by creating a NAT entry because it is addressed to the Internet
  6206. if (ttl <= 1)
  6207. {
  6208. // Reply the Time Exceeded immediately for the packet whose TTL is 1
  6209. UINT reply_size = sizeof(ICMP_HEADER) + 4 + ip_header_size + 8;
  6210. UCHAR *reply_data = ZeroMalloc(reply_size);
  6211. ICMP_HEADER *icmp = (ICMP_HEADER *)reply_data;
  6212. icmp->Type = ICMP_TYPE_TIME_EXCEEDED;
  6213. icmp->Code = ICMP_CODE_TTL_EXCEEDED_IN_TRANSIT;
  6214. Copy(reply_data + sizeof(ICMP_HEADER) + 4, ip_header, ip_header_size);
  6215. Copy(reply_data + sizeof(ICMP_HEADER) + 4 + ip_header_size, icmp_data, MIN(icmp_size, 8));
  6216. icmp->Checksum = IpChecksum(icmp, reply_size);
  6217. SendIp(v, src_ip, v->HostIP, IP_PROTO_ICMPV4, reply_data, reply_size);
  6218. Free(reply_data);
  6219. }
  6220. else
  6221. {
  6222. SetNat(&t, NAT_ICMP, src_ip, id, dst_ip, id, 0, 0);
  6223. if (v->IcmpRawSocketOk)
  6224. {
  6225. // Examine whether a NAT entry for this packet has already been created
  6226. n = SearchNat(v, &t);
  6227. }
  6228. if (n == NULL)
  6229. {
  6230. // Create a NAT entry because it is the first packet
  6231. n = CreateNatIcmp(v, src_ip, id, dst_ip, id, (UCHAR *)ip_header, ip_header_size + 8);
  6232. if (n == NULL)
  6233. {
  6234. // Entry creation failed
  6235. return;
  6236. }
  6237. }
  6238. // Set the event by inserting the packet into the queue
  6239. buf = Malloc(icmp_size);
  6240. Copy(buf, icmp_data, icmp_size);
  6241. block = NewBlock(buf, icmp_size, 0);
  6242. block->Ttl = MAKESURE(ttl - 1, 1, 255);
  6243. InsertQueue(n->UdpSendQueue, block);
  6244. SetSockEvent(v->SockEvent);
  6245. }
  6246. }
  6247. }
  6248. // Receive an ICMP Echo Request packet
  6249. void VirtualIcmpEchoRequestReceived(VH *v, UINT src_ip, UINT dst_ip, void *data, UINT size, UCHAR ttl, void *icmp_data, UINT icmp_size, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size)
  6250. {
  6251. ICMP_ECHO *echo;
  6252. UINT data_size;
  6253. void *data_buf;
  6254. USHORT id, seq_no;
  6255. // Validate arguments
  6256. if (v == NULL || data == NULL || icmp_data == NULL)
  6257. {
  6258. return;
  6259. }
  6260. if (NnIsActive(v))
  6261. {
  6262. // Process by the Native NAT
  6263. NnIcmpEchoRecvForInternet(v, src_ip, dst_ip, data, size, ttl, icmp_data, icmp_size,
  6264. ip_header, ip_header_size, max_l3_size);
  6265. return;
  6266. }
  6267. if (v->HubOption != NULL && v->HubOption->DisableUserModeSecureNAT)
  6268. {
  6269. // User-mode NAT is disabled
  6270. return;
  6271. }
  6272. if (v->IcmpRawSocketOk || v->IcmpApiOk)
  6273. {
  6274. // Process in the Raw Socket
  6275. VirtualIcmpEchoRequestReceivedRaw(v, src_ip, dst_ip, data, size, ttl, icmp_data, icmp_size,
  6276. ip_header, ip_header_size);
  6277. return;
  6278. }
  6279. // Returns the fake ICMP forcibly if any of Native NAT or Raw Socket can not be used
  6280. echo = (ICMP_ECHO *)data;
  6281. // Echo size check
  6282. if (size < sizeof(ICMP_ECHO))
  6283. {
  6284. // Insufficient data
  6285. return;
  6286. }
  6287. id = Endian16(echo->Identifier);
  6288. seq_no = Endian16(echo->SeqNo);
  6289. // Data size
  6290. data_size = size - sizeof(ICMP_ECHO);
  6291. // Data body
  6292. data_buf = ((UCHAR *)data) + sizeof(ICMP_ECHO);
  6293. // Return the ICMP Echo Response
  6294. VirtualIcmpEchoSendResponse(v, dst_ip, src_ip, id, seq_no, data_buf, data_size);
  6295. }
  6296. // An ICMP packet has been received
  6297. void VirtualIcmpReceived(VH *v, UINT src_ip, UINT dst_ip, void *data, UINT size, UCHAR ttl, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size)
  6298. {
  6299. ICMP_HEADER *icmp;
  6300. UINT msg_size;
  6301. USHORT checksum_calc, checksum_original;
  6302. // Validate arguments
  6303. if (v == NULL || data == NULL)
  6304. {
  6305. return;
  6306. }
  6307. // Size check
  6308. if (size < sizeof(ICMP_HEADER))
  6309. {
  6310. return;
  6311. }
  6312. // ICMP header
  6313. icmp = (ICMP_HEADER *)data;
  6314. // Get the ICMP message size
  6315. msg_size = size - sizeof(ICMP_HEADER);
  6316. // Check the checksum of the ICMP header
  6317. checksum_original = icmp->Checksum;
  6318. icmp->Checksum = 0;
  6319. checksum_calc = IpChecksum(data, size);
  6320. icmp->Checksum = checksum_original;
  6321. if (checksum_calc != checksum_original)
  6322. {
  6323. // Checksum is invalid
  6324. Debug("ICMP CheckSum Failed.\n");
  6325. return;
  6326. }
  6327. // Identified by the opcode
  6328. switch (icmp->Type)
  6329. {
  6330. case ICMP_TYPE_ECHO_REQUEST: // ICMP Echo request
  6331. VirtualIcmpEchoRequestReceived(v, src_ip, dst_ip, ((UCHAR *)data) + sizeof(ICMP_HEADER), msg_size, ttl,
  6332. icmp, size, ip_header, ip_header_size, max_l3_size);
  6333. break;
  6334. case ICMP_TYPE_ECHO_RESPONSE: // ICMP Echo response
  6335. // Do Nothing
  6336. break;
  6337. }
  6338. }
  6339. // Received an IP packet
  6340. void IpReceived(VH *v, UINT src_ip, UINT dest_ip, UINT protocol, void *data, UINT size, bool mac_broadcast, UCHAR ttl, UCHAR *ip_header, UINT ip_header_size, bool is_local_mac, UINT max_l3_size)
  6341. {
  6342. // Validate arguments
  6343. if (v == NULL || data == NULL)
  6344. {
  6345. return;
  6346. }
  6347. // Deliver the data to the supported high-level protocol
  6348. switch (protocol)
  6349. {
  6350. case IP_PROTO_ICMPV4: // ICMPv4
  6351. if (mac_broadcast == false)
  6352. {
  6353. VirtualIcmpReceived(v, src_ip, dest_ip, data, size, ttl, ip_header, ip_header_size, max_l3_size);
  6354. }
  6355. break;
  6356. case IP_PROTO_TCP: // TCP
  6357. if (mac_broadcast == false)
  6358. {
  6359. VirtualTcpReceived(v, src_ip, dest_ip, data, size, max_l3_size);
  6360. }
  6361. break;
  6362. case IP_PROTO_UDP: // UDP
  6363. VirtualUdpReceived(v, src_ip, dest_ip, data, size, mac_broadcast, is_local_mac, max_l3_size);
  6364. break;
  6365. }
  6366. }
  6367. // Combine the IP packet received to the IP combining object
  6368. void CombineIp(VH *v, IP_COMBINE *c, UINT offset, void *data, UINT size, bool last_packet, UCHAR *head_ip_header_data, UINT head_ip_header_size)
  6369. {
  6370. UINT i;
  6371. IP_PART *p;
  6372. UINT need_size;
  6373. UINT data_size_delta;
  6374. // Validate arguments
  6375. if (c == NULL || data == NULL)
  6376. {
  6377. return;
  6378. }
  6379. // Check the size and offset
  6380. if ((offset + size) > 65535)
  6381. {
  6382. // Do not process packet larger than 64Kbytes
  6383. return;
  6384. }
  6385. if (last_packet == false && c->Size != 0)
  6386. {
  6387. if ((offset + size) > c->Size)
  6388. {
  6389. // Do not process the packet larger than the packet size
  6390. return;
  6391. }
  6392. }
  6393. if (head_ip_header_data != NULL && head_ip_header_size >= sizeof(IPV4_HEADER))
  6394. {
  6395. if (c->HeadIpHeaderData == NULL)
  6396. {
  6397. c->HeadIpHeaderData = Clone(head_ip_header_data, head_ip_header_size);
  6398. c->HeadIpHeaderDataSize = head_ip_header_size;
  6399. }
  6400. }
  6401. need_size = offset + size;
  6402. data_size_delta = c->DataReserved;
  6403. // Ensure sufficient if the buffer is insufficient
  6404. while (c->DataReserved < need_size)
  6405. {
  6406. c->DataReserved = c->DataReserved * 4;
  6407. c->Data = ReAlloc(c->Data, c->DataReserved);
  6408. }
  6409. data_size_delta = c->DataReserved - data_size_delta;
  6410. v->CurrentIpQuota += data_size_delta;
  6411. // Overwrite the data into the buffer
  6412. Copy(((UCHAR *)c->Data) + offset, data, size);
  6413. if (last_packet)
  6414. {
  6415. // If No More Flagment packet arrives, the size of this datagram is finalized
  6416. c->Size = offset + size;
  6417. }
  6418. // Check the overlap between the region which is represented by the offset and size of the
  6419. // existing received list and the region which is represented by the offset and size
  6420. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  6421. {
  6422. UINT moving_size;
  6423. IP_PART *p = LIST_DATA(c->IpParts, i);
  6424. // Check the overlapping between the existing area and head area
  6425. if ((p->Offset <= offset) && ((p->Offset + p->Size) > offset))
  6426. {
  6427. // Compress behind the offset of this packet since a duplication is
  6428. // found in the first part with the existing packet and this packet
  6429. if ((offset + size) <= (p->Offset + p->Size))
  6430. {
  6431. // This packet is buried in the existing packet
  6432. size = 0;
  6433. }
  6434. else
  6435. {
  6436. // Retral region is not overlapped
  6437. moving_size = p->Offset + p->Size - offset;
  6438. offset += moving_size;
  6439. size -= moving_size;
  6440. }
  6441. }
  6442. if ((p->Offset < (offset + size)) && ((p->Offset + p->Size) >= (offset + size)))
  6443. {
  6444. // Compress the size of this packet forward because a duplication is
  6445. // found between the posterior portion the existing packet and this packet
  6446. moving_size = p->Offset + p->Size - offset - size;
  6447. size -= moving_size;
  6448. }
  6449. if ((p->Offset >= offset) && ((p->Offset + p->Size) <= (offset + size)))
  6450. {
  6451. // This packet was overwritten to completely cover an existing packet
  6452. p->Size = 0;
  6453. }
  6454. }
  6455. if (size != 0)
  6456. {
  6457. // Register this packet
  6458. p = ZeroMalloc(sizeof(IP_PART));
  6459. p->Offset = offset;
  6460. p->Size = size;
  6461. Add(c->IpParts, p);
  6462. }
  6463. if (c->Size != 0)
  6464. {
  6465. // Get the total size of the data portion list already received
  6466. UINT total_size = 0;
  6467. UINT i;
  6468. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  6469. {
  6470. IP_PART *p = LIST_DATA(c->IpParts, i);
  6471. total_size += p->Size;
  6472. }
  6473. if (total_size == c->Size)
  6474. {
  6475. // Received all of the IP packet
  6476. IpReceived(v, c->SrcIP, c->DestIP, c->Protocol, c->Data, c->Size, c->MacBroadcast, c->Ttl,
  6477. c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->SrcIsLocalMacAddr, c->MaxL3Size);
  6478. // Release the combining object
  6479. FreeIpCombine(v, c);
  6480. // Remove from the combining object list
  6481. Delete(v->IpCombine, c);
  6482. }
  6483. }
  6484. }
  6485. // Release the IP combining object
  6486. void FreeIpCombine(VH *v, IP_COMBINE *c)
  6487. {
  6488. UINT i;
  6489. // Validate arguments
  6490. if (c == NULL)
  6491. {
  6492. return;
  6493. }
  6494. // Release the data
  6495. v->CurrentIpQuota -= c->DataReserved;
  6496. Free(c->Data);
  6497. // Release the partial list
  6498. for (i = 0;i < LIST_NUM(c->IpParts);i++)
  6499. {
  6500. IP_PART *p = LIST_DATA(c->IpParts, i);
  6501. Free(p);
  6502. }
  6503. Free(c->HeadIpHeaderData);
  6504. ReleaseList(c->IpParts);
  6505. Free(c);
  6506. }
  6507. // Search the IP combining list
  6508. IP_COMBINE *SearchIpCombine(VH *v, UINT src_ip, UINT dest_ip, USHORT id, UCHAR protocol)
  6509. {
  6510. IP_COMBINE *c, t;
  6511. // Validate arguments
  6512. if (v == NULL)
  6513. {
  6514. return NULL;
  6515. }
  6516. t.DestIP = dest_ip;
  6517. t.SrcIP = src_ip;
  6518. t.Id = id;
  6519. t.Protocol = protocol;
  6520. c = Search(v->IpCombine, &t);
  6521. return c;
  6522. }
  6523. // Insert by creating a new object to the IP combining list
  6524. IP_COMBINE *InsertIpCombine(VH *v, UINT src_ip, UINT dest_ip, USHORT id, UCHAR protocol, bool mac_broadcast, UCHAR ttl, bool src_is_localmac)
  6525. {
  6526. IP_COMBINE *c;
  6527. // Validate arguments
  6528. if (v == NULL)
  6529. {
  6530. return NULL;
  6531. }
  6532. // Examine the quota
  6533. if ((v->CurrentIpQuota + IP_COMBINE_INITIAL_BUF_SIZE) > IP_COMBINE_WAIT_QUEUE_SIZE_QUOTA)
  6534. {
  6535. // IP packet can not be stored any more
  6536. return NULL;
  6537. }
  6538. c = ZeroMalloc(sizeof(IP_COMBINE));
  6539. c->SrcIsLocalMacAddr = src_is_localmac;
  6540. c->DestIP = dest_ip;
  6541. c->SrcIP = src_ip;
  6542. c->Id = id;
  6543. c->Expire = v->Now + (UINT64)IP_COMBINE_TIMEOUT;
  6544. c->Size = 0;
  6545. c->IpParts = NewList(NULL);
  6546. c->Protocol = protocol;
  6547. c->MacBroadcast = mac_broadcast;
  6548. c->Ttl = ttl;
  6549. // Secure the memory
  6550. c->DataReserved = IP_COMBINE_INITIAL_BUF_SIZE;
  6551. c->Data = Malloc(c->DataReserved);
  6552. v->CurrentIpQuota += c->DataReserved;
  6553. Insert(v->IpCombine, c);
  6554. return c;
  6555. }
  6556. // Initialize the IP combining list
  6557. void InitIpCombineList(VH *v)
  6558. {
  6559. // Validate arguments
  6560. if (v == NULL)
  6561. {
  6562. return;
  6563. }
  6564. v->IpCombine = NewList(CompareIpCombine);
  6565. }
  6566. // Release the IP combining list
  6567. void FreeIpCombineList(VH *v)
  6568. {
  6569. UINT i;
  6570. // Validate arguments
  6571. if (v == NULL)
  6572. {
  6573. return;
  6574. }
  6575. for (i = 0;i < LIST_NUM(v->IpCombine);i++)
  6576. {
  6577. IP_COMBINE *c = LIST_DATA(v->IpCombine, i);
  6578. FreeIpCombine(v, c);
  6579. }
  6580. ReleaseList(v->IpCombine);
  6581. }
  6582. // Comparison of IP combining list entry
  6583. int CompareIpCombine(void *p1, void *p2)
  6584. {
  6585. IP_COMBINE *c1, *c2;
  6586. if (p1 == NULL || p2 == NULL)
  6587. {
  6588. return 0;
  6589. }
  6590. c1 = *(IP_COMBINE **)p1;
  6591. c2 = *(IP_COMBINE **)p2;
  6592. if (c1 == NULL || c2 == NULL)
  6593. {
  6594. return 0;
  6595. }
  6596. if (c1->Id > c2->Id)
  6597. {
  6598. return 1;
  6599. }
  6600. else if (c1->Id < c2->Id)
  6601. {
  6602. return -1;
  6603. }
  6604. else if (c1->DestIP > c2->DestIP)
  6605. {
  6606. return 1;
  6607. }
  6608. else if (c1->DestIP < c2->DestIP)
  6609. {
  6610. return -1;
  6611. }
  6612. else if (c1->SrcIP > c2->SrcIP)
  6613. {
  6614. return 1;
  6615. }
  6616. else if (c1->SrcIP < c2->SrcIP)
  6617. {
  6618. return -1;
  6619. }
  6620. else if (c1->Protocol > c2->Protocol)
  6621. {
  6622. return 1;
  6623. }
  6624. else if (c1->Protocol < c2->Protocol)
  6625. {
  6626. return -1;
  6627. }
  6628. return 0;
  6629. }
  6630. // Received an IP packet
  6631. void VirtualIpReceived(VH *v, PKT *packet)
  6632. {
  6633. IPV4_HEADER *ip;
  6634. void *data;
  6635. UINT data_size_recved;
  6636. UINT size;
  6637. UINT ipv4_header_size;
  6638. bool last_packet;
  6639. UCHAR *head_ip_header_data = NULL;
  6640. UINT head_ip_header_size = 0;
  6641. bool is_local_mac = false;
  6642. UINT ip_l3_size;
  6643. // Validate arguments
  6644. if (v == NULL || packet == NULL)
  6645. {
  6646. return;
  6647. }
  6648. ip = packet->L3.IPv4Header;
  6649. if (packet->BroadcastPacket)
  6650. {
  6651. is_local_mac = IsMacAddressLocalFast(packet->MacAddressSrc);
  6652. }
  6653. // Get the size of the IPv4 header
  6654. ipv4_header_size = IPV4_GET_HEADER_LEN(packet->L3.IPv4Header) * 4;
  6655. head_ip_header_size = ipv4_header_size;
  6656. // Calculate the checksum of the IPv4 header
  6657. if (IpCheckChecksum(ip) == false)
  6658. {
  6659. return;
  6660. }
  6661. // Get a pointer to the data
  6662. data = ((UCHAR *)packet->L3.PointerL3) + ipv4_header_size;
  6663. // Register to the ARP table
  6664. ArpIpWasKnown(v, packet->L3.IPv4Header->SrcIP, packet->MacAddressSrc);
  6665. // Get the data size
  6666. size = ip_l3_size = Endian16(ip->TotalLength);
  6667. if (size <= ipv4_header_size)
  6668. {
  6669. // There is no data
  6670. return;
  6671. }
  6672. size -= ipv4_header_size;
  6673. // Get the size of data actually received
  6674. data_size_recved = packet->PacketSize - (ipv4_header_size + MAC_HEADER_SIZE);
  6675. if (data_size_recved < size)
  6676. {
  6677. // Data insufficient (It may be missing on the way)
  6678. return;
  6679. }
  6680. if (IPV4_GET_OFFSET(ip) == 0 && (IPV4_GET_FLAGS(ip) & 0x01) == 0)
  6681. {
  6682. // Because this packet has not been fragmented, it can be delivered to the upper layer immediately
  6683. head_ip_header_data = (UCHAR *)packet->L3.IPv4Header;
  6684. IpReceived(v, ip->SrcIP, ip->DstIP, ip->Protocol, data, size, packet->BroadcastPacket, ip->TimeToLive,
  6685. head_ip_header_data, head_ip_header_size, is_local_mac, ip_l3_size);
  6686. }
  6687. else
  6688. {
  6689. // This packet is necessary to combine because it is fragmented
  6690. UINT offset = IPV4_GET_OFFSET(ip) * 8;
  6691. IP_COMBINE *c = SearchIpCombine(v, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol);
  6692. if (offset == 0)
  6693. {
  6694. head_ip_header_data = (UCHAR *)packet->L3.IPv4Header;
  6695. }
  6696. last_packet = ((IPV4_GET_FLAGS(ip) & 0x01) == 0 ? true : false);
  6697. if (c != NULL)
  6698. {
  6699. // It is the second or subsequent packet
  6700. c->MaxL3Size = MAX(c->MaxL3Size, ip_l3_size);
  6701. CombineIp(v, c, offset, data, size, last_packet, head_ip_header_data, head_ip_header_size);
  6702. }
  6703. else
  6704. {
  6705. // Create a combining object because it is the first packet
  6706. c = InsertIpCombine(
  6707. v, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket,
  6708. ip->TimeToLive, is_local_mac);
  6709. if (c != NULL)
  6710. {
  6711. c->MaxL3Size = ip_l3_size;
  6712. CombineIp(v, c, offset, data, size, last_packet, head_ip_header_data, head_ip_header_size);
  6713. }
  6714. }
  6715. }
  6716. }
  6717. // Send the waiting IP packets from the specified IP address
  6718. void SendWaitingIp(VH *v, UCHAR *mac, UINT dest_ip)
  6719. {
  6720. UINT i;
  6721. LIST *o = NULL;
  6722. // Validate arguments
  6723. if (v == NULL || mac == NULL)
  6724. {
  6725. return;
  6726. }
  6727. // Get a target list
  6728. for (i = 0;i < LIST_NUM(v->IpWaitTable);i++)
  6729. {
  6730. IP_WAIT *w = LIST_DATA(v->IpWaitTable, i);
  6731. if (w->DestIP == dest_ip)
  6732. {
  6733. if (o == NULL)
  6734. {
  6735. o = NewListFast(NULL);
  6736. }
  6737. Add(o, w);
  6738. }
  6739. }
  6740. // Send the target packets at once
  6741. if (o != NULL)
  6742. {
  6743. for (i = 0;i < LIST_NUM(o);i++)
  6744. {
  6745. IP_WAIT *w = LIST_DATA(o, i);
  6746. // Transmission processing
  6747. VirtualIpSend(v, mac, w->Data, w->Size);
  6748. // Remove from the list
  6749. Delete(v->IpWaitTable, w);
  6750. // Release the memory
  6751. Free(w->Data);
  6752. Free(w);
  6753. }
  6754. ReleaseList(o);
  6755. }
  6756. }
  6757. // Remove the old IP waiting table entries
  6758. void DeleteOldIpWaitTable(VH *v)
  6759. {
  6760. UINT i;
  6761. LIST *o = NULL;
  6762. // Validate arguments
  6763. if (v == NULL)
  6764. {
  6765. return;
  6766. }
  6767. // Get the deleting list
  6768. for (i = 0;i < LIST_NUM(v->IpWaitTable);i++)
  6769. {
  6770. IP_WAIT *w = LIST_DATA(v->IpWaitTable, i);
  6771. if (w->Expire < v->Now)
  6772. {
  6773. if (o == NULL)
  6774. {
  6775. o = NewListFast(NULL);
  6776. }
  6777. Add(o, w);
  6778. }
  6779. }
  6780. // Delete all at once
  6781. if (o != NULL)
  6782. {
  6783. for (i = 0;i < LIST_NUM(o);i++)
  6784. {
  6785. IP_WAIT *w = LIST_DATA(o, i);
  6786. // Remove from the list
  6787. Delete(v->IpWaitTable, w);
  6788. // Release the memory
  6789. Free(w->Data);
  6790. Free(w);
  6791. }
  6792. ReleaseList(o);
  6793. }
  6794. }
  6795. // Poll the IP waiting table
  6796. void PollingIpWaitTable(VH *v)
  6797. {
  6798. // Delete the old table entries
  6799. DeleteOldIpWaitTable(v);
  6800. }
  6801. // Insert the IP packet to the IP waiting table
  6802. void InsertIpWaitTable(VH *v, UINT dest_ip, UINT src_ip, void *data, UINT size)
  6803. {
  6804. IP_WAIT *w;
  6805. // Validate arguments
  6806. if (v == NULL || data == NULL || size == 0)
  6807. {
  6808. return;
  6809. }
  6810. w = ZeroMalloc(sizeof(IP_WAIT));
  6811. w->Data = data;
  6812. w->Size = size;
  6813. w->SrcIP = src_ip;
  6814. w->DestIP = dest_ip;
  6815. w->Expire = v->Now + (UINT64)IP_WAIT_FOR_ARP_TIMEOUT;
  6816. Add(v->IpWaitTable, w);
  6817. }
  6818. // Initialize the IP waiting table
  6819. void InitIpWaitTable(VH *v)
  6820. {
  6821. // Validate arguments
  6822. if (v == NULL)
  6823. {
  6824. return;
  6825. }
  6826. v->IpWaitTable = NewList(NULL);
  6827. }
  6828. // Release the IP waiting table
  6829. void FreeIpWaitTable(VH *v)
  6830. {
  6831. UINT i;
  6832. // Validate arguments
  6833. if (v == NULL)
  6834. {
  6835. return;
  6836. }
  6837. for (i = 0;i < LIST_NUM(v->IpWaitTable);i++)
  6838. {
  6839. IP_WAIT *w = LIST_DATA(v->IpWaitTable, i);
  6840. Free(w->Data);
  6841. Free(w);
  6842. }
  6843. ReleaseList(v->IpWaitTable);
  6844. }
  6845. // MAC address for the IP address is found because something such as an ARP Response arrives
  6846. void ArpIpWasKnown(VH *v, UINT ip, UCHAR *mac)
  6847. {
  6848. // Validate arguments
  6849. if (v == NULL || mac == NULL)
  6850. {
  6851. return;
  6852. }
  6853. // If there is a query for this IP address in the ARP queue, delete it
  6854. DeleteArpWaitTable(v, ip);
  6855. // Update or register in the ARP table
  6856. InsertArpTable(v, mac, ip);
  6857. // Send the IP packets waiting in the IP waiting list
  6858. SendWaitingIp(v, mac, ip);
  6859. }
  6860. // Re-issue ARPs by checking the ARP waiting list
  6861. void PollingArpWaitTable(VH *v)
  6862. {
  6863. UINT i;
  6864. LIST *o;
  6865. // Validate arguments
  6866. if (v == NULL)
  6867. {
  6868. return;
  6869. }
  6870. // Initialize the deletion list
  6871. o = NULL;
  6872. // Scan whole ARP waiting list
  6873. for (i = 0;i < LIST_NUM(v->ArpWaitTable);i++)
  6874. {
  6875. ARP_WAIT *w = LIST_DATA(v->ArpWaitTable, i);
  6876. if (w->GiveupTime < v->Now || (w->GiveupTime - 100 * 1000) > v->Now)
  6877. {
  6878. // Give up the sending of ARP
  6879. if (o == NULL)
  6880. {
  6881. o = NewListFast(NULL);
  6882. }
  6883. Add(o, w);
  6884. }
  6885. else
  6886. {
  6887. if (w->TimeoutTime < v->Now)
  6888. {
  6889. // Send an ARP again
  6890. VirtualArpSendRequest(v, w->IpAddress);
  6891. // Set the next timeout time
  6892. w->TimeoutTime = v->Now + (UINT64)w->NextTimeoutTimeValue;
  6893. // Increase the ARP transmission interval of the second and subsequent
  6894. w->NextTimeoutTimeValue = w->NextTimeoutTimeValue + ARP_REQUEST_TIMEOUT;
  6895. }
  6896. }
  6897. }
  6898. // Remove if there is a ARP waiting record to be deleted
  6899. if (o != NULL)
  6900. {
  6901. for (i = 0;i < LIST_NUM(o);i++)
  6902. {
  6903. ARP_WAIT *w = LIST_DATA(o, i);
  6904. DeleteArpWaitTable(v, w->IpAddress);
  6905. }
  6906. ReleaseList(o);
  6907. }
  6908. }
  6909. // Issue an ARP
  6910. void SendArp(VH *v, UINT ip)
  6911. {
  6912. ARP_WAIT *w;
  6913. // Validate arguments
  6914. if (v == NULL)
  6915. {
  6916. return;
  6917. }
  6918. // Examine whether the destination IP address has been registered in the ARP waiting list first
  6919. w = SearchArpWaitTable(v, ip);
  6920. if (w != NULL)
  6921. {
  6922. // Do not do anything because it is already registered
  6923. return;
  6924. }
  6925. // Send an ARP packet first
  6926. VirtualArpSendRequest(v, ip);
  6927. // Register in the ARP waiting list
  6928. w = ZeroMalloc(sizeof(ARP_WAIT));
  6929. w->GiveupTime = v->Now + (UINT64)ARP_REQUEST_GIVEUP;
  6930. w->TimeoutTime = v->Now + (UINT64)ARP_REQUEST_TIMEOUT;
  6931. w->NextTimeoutTimeValue = ARP_REQUEST_TIMEOUT;
  6932. w->IpAddress = ip;
  6933. InsertArpWaitTable(v, w);
  6934. }
  6935. // Delete the ARP waiting table
  6936. void DeleteArpWaitTable(VH *v, UINT ip)
  6937. {
  6938. ARP_WAIT *w;
  6939. // Validate arguments
  6940. if (v == NULL)
  6941. {
  6942. return;
  6943. }
  6944. w = SearchArpWaitTable(v, ip);
  6945. if (w == NULL)
  6946. {
  6947. return;
  6948. }
  6949. Delete(v->ArpWaitTable, w);
  6950. Free(w);
  6951. }
  6952. // Search the ARP waiting table
  6953. ARP_WAIT *SearchArpWaitTable(VH *v, UINT ip)
  6954. {
  6955. ARP_WAIT *w, t;
  6956. // Validate arguments
  6957. if (v == NULL)
  6958. {
  6959. return NULL;
  6960. }
  6961. t.IpAddress = ip;
  6962. w = Search(v->ArpWaitTable, &t);
  6963. return w;
  6964. }
  6965. // Register in the ARP waiting table
  6966. void InsertArpWaitTable(VH *v, ARP_WAIT *w)
  6967. {
  6968. // Validate arguments
  6969. if (v == NULL || w == NULL)
  6970. {
  6971. return;
  6972. }
  6973. Add(v->ArpWaitTable, w);
  6974. }
  6975. // Initialize the ARP waiting table
  6976. void InitArpWaitTable(VH *v)
  6977. {
  6978. // Validate arguments
  6979. if (v == NULL)
  6980. {
  6981. return;
  6982. }
  6983. v->ArpWaitTable = NewList(CompareArpWaitTable);
  6984. }
  6985. // Release the ARP waiting table
  6986. void FreeArpWaitTable(VH *v)
  6987. {
  6988. UINT i;
  6989. // Validate arguments
  6990. if (v == NULL)
  6991. {
  6992. return;
  6993. }
  6994. for (i = 0;i < LIST_NUM(v->ArpWaitTable);i++)
  6995. {
  6996. ARP_WAIT *w = LIST_DATA(v->ArpWaitTable, i);
  6997. Free(w);
  6998. }
  6999. ReleaseList(v->ArpWaitTable);
  7000. }
  7001. // Check whether the MAC address is valid
  7002. bool IsMacInvalid(UCHAR *mac)
  7003. {
  7004. UINT i;
  7005. // Validate arguments
  7006. if (mac == NULL)
  7007. {
  7008. return false;
  7009. }
  7010. for (i = 0;i < 6;i++)
  7011. {
  7012. if (mac[i] != 0x00)
  7013. {
  7014. return false;
  7015. }
  7016. }
  7017. return true;
  7018. }
  7019. // Check whether the MAC address is a broadcast address
  7020. bool IsMacBroadcast(UCHAR *mac)
  7021. {
  7022. UINT i;
  7023. // Validate arguments
  7024. if (mac == NULL)
  7025. {
  7026. return false;
  7027. }
  7028. for (i = 0;i < 6;i++)
  7029. {
  7030. if (mac[i] != 0xff)
  7031. {
  7032. return false;
  7033. }
  7034. }
  7035. return true;
  7036. }
  7037. // Insert an entry in the ARP table
  7038. void InsertArpTable(VH *v, UCHAR *mac, UINT ip)
  7039. {
  7040. ARP_ENTRY *e, t;
  7041. // Validate arguments
  7042. if (v == NULL || mac == NULL || ip == 0 || ip == 0xffffffff || IsMacBroadcast(mac) || IsMacInvalid(mac))
  7043. {
  7044. return;
  7045. }
  7046. // Check whether the same IP address is not already registered
  7047. t.IpAddress = ip;
  7048. e = Search(v->ArpTable, &t);
  7049. if (e != NULL)
  7050. {
  7051. // Override this simply because it was registered
  7052. if (Cmp(e->MacAddress, mac, 6) != 0)
  7053. {
  7054. e->Created = v->Now;
  7055. Copy(e->MacAddress, mac, 6);
  7056. }
  7057. e->Expire = v->Now + (UINT64)ARP_ENTRY_EXPIRES;
  7058. }
  7059. else
  7060. {
  7061. // Create a new entry
  7062. e = ZeroMalloc(sizeof(ARP_ENTRY));
  7063. e->Created = v->Now;
  7064. e->Expire = v->Now + (UINT64)ARP_ENTRY_EXPIRES;
  7065. Copy(e->MacAddress, mac, 6);
  7066. e->IpAddress = ip;
  7067. Add(v->ArpTable, e);
  7068. }
  7069. }
  7070. // Poll the ARP table
  7071. void PollingArpTable(VH *v)
  7072. {
  7073. // Validate arguments
  7074. if (v == NULL)
  7075. {
  7076. return;
  7077. }
  7078. if (v->Now > v->NextArpTablePolling)
  7079. {
  7080. v->NextArpTablePolling = v->Now + (UINT64)ARP_ENTRY_POLLING_TIME;
  7081. RefreshArpTable(v);
  7082. }
  7083. }
  7084. // Remove the old ARP entries
  7085. void RefreshArpTable(VH *v)
  7086. {
  7087. UINT i;
  7088. LIST *o;
  7089. // Validate arguments
  7090. if (v == NULL)
  7091. {
  7092. return;
  7093. }
  7094. o = NewListFast(NULL);
  7095. for (i = 0;i < LIST_NUM(v->ArpTable);i++)
  7096. {
  7097. ARP_ENTRY *e = LIST_DATA(v->ArpTable, i);
  7098. // Check for expired
  7099. if (e->Expire < v->Now)
  7100. {
  7101. // Expired
  7102. Add(o, e);
  7103. }
  7104. }
  7105. // Remove expired entries at once
  7106. for (i = 0;i < LIST_NUM(o);i++)
  7107. {
  7108. ARP_ENTRY *e = LIST_DATA(o, i);
  7109. Delete(v->ArpTable, e);
  7110. Free(e);
  7111. }
  7112. ReleaseList(o);
  7113. }
  7114. // Search the ARP table
  7115. ARP_ENTRY *SearchArpTable(VH *v, UINT ip)
  7116. {
  7117. ARP_ENTRY *e, t;
  7118. // Validate arguments
  7119. if (v == NULL)
  7120. {
  7121. return NULL;
  7122. }
  7123. t.IpAddress = ip;
  7124. e = Search(v->ArpTable, &t);
  7125. return e;
  7126. }
  7127. // Initialize the ARP table
  7128. void InitArpTable(VH *v)
  7129. {
  7130. // Validate arguments
  7131. if (v == NULL)
  7132. {
  7133. return;
  7134. }
  7135. v->ArpTable = NewList(CompareArpTable);
  7136. }
  7137. // Release the ARP table
  7138. void FreeArpTable(VH *v)
  7139. {
  7140. UINT i;
  7141. // Validate arguments
  7142. if (v == NULL)
  7143. {
  7144. return;
  7145. }
  7146. // Delete all entries
  7147. for (i = 0;i < LIST_NUM(v->ArpTable);i++)
  7148. {
  7149. ARP_ENTRY *e = LIST_DATA(v->ArpTable, i);
  7150. Free(e);
  7151. }
  7152. ReleaseList(v->ArpTable);
  7153. }
  7154. // Comparison of the ARP waiting table entry
  7155. int CompareArpWaitTable(void *p1, void *p2)
  7156. {
  7157. ARP_WAIT *e1, *e2;
  7158. if (p1 == NULL || p2 == NULL)
  7159. {
  7160. return 0;
  7161. }
  7162. e1 = *(ARP_WAIT **)p1;
  7163. e2 = *(ARP_WAIT **)p2;
  7164. if (e1 == NULL || e2 == NULL)
  7165. {
  7166. return 0;
  7167. }
  7168. if (e1->IpAddress > e2->IpAddress)
  7169. {
  7170. return 1;
  7171. }
  7172. else if (e1->IpAddress < e2->IpAddress)
  7173. {
  7174. return -1;
  7175. }
  7176. return 0;
  7177. }
  7178. // Comparison of the ARP table entry
  7179. int CompareArpTable(void *p1, void *p2)
  7180. {
  7181. ARP_ENTRY *e1, *e2;
  7182. if (p1 == NULL || p2 == NULL)
  7183. {
  7184. return 0;
  7185. }
  7186. e1 = *(ARP_ENTRY **)p1;
  7187. e2 = *(ARP_ENTRY **)p2;
  7188. if (e1 == NULL || e2 == NULL)
  7189. {
  7190. return 0;
  7191. }
  7192. if (e1->IpAddress > e2->IpAddress)
  7193. {
  7194. return 1;
  7195. }
  7196. else if (e1->IpAddress < e2->IpAddress)
  7197. {
  7198. return -1;
  7199. }
  7200. return 0;
  7201. }
  7202. // Initialize the virtual host
  7203. bool VirtualInit(VH *v)
  7204. {
  7205. // Initialize the log
  7206. v->Logger = NULL;
  7207. LockVirtual(v);
  7208. {
  7209. // Initialize
  7210. v->Cancel = NewCancel();
  7211. v->SendQueue = NewQueue();
  7212. }
  7213. UnlockVirtual(v);
  7214. // Counter reset
  7215. v->Counter->c = 0;
  7216. v->DhcpId = 0;
  7217. // Initialize the ARP table
  7218. InitArpTable(v);
  7219. // Initialize the ARP waiting table
  7220. InitArpWaitTable(v);
  7221. // Initialize the IP waiting table
  7222. InitIpWaitTable(v);
  7223. // Initialize the IP combining list
  7224. InitIpCombineList(v);
  7225. // Initialize the NAT
  7226. InitNat(v);
  7227. // Initialize the DHCP server
  7228. InitDhcpServer(v);
  7229. // Other initialization
  7230. v->flag1 = false;
  7231. v->NextArpTablePolling = Tick64() + (UINT64)ARP_ENTRY_POLLING_TIME;
  7232. v->CurrentIpQuota = 0;
  7233. v->Active = true;
  7234. return true;
  7235. }
  7236. bool VirtualPaInit(SESSION *s)
  7237. {
  7238. VH *v;
  7239. // Validate arguments
  7240. if (s == NULL || (v = (VH *)s->PacketAdapter->Param) == NULL)
  7241. {
  7242. return false;
  7243. }
  7244. return VirtualInit(v);
  7245. }
  7246. // Get the cancel object of the virtual host
  7247. CANCEL *VirtualPaGetCancel(SESSION *s)
  7248. {
  7249. VH *v;
  7250. // Validate arguments
  7251. if (s == NULL || (v = (VH *)s->PacketAdapter->Param) == NULL)
  7252. {
  7253. return NULL;
  7254. }
  7255. AddRef(v->Cancel->ref);
  7256. return v->Cancel;
  7257. }
  7258. // Get the next packet from the virtual host
  7259. UINT VirtualGetNextPacket(VH *v, void **data)
  7260. {
  7261. UINT ret = 0;
  7262. START:
  7263. // Examine the transmission queue
  7264. LockQueue(v->SendQueue);
  7265. {
  7266. BLOCK *block = GetNext(v->SendQueue);
  7267. if (block != NULL)
  7268. {
  7269. // There is a packet
  7270. ret = block->Size;
  7271. *data = block->Buf;
  7272. // Discard the structure
  7273. Free(block);
  7274. }
  7275. }
  7276. UnlockQueue(v->SendQueue);
  7277. if (ret == 0)
  7278. {
  7279. LockVirtual(v);
  7280. {
  7281. v->Now = Tick64();
  7282. // Polling process
  7283. VirtualPolling(v);
  7284. }
  7285. UnlockVirtual(v);
  7286. if (v->SendQueue->num_item != 0)
  7287. {
  7288. goto START;
  7289. }
  7290. }
  7291. return ret;
  7292. }
  7293. UINT VirtualPaGetNextPacket(SESSION *s, void **data)
  7294. {
  7295. VH *v;
  7296. // Validate arguments
  7297. if (s == NULL || (v = (VH *)s->PacketAdapter->Param) == NULL)
  7298. {
  7299. return INFINITE;
  7300. }
  7301. return VirtualGetNextPacket(v, data);
  7302. }
  7303. // Polling process (Always called once in a SessionMain loop)
  7304. void VirtualPolling(VH *v)
  7305. {
  7306. // Validate arguments
  7307. if (v == NULL)
  7308. {
  7309. return;
  7310. }
  7311. // DHCP polling
  7312. PollingDhcpServer(v);
  7313. // NAT polling
  7314. PoolingNat(v);
  7315. // Clear the old ARP table entries
  7316. PollingArpTable(v);
  7317. // Poll the ARP waiting list
  7318. PollingArpWaitTable(v);
  7319. // Poll the IP waiting list
  7320. PollingIpWaitTable(v);
  7321. // Poll the IP combining list
  7322. PollingIpCombine(v);
  7323. // Beacon transmission procedure
  7324. PollingBeacon(v);
  7325. }
  7326. // Beacon transmission procedure
  7327. void PollingBeacon(VH *v)
  7328. {
  7329. // Validate arguments
  7330. if (v == NULL)
  7331. {
  7332. return;
  7333. }
  7334. if (v->LastSendBeacon == 0 ||
  7335. ((v->LastSendBeacon + BEACON_SEND_INTERVAL) <= Tick64()))
  7336. {
  7337. v->LastSendBeacon = Tick64();
  7338. SendBeacon(v);
  7339. }
  7340. }
  7341. // Send a Layer-2 packet
  7342. void VirtualLayer2Send(VH *v, UCHAR *dest_mac, UCHAR *src_mac, USHORT protocol, void *data, UINT size)
  7343. {
  7344. MAC_HEADER *mac_header;
  7345. UCHAR *buf;
  7346. BLOCK *block;
  7347. // Validate arguments
  7348. if (v == NULL || dest_mac == NULL || src_mac == NULL || data == NULL || size > (MAX_PACKET_SIZE - sizeof(MAC_HEADER)))
  7349. {
  7350. return;
  7351. }
  7352. // Create buffer
  7353. buf = Malloc(MAC_HEADER_SIZE + size);
  7354. // MAC header
  7355. mac_header = (MAC_HEADER *)&buf[0];
  7356. Copy(mac_header->DestAddress, dest_mac, 6);
  7357. Copy(mac_header->SrcAddress, src_mac, 6);
  7358. mac_header->Protocol = Endian16(protocol);
  7359. // Copy data
  7360. Copy(&buf[sizeof(MAC_HEADER)], data, size);
  7361. // Size
  7362. size += sizeof(MAC_HEADER);
  7363. // Generate the packet
  7364. block = NewBlock(buf, size, 0);
  7365. // Insert into the queue
  7366. LockQueue(v->SendQueue);
  7367. {
  7368. InsertQueue(v->SendQueue, block);
  7369. }
  7370. UnlockQueue(v->SendQueue);
  7371. // Cancel
  7372. Cancel(v->Cancel);
  7373. }
  7374. // Send an IP packet (with automatic fragmentation)
  7375. void SendIp(VH *v, UINT dest_ip, UINT src_ip, UCHAR protocol, void *data, UINT size)
  7376. {
  7377. SendIpEx(v, dest_ip, src_ip, protocol, data, size, 0);
  7378. }
  7379. void SendIpEx(VH *v, UINT dest_ip, UINT src_ip, UCHAR protocol, void *data, UINT size, UCHAR ttl)
  7380. {
  7381. UINT mss;
  7382. UCHAR *buf;
  7383. USHORT offset;
  7384. USHORT id;
  7385. USHORT total_size;
  7386. UINT size_of_this_packet;
  7387. // Validate arguments
  7388. if (v == NULL || data == NULL || size == 0 || size > MAX_IP_DATA_SIZE_TOTAL)
  7389. {
  7390. return;
  7391. }
  7392. // Maximum segment size
  7393. mss = v->IpMss;
  7394. // Buffer
  7395. buf = (UCHAR *)data;
  7396. // ID
  7397. id = (v->NextId++);
  7398. // Total size
  7399. total_size = (USHORT)size;
  7400. // Start to split
  7401. offset = 0;
  7402. while (true)
  7403. {
  7404. bool last_packet = false;
  7405. // Gets the size of this packet
  7406. size_of_this_packet = MIN((USHORT)mss, (total_size - offset));
  7407. if ((offset + (USHORT)size_of_this_packet) == total_size)
  7408. {
  7409. last_packet = true;
  7410. }
  7411. // Transmit the fragmented packet
  7412. SendFragmentedIp(v, dest_ip, src_ip, id,
  7413. total_size, offset, protocol, buf + offset, size_of_this_packet, NULL, ttl);
  7414. if (last_packet)
  7415. {
  7416. break;
  7417. }
  7418. offset += (USHORT)size_of_this_packet;
  7419. }
  7420. }
  7421. // Reserve to send the fragmented IP packet
  7422. void SendFragmentedIp(VH *v, UINT dest_ip, UINT src_ip, USHORT id, USHORT total_size, USHORT offset, UCHAR protocol, void *data, UINT size, UCHAR *dest_mac, UCHAR ttl)
  7423. {
  7424. UCHAR *buf;
  7425. IPV4_HEADER *ip;
  7426. ARP_ENTRY *arp;
  7427. // Validate arguments
  7428. if (v == NULL || data == NULL || size == 0)
  7429. {
  7430. return;
  7431. }
  7432. // Memory allocation
  7433. buf = Malloc(size + IP_HEADER_SIZE);
  7434. ip = (IPV4_HEADER *)&buf[0];
  7435. // IP header construction
  7436. ip->VersionAndHeaderLength = 0;
  7437. IPV4_SET_VERSION(ip, 4);
  7438. IPV4_SET_HEADER_LEN(ip, (IP_HEADER_SIZE / 4));
  7439. ip->TypeOfService = DEFAULT_IP_TOS;
  7440. ip->TotalLength = Endian16((USHORT)(size + IP_HEADER_SIZE));
  7441. ip->Identification = Endian16(id);
  7442. ip->FlagsAndFlagmentOffset[0] = ip->FlagsAndFlagmentOffset[1] = 0;
  7443. IPV4_SET_OFFSET(ip, (offset / 8));
  7444. if ((offset + size) >= total_size)
  7445. {
  7446. IPV4_SET_FLAGS(ip, 0x00);
  7447. }
  7448. else
  7449. {
  7450. IPV4_SET_FLAGS(ip, 0x01);
  7451. }
  7452. ip->TimeToLive = (ttl == 0 ? DEFAULT_IP_TTL : ttl);
  7453. ip->Protocol = protocol;
  7454. ip->Checksum = 0;
  7455. ip->SrcIP = src_ip;
  7456. ip->DstIP = dest_ip;
  7457. // Checksum calculation
  7458. ip->Checksum = IpChecksum(ip, IP_HEADER_SIZE);
  7459. // Data copy
  7460. Copy(buf + IP_HEADER_SIZE, data, size);
  7461. if (dest_mac == NULL)
  7462. {
  7463. if (ip->DstIP == 0xffffffff ||
  7464. (IsInNetwork(ip->DstIP, v->HostIP, v->HostMask) && (ip->DstIP & (~v->HostMask)) == (~v->HostMask)))
  7465. {
  7466. // Broadcast address
  7467. dest_mac = broadcast;
  7468. }
  7469. else
  7470. {
  7471. // Send an ARP query if the destination MAC address is unknown
  7472. arp = SearchArpTable(v, dest_ip);
  7473. if (arp != NULL)
  7474. {
  7475. dest_mac = arp->MacAddress;
  7476. }
  7477. }
  7478. }
  7479. if (dest_mac != NULL)
  7480. {
  7481. // Send the packet immediately
  7482. VirtualIpSend(v, dest_mac, buf, size + IP_HEADER_SIZE);
  7483. // Packet data may be released
  7484. Free(buf);
  7485. }
  7486. else
  7487. {
  7488. // Because this packet still can not be transferred, add it to the IP waiting table
  7489. InsertIpWaitTable(v, dest_ip, src_ip, buf, size + IP_HEADER_SIZE);
  7490. // Issue an ARP
  7491. SendArp(v, dest_ip);
  7492. }
  7493. }
  7494. // Send an IP packet (fragmented)
  7495. void VirtualIpSend(VH *v, UCHAR *dest_mac, void *data, UINT size)
  7496. {
  7497. // Validate arguments
  7498. if (v == NULL || dest_mac == NULL || data == NULL || size == 0)
  7499. {
  7500. return;
  7501. }
  7502. // Transmission
  7503. VirtualLayer2Send(v, dest_mac, v->MacAddress, MAC_PROTO_IPV4, data, size);
  7504. }
  7505. // Send an ARP request packet
  7506. void VirtualArpSendRequest(VH *v, UINT dest_ip)
  7507. {
  7508. ARPV4_HEADER arp;
  7509. // Validate arguments
  7510. if (v == NULL)
  7511. {
  7512. return;
  7513. }
  7514. // Build the ARP header
  7515. arp.HardwareType = Endian16(ARP_HARDWARE_TYPE_ETHERNET);
  7516. arp.ProtocolType = Endian16(MAC_PROTO_IPV4);
  7517. arp.HardwareSize = 6;
  7518. arp.ProtocolSize = 4;
  7519. arp.Operation = Endian16(ARP_OPERATION_REQUEST);
  7520. Copy(arp.SrcAddress, v->MacAddress, 6);
  7521. arp.SrcIP = v->HostIP;
  7522. Zero(&arp.TargetAddress, 6);
  7523. arp.TargetIP = dest_ip;
  7524. // Transmission
  7525. VirtualLayer2Send(v, broadcast, v->MacAddress, MAC_PROTO_ARPV4, &arp, sizeof(arp));
  7526. }
  7527. // Send an ARP response packet
  7528. void VirtualArpSendResponse(VH *v, UCHAR *dest_mac, UINT dest_ip, UINT src_ip)
  7529. {
  7530. ARPV4_HEADER arp;
  7531. // Validate arguments
  7532. if (v == NULL || dest_mac == NULL)
  7533. {
  7534. return;
  7535. }
  7536. // Build the ARP header
  7537. arp.HardwareType = Endian16(ARP_HARDWARE_TYPE_ETHERNET);
  7538. arp.ProtocolType = Endian16(MAC_PROTO_IPV4);
  7539. arp.HardwareSize = 6;
  7540. arp.ProtocolSize = 4;
  7541. arp.Operation = Endian16(ARP_OPERATION_RESPONSE);
  7542. Copy(arp.SrcAddress, v->MacAddress, 6);
  7543. Copy(arp.TargetAddress, dest_mac, 6);
  7544. arp.SrcIP = src_ip;
  7545. arp.TargetIP = dest_ip;
  7546. // Transmission
  7547. VirtualLayer2Send(v, dest_mac, v->MacAddress, MAC_PROTO_ARPV4, &arp, sizeof(ARPV4_HEADER));
  7548. }
  7549. // An ARP request packet was received
  7550. void VirtualArpResponseRequest(VH *v, PKT *packet)
  7551. {
  7552. ARPV4_HEADER *arp;
  7553. // Validate arguments
  7554. if (v == NULL || packet == NULL)
  7555. {
  7556. return;
  7557. }
  7558. arp = packet->L3.ARPv4Header;
  7559. // Memory the information of the host IP address and the MAC address of the other party
  7560. ArpIpWasKnown(v, arp->SrcIP, arp->SrcAddress);
  7561. // Search whether it matches with the IP address of this host
  7562. if (v->HostIP == arp->TargetIP)
  7563. {
  7564. // Respond since the match
  7565. VirtualArpSendResponse(v, arp->SrcAddress, arp->SrcIP, v->HostIP);
  7566. return;
  7567. }
  7568. // Do nothing if it doesn't match
  7569. }
  7570. // An ARP response packet is received
  7571. void VirtualArpResponseReceived(VH *v, PKT *packet)
  7572. {
  7573. ARPV4_HEADER *arp;
  7574. // Validate arguments
  7575. if (v == NULL || packet == NULL)
  7576. {
  7577. return;
  7578. }
  7579. arp = packet->L3.ARPv4Header;
  7580. // Regard this information as known information
  7581. ArpIpWasKnown(v, arp->SrcIP, arp->SrcAddress);
  7582. }
  7583. // Received an ARP packet
  7584. void VirtualArpReceived(VH *v, PKT *packet)
  7585. {
  7586. ARPV4_HEADER *arp;
  7587. // Validate arguments
  7588. if (v == NULL || packet == NULL)
  7589. {
  7590. return;
  7591. }
  7592. arp = packet->L3.ARPv4Header;
  7593. if (Endian16(arp->HardwareType) != ARP_HARDWARE_TYPE_ETHERNET)
  7594. {
  7595. // Ignore if hardware type is other than Ethernet
  7596. return;
  7597. }
  7598. if (Endian16(arp->ProtocolType) != MAC_PROTO_IPV4)
  7599. {
  7600. // Ignore if the protocol type is a non-IPv4
  7601. return;
  7602. }
  7603. if (arp->HardwareSize != 6 || arp->ProtocolSize != 4)
  7604. {
  7605. // Ignore because the size of protocol address or hardware address is invalid
  7606. return;
  7607. }
  7608. // Check the source MAC address
  7609. if (Cmp(arp->SrcAddress, packet->MacAddressSrc, 6) != 0)
  7610. {
  7611. // MAC address in the MAC header and the MAC address of the ARP packet are different
  7612. return;
  7613. }
  7614. switch (Endian16(arp->Operation))
  7615. {
  7616. case ARP_OPERATION_REQUEST: // ARP request
  7617. VirtualArpResponseRequest(v, packet);
  7618. break;
  7619. case ARP_OPERATION_RESPONSE: // ARP response
  7620. VirtualArpResponseReceived(v, packet);
  7621. break;
  7622. }
  7623. }
  7624. // Release the DHCP server
  7625. void FreeDhcpServer(VH *v)
  7626. {
  7627. UINT i;
  7628. // Validate arguments
  7629. if (v == NULL)
  7630. {
  7631. return;
  7632. }
  7633. // Remove the all lease entries
  7634. for (i = 0;i < LIST_NUM(v->DhcpLeaseList);i++)
  7635. {
  7636. DHCP_LEASE *d = LIST_DATA(v->DhcpLeaseList, i);
  7637. FreeDhcpLease(d);
  7638. }
  7639. ReleaseList(v->DhcpLeaseList);
  7640. v->DhcpLeaseList = NULL;
  7641. }
  7642. // Initialize the DHCP server
  7643. void InitDhcpServer(VH *v)
  7644. {
  7645. // Validate arguments
  7646. if (v == NULL)
  7647. {
  7648. return;
  7649. }
  7650. // Create a list
  7651. v->DhcpLeaseList = NewList(CompareDhcpLeaseList);
  7652. }
  7653. // Search for a DHCP lease item by the IP address
  7654. DHCP_LEASE *SearchDhcpLeaseByIp(VH *v, UINT ip)
  7655. {
  7656. UINT i;
  7657. // Validate arguments
  7658. if (v == NULL)
  7659. {
  7660. return NULL;
  7661. }
  7662. for (i = 0;i < LIST_NUM(v->DhcpLeaseList);i++)
  7663. {
  7664. DHCP_LEASE *d = LIST_DATA(v->DhcpLeaseList, i);
  7665. if (d->IpAddress == ip)
  7666. {
  7667. return d;
  7668. }
  7669. }
  7670. return NULL;
  7671. }
  7672. // Search for a DHCP lease item by the MAC address
  7673. DHCP_LEASE *SearchDhcpLeaseByMac(VH *v, UCHAR *mac)
  7674. {
  7675. DHCP_LEASE *d, t;
  7676. // Validate arguments
  7677. if (v == NULL || mac == NULL)
  7678. {
  7679. return NULL;
  7680. }
  7681. Copy(&t.MacAddress, mac, 6);
  7682. d = Search(v->DhcpLeaseList, &t);
  7683. return d;
  7684. }
  7685. // Release the DHCP lease item
  7686. void FreeDhcpLease(DHCP_LEASE *d)
  7687. {
  7688. // Validate arguments
  7689. if (d == NULL)
  7690. {
  7691. return;
  7692. }
  7693. Free(d->Hostname);
  7694. Free(d);
  7695. }
  7696. // Create a DHCP lease item
  7697. DHCP_LEASE *NewDhcpLease(UINT expire, UCHAR *mac_address, UINT ip, UINT mask, char *hostname)
  7698. {
  7699. DHCP_LEASE *d;
  7700. // Validate arguments
  7701. if (mac_address == NULL || hostname == NULL)
  7702. {
  7703. return NULL;
  7704. }
  7705. d = ZeroMalloc(sizeof(DHCP_LEASE));
  7706. d->LeasedTime = (UINT64)Tick64();
  7707. if (expire == INFINITE)
  7708. {
  7709. d->ExpireTime = INFINITE;
  7710. }
  7711. else
  7712. {
  7713. d->ExpireTime = d->LeasedTime + (UINT64)expire;
  7714. }
  7715. d->IpAddress = ip;
  7716. d->Mask = mask;
  7717. d->Hostname = CopyStr(hostname);
  7718. Copy(d->MacAddress, mac_address, 6);
  7719. return d;
  7720. }
  7721. // Comparison of the items in the DHCP list
  7722. int CompareDhcpLeaseList(void *p1, void *p2)
  7723. {
  7724. DHCP_LEASE *d1, *d2;
  7725. // Validate arguments
  7726. if (p1 == NULL || p2 == NULL)
  7727. {
  7728. return 0;
  7729. }
  7730. d1 = *(DHCP_LEASE **)p1;
  7731. d2 = *(DHCP_LEASE **)p2;
  7732. if (d1 == NULL || d2 == NULL)
  7733. {
  7734. return 0;
  7735. }
  7736. return Cmp(d1->MacAddress, d2->MacAddress, 6);
  7737. }
  7738. // Poll the DHCP server
  7739. void PollingDhcpServer(VH *v)
  7740. {
  7741. UINT i;
  7742. // Validate arguments
  7743. if (v == NULL)
  7744. {
  7745. return;
  7746. }
  7747. if (v->LastDhcpPolling != 0)
  7748. {
  7749. if ((v->LastDhcpPolling + (UINT64)DHCP_POLLING_INTERVAL) > v->Now &&
  7750. v->LastDhcpPolling < v->Now)
  7751. {
  7752. return;
  7753. }
  7754. }
  7755. v->LastDhcpPolling = v->Now;
  7756. // Remove expired entries
  7757. FIRST_LIST:
  7758. for (i = 0;i < LIST_NUM(v->DhcpLeaseList);i++)
  7759. {
  7760. DHCP_LEASE *d = LIST_DATA(v->DhcpLeaseList, i);
  7761. if (d->ExpireTime < v->Now)
  7762. {
  7763. FreeDhcpLease(d);
  7764. Delete(v->DhcpLeaseList, d);
  7765. goto FIRST_LIST;
  7766. }
  7767. }
  7768. }
  7769. // Correspond to the DHCP REQUEST
  7770. UINT ServeDhcpRequest(VH *v, UCHAR *mac, UINT request_ip)
  7771. {
  7772. UINT ret;
  7773. // Validate arguments
  7774. if (v == NULL || mac == NULL)
  7775. {
  7776. return 0;
  7777. }
  7778. ret = ServeDhcpDiscover(v, mac, request_ip);
  7779. if (ret != request_ip)
  7780. {
  7781. if (request_ip != 0)
  7782. {
  7783. // Raise an error if the requested IP address cannot to be assigned
  7784. return 0;
  7785. }
  7786. }
  7787. return ret;
  7788. }
  7789. // Correspond to the DHCP DISCOVER
  7790. UINT ServeDhcpDiscover(VH *v, UCHAR *mac, UINT request_ip)
  7791. {
  7792. UINT ret = 0;
  7793. // Validate arguments
  7794. if (v == NULL || mac == NULL)
  7795. {
  7796. return 0;
  7797. }
  7798. if (request_ip != 0)
  7799. {
  7800. // IP address is specified
  7801. DHCP_LEASE *d = SearchDhcpLeaseByIp(v, request_ip);
  7802. if (d != NULL)
  7803. {
  7804. // If an entry for the same IP address already exists,
  7805. // check whether it is a request from the same MAC address
  7806. if (Cmp(mac, d->MacAddress, 6) == 0)
  7807. {
  7808. // Examine whether the specified IP address is within the range of assignment
  7809. if (Endian32(v->DhcpIpStart) <= Endian32(request_ip) &&
  7810. Endian32(request_ip) <= Endian32(v->DhcpIpEnd))
  7811. {
  7812. // Accept if within the range
  7813. ret = request_ip;
  7814. }
  7815. }
  7816. }
  7817. else
  7818. {
  7819. // Examine whether the specified IP address is within the range of assignment
  7820. if (Endian32(v->DhcpIpStart) <= Endian32(request_ip) &&
  7821. Endian32(request_ip) <= Endian32(v->DhcpIpEnd))
  7822. {
  7823. // Accept if within the range
  7824. ret = request_ip;
  7825. }
  7826. else
  7827. {
  7828. // Propose an IP in the range since it's a Discover although It is out of range
  7829. }
  7830. }
  7831. }
  7832. if (ret == 0)
  7833. {
  7834. // If there is any entry with the same MAC address
  7835. // that are already registered, use it with priority
  7836. DHCP_LEASE *d = SearchDhcpLeaseByMac(v, mac);
  7837. if (d != NULL)
  7838. {
  7839. // Examine whether the found IP address is in the allocation region
  7840. if (Endian32(v->DhcpIpStart) <= Endian32(d->IpAddress) &&
  7841. Endian32(d->IpAddress) <= Endian32(v->DhcpIpEnd))
  7842. {
  7843. // Use the IP address if it's found within the range
  7844. ret = d->IpAddress;
  7845. }
  7846. }
  7847. }
  7848. if (ret == 0)
  7849. {
  7850. // Take an appropriate IP addresses that can be assigned newly
  7851. ret = GetFreeDhcpIpAddress(v);
  7852. }
  7853. return ret;
  7854. }
  7855. // Take an appropriate IP addresses that can be assigned newly
  7856. UINT GetFreeDhcpIpAddress(VH *v)
  7857. {
  7858. UINT ip_start, ip_end;
  7859. UINT i;
  7860. // Validate arguments
  7861. if (v == NULL)
  7862. {
  7863. return 0;
  7864. }
  7865. ip_start = Endian32(v->DhcpIpStart);
  7866. ip_end = Endian32(v->DhcpIpEnd);
  7867. for (i = ip_start; i <= ip_end;i++)
  7868. {
  7869. UINT ip = Endian32(i);
  7870. if (SearchDhcpLeaseByIp(v, ip) == NULL)
  7871. {
  7872. // A free IP address is found
  7873. return ip;
  7874. }
  7875. }
  7876. // There is no free address
  7877. return 0;
  7878. }
  7879. // Virtual DHCP Server
  7880. void VirtualDhcpServer(VH *v, PKT *p)
  7881. {
  7882. DHCPV4_HEADER *dhcp;
  7883. UCHAR *data;
  7884. UINT size;
  7885. UINT dhcp_header_size;
  7886. UINT dhcp_data_offset;
  7887. UINT tran_id;
  7888. UINT magic_cookie = Endian32(DHCP_MAGIC_COOKIE);
  7889. bool ok;
  7890. DHCP_OPTION_LIST *opt;
  7891. // Validate arguments
  7892. if (v == NULL || p == NULL)
  7893. {
  7894. return;
  7895. }
  7896. if (v->NativeNat != NULL)
  7897. {
  7898. if (Cmp(p->MacAddressSrc, v->NativeNat->CurrentMacAddress, 6) == 0)
  7899. {
  7900. // DHCP server is kept from responding for the native NAT interface
  7901. // ** Not be needed to return yet **
  7902. //return;
  7903. }
  7904. }
  7905. dhcp = p->L7.DHCPv4Header;
  7906. tran_id = Endian32(dhcp->TransactionId);
  7907. // Get the DHCP data and size
  7908. dhcp_header_size = sizeof(DHCPV4_HEADER);
  7909. dhcp_data_offset = (UINT)(((UCHAR *)p->L7.DHCPv4Header) - ((UCHAR *)p->MacHeader) + dhcp_header_size);
  7910. data = ((UCHAR *)dhcp) + dhcp_header_size;
  7911. size = p->PacketSize - dhcp_data_offset;
  7912. if (dhcp_header_size < 5)
  7913. {
  7914. // Data size is invalid
  7915. return;
  7916. }
  7917. // Search for Magic Cookie
  7918. ok = false;
  7919. while (size >= 5)
  7920. {
  7921. if (Cmp(data, &magic_cookie, sizeof(magic_cookie)) == 0)
  7922. {
  7923. // Found
  7924. data += 4;
  7925. size -= 4;
  7926. ok = true;
  7927. break;
  7928. }
  7929. data++;
  7930. size--;
  7931. }
  7932. if (ok == false)
  7933. {
  7934. // The packet is invalid
  7935. return;
  7936. }
  7937. // Parse DHCP options list
  7938. opt = ParseDhcpOptionList(data, size);
  7939. if (opt == NULL)
  7940. {
  7941. // The packet is invalid
  7942. return;
  7943. }
  7944. if (StartWith(opt->Hostname, NN_HOSTNAME_STARTWITH) || StartWith(opt->Hostname, NN_HOSTNAME_STARTWITH2))
  7945. {
  7946. Free(opt);
  7947. return;
  7948. }
  7949. if (dhcp->OpCode == 1 && (opt->Opcode == DHCP_DISCOVER || opt->Opcode == DHCP_REQUEST || opt->Opcode == DHCP_INFORM))
  7950. {
  7951. // Operate as the server
  7952. UINT ip = 0;
  7953. if (opt->RequestedIp == 0)
  7954. {
  7955. opt->RequestedIp = p->L3.IPv4Header->SrcIP;
  7956. }
  7957. if (opt->Opcode == DHCP_DISCOVER)
  7958. {
  7959. // Return an IP address that can be used
  7960. ip = ServeDhcpDiscover(v, p->MacAddressSrc, opt->RequestedIp);
  7961. }
  7962. else if (opt->Opcode == DHCP_REQUEST)
  7963. {
  7964. // Determine the IP address
  7965. ip = ServeDhcpRequest(v, p->MacAddressSrc, opt->RequestedIp);
  7966. }
  7967. if (ip != 0 || opt->Opcode == DHCP_INFORM)
  7968. {
  7969. // Respond if there is providable IP address
  7970. if (opt->Opcode == DHCP_REQUEST)
  7971. {
  7972. DHCP_LEASE *d;
  7973. char mac[MAX_SIZE];
  7974. char str[MAX_SIZE];
  7975. // Remove old records with the same IP address
  7976. d = SearchDhcpLeaseByIp(v, ip);
  7977. if (d != NULL)
  7978. {
  7979. FreeDhcpLease(d);
  7980. Delete(v->DhcpLeaseList, d);
  7981. }
  7982. // Create a new entry
  7983. d = NewDhcpLease(v->DhcpExpire, p->MacAddressSrc,
  7984. ip, v->DhcpMask,
  7985. opt->Hostname);
  7986. d->Id = ++v->DhcpId;
  7987. Add(v->DhcpLeaseList, d);
  7988. MacToStr(mac, sizeof(mac), d->MacAddress);
  7989. IPToStr32(str, sizeof(str), d->IpAddress);
  7990. NLog(v, "LH_NAT_DHCP_CREATED", d->Id, mac, str, d->Hostname, v->DhcpExpire / 1000);
  7991. }
  7992. // Respond
  7993. if (true)
  7994. {
  7995. DHCP_OPTION_LIST ret;
  7996. LIST *o;
  7997. Zero(&ret, sizeof(ret));
  7998. ret.Opcode = (opt->Opcode == DHCP_DISCOVER ? DHCP_OFFER : DHCP_ACK);
  7999. ret.ServerAddress = v->HostIP;
  8000. if (v->DhcpExpire == INFINITE)
  8001. {
  8002. ret.LeaseTime = INFINITE;
  8003. }
  8004. else
  8005. {
  8006. ret.LeaseTime = Endian32(v->DhcpExpire / 1000);
  8007. }
  8008. if (opt->Opcode == DHCP_INFORM)
  8009. {
  8010. ret.LeaseTime = 0;
  8011. }
  8012. StrCpy(ret.DomainName, sizeof(ret.DomainName), v->DhcpDomain);
  8013. ret.SubnetMask = v->DhcpMask;
  8014. ret.DnsServer = v->DhcpDns;
  8015. ret.DnsServer2 = v->DhcpDns2;
  8016. ret.Gateway = v->DhcpGateway;
  8017. if (GetGlobalServerFlag(GSF_DISABLE_PUSH_ROUTE) == 0)
  8018. {
  8019. Copy(&ret.ClasslessRoute, &v->PushRoute, sizeof(DHCP_CLASSLESS_ROUTE_TABLE));
  8020. if (IsIpcMacAddress(p->MacAddressSrc))
  8021. {
  8022. if (ret.Gateway == 0)
  8023. {
  8024. // If the default gateway is not specified, add the static routing table
  8025. // entry for the local IP subnet
  8026. // (for PPP clients)
  8027. IP dhcp_ip;
  8028. IP dhcp_mask;
  8029. IP dhcp_network;
  8030. UINTToIP(&dhcp_ip, ip);
  8031. if (ip == 0)
  8032. {
  8033. UINTToIP(&dhcp_ip, p->L3.IPv4Header->SrcIP);
  8034. }
  8035. UINTToIP(&dhcp_mask, v->DhcpMask);
  8036. IPAnd4(&dhcp_network, &dhcp_ip, &dhcp_mask);
  8037. if (GetBestClasslessRoute(&ret.ClasslessRoute, &dhcp_ip) == NULL)
  8038. {
  8039. if (ret.ClasslessRoute.NumExistingRoutes < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES)
  8040. {
  8041. DHCP_CLASSLESS_ROUTE *cr = &ret.ClasslessRoute.Entries[ret.ClasslessRoute.NumExistingRoutes];
  8042. cr->Exists = true;
  8043. UINTToIP(&cr->Gateway, v->HostIP);
  8044. if (v->UseNat == false && ret.ClasslessRoute.NumExistingRoutes >= 1)
  8045. {
  8046. Copy(&cr->Gateway, &ret.ClasslessRoute.Entries[0].Gateway, sizeof(IP));
  8047. }
  8048. Copy(&cr->Network, &dhcp_network, sizeof(IP));
  8049. Copy(&cr->SubnetMask, &dhcp_mask, sizeof(IP));
  8050. cr->SubnetMaskLen = SubnetMaskToInt(&dhcp_mask);
  8051. ret.ClasslessRoute.NumExistingRoutes++;
  8052. }
  8053. }
  8054. }
  8055. }
  8056. }
  8057. if (opt->Opcode != DHCP_INFORM)
  8058. {
  8059. char client_mac[MAX_SIZE];
  8060. char client_ip[64];
  8061. IP ips;
  8062. BinToStr(client_mac, sizeof(client_mac), p->MacAddressSrc, 6);
  8063. UINTToIP(&ips, ip);
  8064. IPToStr(client_ip, sizeof(client_ip), &ips);
  8065. Debug("DHCP %s : %s given %s\n",
  8066. ret.Opcode == DHCP_OFFER ? "DHCP_OFFER" : "DHCP_ACK",
  8067. client_mac, client_ip);
  8068. }
  8069. // Build a DHCP option
  8070. o = BuildDhcpOption(&ret);
  8071. if (o != NULL)
  8072. {
  8073. BUF *b = BuildDhcpOptionsBuf(o);
  8074. if (b != NULL)
  8075. {
  8076. UINT dest_ip = p->L3.IPv4Header->SrcIP;
  8077. if (dest_ip == 0)
  8078. {
  8079. dest_ip = 0xffffffff;
  8080. }
  8081. // Transmission
  8082. VirtualDhcpSend(v, tran_id, dest_ip, Endian16(p->L4.UDPHeader->SrcPort),
  8083. ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize);
  8084. // Release the memory
  8085. FreeBuf(b);
  8086. }
  8087. FreeDhcpOptions(o);
  8088. }
  8089. }
  8090. }
  8091. else
  8092. {
  8093. // There is no IP address that can be provided
  8094. DHCP_OPTION_LIST ret;
  8095. LIST *o;
  8096. Zero(&ret, sizeof(ret));
  8097. ret.Opcode = DHCP_NACK;
  8098. ret.ServerAddress = v->HostIP;
  8099. StrCpy(ret.DomainName, sizeof(ret.DomainName), v->DhcpDomain);
  8100. ret.SubnetMask = v->DhcpMask;
  8101. // Build the DHCP option
  8102. o = BuildDhcpOption(&ret);
  8103. if (o != NULL)
  8104. {
  8105. BUF *b = BuildDhcpOptionsBuf(o);
  8106. if (b != NULL)
  8107. {
  8108. UINT dest_ip = p->L3.IPv4Header->SrcIP;
  8109. if (dest_ip == 0)
  8110. {
  8111. dest_ip = 0xffffffff;
  8112. }
  8113. // Transmission
  8114. VirtualDhcpSend(v, tran_id, dest_ip, Endian16(p->L4.UDPHeader->SrcPort),
  8115. ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize);
  8116. // Release the memory
  8117. FreeBuf(b);
  8118. }
  8119. FreeDhcpOptions(o);
  8120. }
  8121. }
  8122. }
  8123. // Release the memory
  8124. Free(opt);
  8125. }
  8126. // Submit the DHCP response packet
  8127. void VirtualDhcpSend(VH *v, UINT tran_id, UINT dest_ip, UINT dest_port,
  8128. UINT new_ip, UCHAR *client_mac, BUF *b, UINT hw_type, UINT hw_addr_size)
  8129. {
  8130. UINT blank_size = 128 + 64;
  8131. UINT dhcp_packet_size;
  8132. UINT magic = Endian32(DHCP_MAGIC_COOKIE);
  8133. DHCPV4_HEADER *dhcp;
  8134. void *magic_cookie_addr;
  8135. void *buffer_addr;
  8136. // Validate arguments
  8137. if (v == NULL || b == NULL)
  8138. {
  8139. return;
  8140. }
  8141. // Calculate the DHCP packet size
  8142. dhcp_packet_size = blank_size + sizeof(DHCPV4_HEADER) + sizeof(magic) + b->Size;
  8143. if (dhcp_packet_size < DHCP_MIN_SIZE)
  8144. {
  8145. // Padding
  8146. dhcp_packet_size = DHCP_MIN_SIZE;
  8147. }
  8148. // Create a header
  8149. dhcp = ZeroMalloc(dhcp_packet_size);
  8150. dhcp->OpCode = 2;
  8151. dhcp->HardwareType = hw_type;
  8152. dhcp->HardwareAddressSize = hw_addr_size;
  8153. dhcp->Hops = 0;
  8154. dhcp->TransactionId = Endian32(tran_id);
  8155. dhcp->Seconds = 0;
  8156. dhcp->Flags = 0;
  8157. dhcp->YourIP = new_ip;
  8158. dhcp->ServerIP = v->HostIP;
  8159. Copy(dhcp->ClientMacAddress, client_mac, 6);
  8160. // Calculate the address
  8161. magic_cookie_addr = (((UCHAR *)dhcp) + sizeof(DHCPV4_HEADER) + blank_size);
  8162. buffer_addr = ((UCHAR *)magic_cookie_addr) + sizeof(magic);
  8163. // Magic Cookie
  8164. Copy(magic_cookie_addr, &magic, sizeof(magic));
  8165. // Buffer
  8166. Copy(buffer_addr, b->Buf, b->Size);
  8167. // Transmission
  8168. SendUdp(v, dest_ip, dest_port, v->HostIP, NAT_DHCP_SERVER_PORT, dhcp, dhcp_packet_size);
  8169. Free(dhcp);
  8170. }
  8171. // Virtual host: Process the Layer2
  8172. void VirtualLayer2(VH *v, PKT *packet)
  8173. {
  8174. bool ok;
  8175. // Validate arguments
  8176. if (packet == NULL || v == NULL)
  8177. {
  8178. return;
  8179. }
  8180. // Packet filter
  8181. if (VirtualLayer2Filter(v, packet) == false)
  8182. {
  8183. // Packet was ignored
  8184. return;
  8185. }
  8186. ok = false;
  8187. if (packet->TypeL3 == L3_IPV4 && packet->TypeL4 == L4_UDP && packet->TypeL7 == L7_DHCPV4)
  8188. {
  8189. if (v->UseDhcp)
  8190. {
  8191. // A special treatment on the DHCP packet
  8192. if (packet->BroadcastPacket || Cmp(packet->MacAddressDest, v->MacAddress, 6) == 0)
  8193. {
  8194. // Virtual DHCP server processing
  8195. VirtualDhcpServer(v, packet);
  8196. ok = true;
  8197. }
  8198. }
  8199. }
  8200. if (ok == false)
  8201. {
  8202. // The process for each supported protocol
  8203. switch (packet->TypeL3)
  8204. {
  8205. case L3_ARPV4: // ARPv4
  8206. VirtualArpReceived(v, packet);
  8207. break;
  8208. case L3_IPV4: // IPv4
  8209. VirtualIpReceived(v, packet);
  8210. break;
  8211. }
  8212. }
  8213. }
  8214. // Packet filter (Blocking packets to other than me)
  8215. bool VirtualLayer2Filter(VH *v, PKT *packet)
  8216. {
  8217. // Validate arguments
  8218. if (v == NULL || packet == NULL)
  8219. {
  8220. return false;
  8221. }
  8222. // Pass through if broadcast packet
  8223. if (packet->BroadcastPacket)
  8224. {
  8225. return true;
  8226. }
  8227. // Ignore if the sender of the packet is myself
  8228. if (Cmp(packet->MacAddressSrc, v->MacAddress, 6) == 0)
  8229. {
  8230. return false;
  8231. }
  8232. // Pass through in the case of a packet addressed to me
  8233. if (Cmp(packet->MacAddressDest, v->MacAddress, 6) == 0)
  8234. {
  8235. return true;
  8236. }
  8237. // Discard if the other packets
  8238. return false;
  8239. }
  8240. // The virtual host is made to receive a packet
  8241. bool VirtualPutPacket(VH *v, void *data, UINT size)
  8242. {
  8243. if (data == NULL)
  8244. {
  8245. // Flush
  8246. v->flag1 = false;
  8247. if (v->NativeNat != NULL)
  8248. {
  8249. if (v->NativeNat->SendStateChanged)
  8250. {
  8251. TUBE *halt_tube = NULL;
  8252. Lock(v->NativeNat->Lock);
  8253. {
  8254. if (v->NativeNat->HaltTube != NULL)
  8255. {
  8256. halt_tube = v->NativeNat->HaltTube;
  8257. AddRef(halt_tube->Ref);
  8258. }
  8259. }
  8260. Unlock(v->NativeNat->Lock);
  8261. if (halt_tube != NULL)
  8262. {
  8263. TubeFlushEx(halt_tube, true);
  8264. v->NativeNat->SendStateChanged = false;
  8265. ReleaseTube(halt_tube);
  8266. }
  8267. }
  8268. }
  8269. }
  8270. else
  8271. {
  8272. // Interpret the received packet
  8273. PKT *packet = ParsePacket(data, size);
  8274. if (v->flag1 == false)
  8275. {
  8276. v->flag1 = true;
  8277. v->Now = Tick64();
  8278. }
  8279. // Lock the entire virtual machine in here
  8280. LockVirtual(v);
  8281. {
  8282. if (packet != NULL)
  8283. {
  8284. // Process the Layer-2
  8285. VirtualLayer2(v, packet);
  8286. // Release the packet structure
  8287. FreePacket(packet);
  8288. }
  8289. }
  8290. UnlockVirtual(v);
  8291. Free(data);
  8292. }
  8293. return true;
  8294. }
  8295. bool VirtualPaPutPacket(SESSION *s, void *data, UINT size)
  8296. {
  8297. VH *v;
  8298. // Validate arguments
  8299. if (s == NULL || (v = (VH *)s->PacketAdapter->Param) == NULL)
  8300. {
  8301. return false;
  8302. }
  8303. return VirtualPutPacket(v, data, size);
  8304. }
  8305. // Get the options for the virtual host
  8306. void GetVirtualHostOption(VH *v, VH_OPTION *o)
  8307. {
  8308. // Validate arguments
  8309. if (v == NULL)
  8310. {
  8311. return;
  8312. }
  8313. LockVirtual(v);
  8314. {
  8315. Zero(o, sizeof(VH_OPTION));
  8316. // MAC address
  8317. Copy(o->MacAddress, v->MacAddress, 6);
  8318. // Host information
  8319. UINTToIP(&o->Ip, v->HostIP);
  8320. UINTToIP(&o->Mask, v->HostMask);
  8321. o->Mtu = v->Mtu;
  8322. // NAT timeout information
  8323. o->NatTcpTimeout = v->NatTcpTimeout / 1000;
  8324. o->NatUdpTimeout = v->NatUdpTimeout / 1000;
  8325. // NAT using flag
  8326. o->UseNat = v->UseNat;
  8327. // DHCP using flag
  8328. o->UseDhcp = v->UseDhcp;
  8329. // IP address range for DHCP distribution
  8330. UINTToIP(&o->DhcpLeaseIPStart, v->DhcpIpStart);
  8331. UINTToIP(&o->DhcpLeaseIPEnd, v->DhcpIpEnd);
  8332. // Subnet mask
  8333. UINTToIP(&o->DhcpSubnetMask, v->DhcpMask);
  8334. // Expiration date
  8335. if (v->DhcpExpire != INFINITE)
  8336. {
  8337. o->DhcpExpireTimeSpan = v->DhcpExpire / 1000;
  8338. }
  8339. else
  8340. {
  8341. o->DhcpExpireTimeSpan = INFINITE;
  8342. }
  8343. // Gateway address
  8344. UINTToIP(&o->DhcpGatewayAddress, v->DhcpGateway);
  8345. // DNS server address
  8346. UINTToIP(&o->DhcpDnsServerAddress, v->DhcpDns);
  8347. UINTToIP(&o->DhcpDnsServerAddress2, v->DhcpDns2);
  8348. // Domain name
  8349. StrCpy(o->DhcpDomainName, sizeof(o->DhcpDomainName), v->DhcpDomain);
  8350. // Save a log
  8351. o->SaveLog = v->SaveLog;
  8352. // Pushing route option
  8353. BuildClasslessRouteTableStr(o->DhcpPushRoutes, sizeof(o->DhcpPushRoutes), &v->PushRoute);
  8354. o->ApplyDhcpPushRoutes = true;
  8355. }
  8356. UnlockVirtual(v);
  8357. }
  8358. // Set the option to the virtual host
  8359. void SetVirtualHostOption(VH *v, VH_OPTION *vo)
  8360. {
  8361. UINT i;
  8362. // Validate arguments
  8363. if (v == NULL || vo == NULL)
  8364. {
  8365. return;
  8366. }
  8367. LockVirtual(v);
  8368. {
  8369. // Set the MAC address
  8370. for (i = 0;i < 6;i++)
  8371. {
  8372. if (vo->MacAddress[i] != 0)
  8373. {
  8374. Copy(v->MacAddress, vo->MacAddress, 6);
  8375. break;
  8376. }
  8377. }
  8378. // Set the host information list
  8379. v->HostIP = IPToUINT(&vo->Ip);
  8380. v->HostMask = IPToUINT(&vo->Mask);
  8381. // Set the MTU, MMS
  8382. v->Mtu = MIN(vo->Mtu, MAX_L3_DATA_SIZE);
  8383. if (v->Mtu == 0)
  8384. {
  8385. v->Mtu = MAX_L3_DATA_SIZE;
  8386. }
  8387. v->Mtu = MAX(v->Mtu, TCP_HEADER_SIZE + IP_HEADER_SIZE + MAC_HEADER_SIZE + 8);
  8388. v->IpMss = ((v->Mtu - IP_HEADER_SIZE) / 8) * 8;
  8389. v->TcpMss = ((v->IpMss - TCP_HEADER_SIZE) / 8) * 8;
  8390. v->UdpMss = ((v->IpMss - UDP_HEADER_SIZE) / 8) * 8;
  8391. if (vo->NatTcpTimeout != 0)
  8392. {
  8393. v->NatTcpTimeout = MIN(vo->NatTcpTimeout, 4000000) * 1000;
  8394. }
  8395. if (vo->NatUdpTimeout != 0)
  8396. {
  8397. v->NatUdpTimeout = MIN(vo->NatUdpTimeout, 4000000) * 1000;
  8398. }
  8399. v->NatTcpTimeout = MAKESURE(v->NatTcpTimeout, NAT_TCP_MIN_TIMEOUT, NAT_TCP_MAX_TIMEOUT);
  8400. v->NatUdpTimeout = MAKESURE(v->NatUdpTimeout, NAT_UDP_MIN_TIMEOUT, NAT_UDP_MAX_TIMEOUT);
  8401. Debug("Timeout: %d , %d\n", v->NatTcpTimeout, v->NatUdpTimeout);
  8402. // NAT using flag
  8403. v->UseNat = vo->UseNat;
  8404. // DHCP using flag
  8405. v->UseDhcp = vo->UseDhcp;
  8406. // Expiration date
  8407. if (vo->DhcpExpireTimeSpan == 0 || vo->DhcpExpireTimeSpan == INFINITE)
  8408. {
  8409. v->DhcpExpire = INFINITE;
  8410. }
  8411. else
  8412. {
  8413. v->DhcpExpire = MAKESURE(DHCP_MIN_EXPIRE_TIMESPAN,
  8414. MIN(vo->DhcpExpireTimeSpan * 1000, 2000000000),
  8415. INFINITE);
  8416. }
  8417. // Address range to be distributed
  8418. v->DhcpIpStart = IPToUINT(&vo->DhcpLeaseIPStart);
  8419. v->DhcpIpEnd = IPToUINT(&vo->DhcpLeaseIPEnd);
  8420. if (Endian32(v->DhcpIpEnd) < Endian32(v->DhcpIpStart))
  8421. {
  8422. v->DhcpIpEnd = v->DhcpIpStart;
  8423. }
  8424. // Subnet mask
  8425. v->DhcpMask = IPToUINT(&vo->DhcpSubnetMask);
  8426. // Gateway address
  8427. v->DhcpGateway = IPToUINT(&vo->DhcpGatewayAddress);
  8428. // DNS server address
  8429. v->DhcpDns = IPToUINT(&vo->DhcpDnsServerAddress);
  8430. v->DhcpDns2 = IPToUINT(&vo->DhcpDnsServerAddress2);
  8431. // Domain name
  8432. StrCpy(v->DhcpDomain, sizeof(v->DhcpDomain), vo->DhcpDomainName);
  8433. // Save a log
  8434. v->SaveLog = vo->SaveLog;
  8435. // DHCP routing table pushing setting
  8436. if (vo->ApplyDhcpPushRoutes)
  8437. {
  8438. DHCP_CLASSLESS_ROUTE_TABLE rt;
  8439. Zero(&rt, sizeof(rt));
  8440. if (ParseClasslessRouteTableStr(&rt, vo->DhcpPushRoutes))
  8441. {
  8442. Copy(&v->PushRoute, &rt, sizeof(DHCP_CLASSLESS_ROUTE_TABLE));
  8443. }
  8444. }
  8445. }
  8446. UnlockVirtual(v);
  8447. }
  8448. // Release the virtual host
  8449. void Virtual_Free(VH *v)
  8450. {
  8451. // Release the DHCP server
  8452. FreeDhcpServer(v);
  8453. // NAT release
  8454. FreeNat(v);
  8455. LockVirtual(v);
  8456. {
  8457. // Release the IP combining list
  8458. FreeIpCombineList(v);
  8459. // Release the IP waiting table
  8460. FreeIpWaitTable(v);
  8461. // Release the ARP waiting table
  8462. FreeArpWaitTable(v);
  8463. // Release the ARP table
  8464. FreeArpTable(v);
  8465. // Release the transmission queue
  8466. LockQueue(v->SendQueue);
  8467. {
  8468. BLOCK *block;
  8469. // Release all queues
  8470. while (block = GetNext(v->SendQueue))
  8471. {
  8472. FreeBlock(block);
  8473. }
  8474. }
  8475. UnlockQueue(v->SendQueue);
  8476. ReleaseQueue(v->SendQueue);
  8477. v->SendQueue = NULL;
  8478. // Release the cancel object
  8479. ReleaseCancel(v->Cancel);
  8480. v->Active = false;
  8481. }
  8482. UnlockVirtual(v);
  8483. // Release the logger
  8484. FreeLog(v->Logger);
  8485. }
  8486. void VirtualPaFree(SESSION *s)
  8487. {
  8488. VH *v;
  8489. // Validate arguments
  8490. if (s == NULL || (v = (VH *)s->PacketAdapter->Param) == NULL)
  8491. {
  8492. return;
  8493. }
  8494. Virtual_Free(v);
  8495. }
  8496. // Release the virtual host
  8497. void ReleaseVirtual(VH *v)
  8498. {
  8499. // Validate arguments
  8500. if (v == NULL)
  8501. {
  8502. return;
  8503. }
  8504. if (Release(v->ref) == 0)
  8505. {
  8506. CleanupVirtual(v);
  8507. }
  8508. }
  8509. // Lock the virtual host
  8510. void LockVirtual(VH *v)
  8511. {
  8512. // Validate arguments
  8513. if (v == NULL)
  8514. {
  8515. return;
  8516. }
  8517. Lock(v->lock);
  8518. }
  8519. // Unlock the virtual host
  8520. void UnlockVirtual(VH *v)
  8521. {
  8522. // Validate arguments
  8523. if (v == NULL)
  8524. {
  8525. return;
  8526. }
  8527. Unlock(v->lock);
  8528. }
  8529. // Cleanup the virtual host
  8530. void CleanupVirtual(VH *v)
  8531. {
  8532. // Validate arguments
  8533. if (v == NULL)
  8534. {
  8535. return;
  8536. }
  8537. if (v->Session != NULL)
  8538. {
  8539. ReleaseSession(v->Session);
  8540. }
  8541. DeleteCounter(v->Counter);
  8542. DeleteLock(v->lock);
  8543. Free(v);
  8544. }
  8545. // Stop the virtual host
  8546. void StopVirtualHost(VH *v)
  8547. {
  8548. SESSION *s;
  8549. // Validate arguments
  8550. if (v == NULL)
  8551. {
  8552. return;
  8553. }
  8554. // Get the session corresponding to the virtual host
  8555. LockVirtual(v);
  8556. {
  8557. s = v->Session;
  8558. if (s != NULL)
  8559. {
  8560. AddRef(s->ref);
  8561. }
  8562. }
  8563. UnlockVirtual(v);
  8564. if (s == NULL)
  8565. {
  8566. // This session is already stopped
  8567. return;
  8568. }
  8569. // Stop Session
  8570. StopSession(s);
  8571. ReleaseSession(s);
  8572. }
  8573. // Create a new virtual host
  8574. VH *NewVirtualHost(CEDAR *cedar, CLIENT_OPTION *option, CLIENT_AUTH *auth, VH_OPTION *vh_option)
  8575. {
  8576. return NewVirtualHostEx(cedar, option, auth, vh_option, NULL);
  8577. }
  8578. VH *NewVirtualHostEx(CEDAR *cedar, CLIENT_OPTION *option, CLIENT_AUTH *auth, VH_OPTION *vh_option, NAT *nat)
  8579. {
  8580. VH *v;
  8581. SOCK *s;
  8582. // Validate arguments
  8583. if (vh_option == NULL)
  8584. {
  8585. return NULL;
  8586. }
  8587. // Create a VH
  8588. v = ZeroMalloc(sizeof(VH));
  8589. v->ref = NewRef();
  8590. v->lock = NewLock();
  8591. v->Counter = NewCounter();
  8592. v->nat = nat;
  8593. // Examine whether ICMP Raw Socket can be created
  8594. s = NewUDP4(MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4), NULL);
  8595. if (s != NULL)
  8596. {
  8597. if (s->IsTtlSupported)
  8598. {
  8599. v->IcmpRawSocketOk = true;
  8600. }
  8601. ReleaseSock(s);
  8602. }
  8603. if (v->IcmpRawSocketOk == false)
  8604. {
  8605. if (IsIcmpApiSupported())
  8606. {
  8607. v->IcmpApiOk = true;
  8608. }
  8609. }
  8610. // Set the options
  8611. SetVirtualHostOption(v, vh_option);
  8612. return v;
  8613. }
  8614. // Generate a random MAC address
  8615. void GenMacAddress(UCHAR *mac)
  8616. {
  8617. UCHAR rand_data[32];
  8618. UINT64 now;
  8619. BUF *b;
  8620. UCHAR hash[SHA1_SIZE];
  8621. // Validate arguments
  8622. if (mac == NULL)
  8623. {
  8624. return;
  8625. }
  8626. // Get the current time
  8627. now = SystemTime64();
  8628. // Generate a random number
  8629. Rand(rand_data, sizeof(rand_data));
  8630. // Add to the buffer
  8631. b = NewBuf();
  8632. WriteBuf(b, &now, sizeof(now));
  8633. WriteBuf(b, rand_data, sizeof(rand_data));
  8634. // Hash
  8635. Hash(hash, b->Buf, b->Size, true);
  8636. // Generate a MAC address
  8637. mac[0] = 0x00;
  8638. mac[1] = 0xAC; // AC hurray
  8639. mac[2] = hash[0];
  8640. mac[3] = hash[1];
  8641. mac[4] = hash[2];
  8642. mac[5] = hash[3];
  8643. FreeBuf(b);
  8644. }
  8645. // Get a packet of virtual host adapter
  8646. PACKET_ADAPTER *VirtualGetPacketAdapter()
  8647. {
  8648. return NewPacketAdapter(VirtualPaInit, VirtualPaGetCancel,
  8649. VirtualPaGetNextPacket, VirtualPaPutPacket, VirtualPaFree);
  8650. }
  8651. // Developed by SoftEther VPN Project at University of Tsukuba in Japan.
  8652. // Department of Computer Science has dozens of overly-enthusiastic geeks.
  8653. // Join us: http://www.tsukuba.ac.jp/english/admission/