Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310/* * Copyright 2018 Nikolay Sivov * Copyright 2018 Zhiyi Zhang * Copyright 2021-2023 Zebediah Figura * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */
#include <stdarg.h>#include <stdbool.h>#include <string.h>#include <wchar.h>
#ifndef STATIC_PATHCCH
#include "windef.h"#include "winbase.h"#include "pathcch.h"#include "strsafe.h"#include "shlwapi.h"#include "wininet.h"#include "intshcut.h"#include "winternl.h"
#include "kernelbase.h"#include "wine/exception.h"#include "wine/debug.h"#include "wine/heap.h"
WINE_DEFAULT_DEBUG_CHANNEL(path);
#else // STATIC_PATHCCH#ifdef __REACTOS__/* This is the static implementation of the PathCch library */
#include <windef.h>#include <winbase.h>
/* The PathCch functions use size_t, but Wine's implementation uses SIZE_T, * so temporarily change the define'd SIZE_T type to the compatible one... */#undef SIZE_T#define SIZE_T size_t
#include <pathcch.h>#include <strsafe.h>
#define TRACE(...)
#if (_WIN32_WINNT < _WIN32_WINNT_VISTA) || (DLL_EXPORT_VERSION < _WIN32_WINNT_VISTA)/* wcsnlen is an NT6+ function. To cover all cases, use a private implementation */static inline size_t compat_wcsnlen(const wchar_t* str, size_t size){ StringCchLengthW(str, size, &size); return size;}#define wcsnlen compat_wcsnlen#endif /* _WIN32_WINNT || DLL_EXPORT_VERSION */
// Implementation from string.c copied here in order not// to depend on the whole file just for the PathCch library.WCHAR * WINAPI StrRChrW(const WCHAR *str, const WCHAR *end, WORD ch){ WCHAR *ret = NULL;
if (!str) return NULL; if (!end) end = str + lstrlenW(str); while (str < end) { if (*str == ch) ret = (WCHAR *)str; str++; } return ret;}
#endif /* __REACTOS__ */#endif // STATIC_PATHCCH
#ifndef STATIC_PATHCCH
static const char hexDigits[] = "0123456789ABCDEF";
static const unsigned char hashdata_lookup[256] ={ 0x01, 0x0e, 0x6e, 0x19, 0x61, 0xae, 0x84, 0x77, 0x8a, 0xaa, 0x7d, 0x76, 0x1b, 0xe9, 0x8c, 0x33, 0x57, 0xc5, 0xb1, 0x6b, 0xea, 0xa9, 0x38, 0x44, 0x1e, 0x07, 0xad, 0x49, 0xbc, 0x28, 0x24, 0x41, 0x31, 0xd5, 0x68, 0xbe, 0x39, 0xd3, 0x94, 0xdf, 0x30, 0x73, 0x0f, 0x02, 0x43, 0xba, 0xd2, 0x1c, 0x0c, 0xb5, 0x67, 0x46, 0x16, 0x3a, 0x4b, 0x4e, 0xb7, 0xa7, 0xee, 0x9d, 0x7c, 0x93, 0xac, 0x90, 0xb0, 0xa1, 0x8d, 0x56, 0x3c, 0x42, 0x80, 0x53, 0x9c, 0xf1, 0x4f, 0x2e, 0xa8, 0xc6, 0x29, 0xfe, 0xb2, 0x55, 0xfd, 0xed, 0xfa, 0x9a, 0x85, 0x58, 0x23, 0xce, 0x5f, 0x74, 0xfc, 0xc0, 0x36, 0xdd, 0x66, 0xda, 0xff, 0xf0, 0x52, 0x6a, 0x9e, 0xc9, 0x3d, 0x03, 0x59, 0x09, 0x2a, 0x9b, 0x9f, 0x5d, 0xa6, 0x50, 0x32, 0x22, 0xaf, 0xc3, 0x64, 0x63, 0x1a, 0x96, 0x10, 0x91, 0x04, 0x21, 0x08, 0xbd, 0x79, 0x40, 0x4d, 0x48, 0xd0, 0xf5, 0x82, 0x7a, 0x8f, 0x37, 0x69, 0x86, 0x1d, 0xa4, 0xb9, 0xc2, 0xc1, 0xef, 0x65, 0xf2, 0x05, 0xab, 0x7e, 0x0b, 0x4a, 0x3b, 0x89, 0xe4, 0x6c, 0xbf, 0xe8, 0x8b, 0x06, 0x18, 0x51, 0x14, 0x7f, 0x11, 0x5b, 0x5c, 0xfb, 0x97, 0xe1, 0xcf, 0x15, 0x62, 0x71, 0x70, 0x54, 0xe2, 0x12, 0xd6, 0xc7, 0xbb, 0x0d, 0x20, 0x5e, 0xdc, 0xe0, 0xd4, 0xf7, 0xcc, 0xc4, 0x2b, 0xf9, 0xec, 0x2d, 0xf4, 0x6f, 0xb6, 0x99, 0x88, 0x81, 0x5a, 0xd9, 0xca, 0x13, 0xa5, 0xe7, 0x47, 0xe6, 0x8e, 0x60, 0xe3, 0x3e, 0xb3, 0xf6, 0x72, 0xa2, 0x35, 0xa0, 0xd7, 0xcd, 0xb4, 0x2f, 0x6d, 0x2c, 0x26, 0x1f, 0x95, 0x87, 0x00, 0xd8, 0x34, 0x3f, 0x17, 0x25, 0x45, 0x27, 0x75, 0x92, 0xb8, 0xa3, 0xc8, 0xde, 0xeb, 0xf8, 0xf3, 0xdb, 0x0a, 0x98, 0x83, 0x7b, 0xe5, 0xcb, 0x4c, 0x78, 0xd1,};
struct parsed_url{ const WCHAR *scheme; /* [out] start of scheme */ DWORD scheme_len; /* [out] size of scheme (until colon) */ const WCHAR *username; /* [out] start of Username */ DWORD username_len; /* [out] size of Username (until ":" or "@") */ const WCHAR *password; /* [out] start of Password */ DWORD password_len; /* [out] size of Password (until "@") */ const WCHAR *hostname; /* [out] start of Hostname */ DWORD hostname_len; /* [out] size of Hostname (until ":" or "/") */ const WCHAR *port; /* [out] start of Port */ DWORD port_len; /* [out] size of Port (until "/" or eos) */ const WCHAR *query; /* [out] start of Query */ DWORD query_len; /* [out] size of Query (until eos) */ DWORD scheme_number;};
static WCHAR *heap_strdupAtoW(const char *str){ WCHAR *ret = NULL;
if (str) { DWORD len;
len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); ret = heap_alloc(len * sizeof(WCHAR)); MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len); }
return ret;}
static bool array_reserve(void **elements, size_t *capacity, size_t count, size_t size){ unsigned int new_capacity, max_capacity; void *new_elements;
if (count <= *capacity) return true;
max_capacity = ~(SIZE_T)0 / size; if (count > max_capacity) return false;
new_capacity = max(4, *capacity); while (new_capacity < count && new_capacity <= max_capacity / 2) new_capacity *= 2; if (new_capacity < count) new_capacity = max_capacity;
if (!(new_elements = heap_realloc( *elements, new_capacity * size ))) return false;
*elements = new_elements; *capacity = new_capacity;
return true;}
static bool is_slash( char c ){ return c == '/' || c == '\\';}
static BOOL is_drive_specA( const char *str ){ return isalpha( str[0] ) && str[1] == ':';}
#endif // !STATIC_PATHCCH
static BOOL is_drive_spec( const WCHAR *str ){ return isalpha( str[0] ) && str[1] == ':';}
#ifndef STATIC_PATHCCHstatic BOOL is_escaped_drive_spec( const WCHAR *str ){ return isalpha( str[0] ) && (str[1] == ':' || str[1] == '|');}#endif // !STATIC_PATHCCH
static BOOL is_prefixed_unc(const WCHAR *string){ return !wcsnicmp(string, L"\\\\?\\UNC\\", 8 );}
static BOOL is_prefixed_disk(const WCHAR *string){ return !wcsncmp(string, L"\\\\?\\", 4) && is_drive_spec( string + 4 );}
static BOOL is_prefixed_volume(const WCHAR *string){ const WCHAR *guid; INT i = 0;
if (wcsnicmp( string, L"\\\\?\\Volume", 10 )) return FALSE;
guid = string + 10;
while (i <= 37) { switch (i) { case 0: if (guid[i] != '{') return FALSE; break; case 9: case 14: case 19: case 24: if (guid[i] != '-') return FALSE; break; case 37: if (guid[i] != '}') return FALSE; break; default: if (!isxdigit(guid[i])) return FALSE; break; } i++; }
return TRUE;}
/* Get the next character beyond end of the segment. Return TRUE if the last segment ends with a backslash */static BOOL get_next_segment(const WCHAR *next, const WCHAR **next_segment){ while (*next && *next != '\\') next++; if (*next == '\\') { *next_segment = next + 1; return TRUE; } else { *next_segment = next; return FALSE; }}
/* Find the last character of the root in a path, if there is one, without any segments */static const WCHAR *get_root_end(const WCHAR *path){ /* Find path root */ if (is_prefixed_volume(path)) return path[48] == '\\' ? path + 48 : path + 47; else if (is_prefixed_unc(path)) return path + 7; else if (is_prefixed_disk(path)) return path[6] == '\\' ? path + 6 : path + 5; /* \\ */ else if (path[0] == '\\' && path[1] == '\\') return path + 1; /* \ */ else if (path[0] == '\\') return path; /* X:\ */ else if (is_drive_spec( path )) return path[2] == '\\' ? path + 2 : path + 1; else return NULL;}
HRESULT WINAPI PathAllocCanonicalize(const WCHAR *path_in, DWORD flags, WCHAR **path_out){ WCHAR *buffer, *dst; const WCHAR *src; const WCHAR *root_end; SIZE_T buffer_size, length;
TRACE("%s %#lx %p\n", debugstr_w(path_in), flags, path_out);
if (!path_in || !path_out || ((flags & PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS) && (flags & PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS)) || (flags & (PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS | PATHCCH_FORCE_DISABLE_LONG_NAME_PROCESS) && !(flags & PATHCCH_ALLOW_LONG_PATHS)) || ((flags & PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH) && (flags & PATHCCH_ALLOW_LONG_PATHS))) { if (path_out) *path_out = NULL; return E_INVALIDARG; }
length = lstrlenW(path_in); if ((length + 1 > MAX_PATH && !(flags & (PATHCCH_ALLOW_LONG_PATHS | PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH))) || (length + 1 > PATHCCH_MAX_CCH)) { *path_out = NULL; return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE); }
/* PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH implies PATHCCH_DO_NOT_NORMALIZE_SEGMENTS */ if (flags & PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH) flags |= PATHCCH_DO_NOT_NORMALIZE_SEGMENTS;
/* path length + possible \\?\ addition + possible \ addition + NUL */ buffer_size = (length + 6) * sizeof(WCHAR); buffer = LocalAlloc(LMEM_ZEROINIT, buffer_size); if (!buffer) { *path_out = NULL; return E_OUTOFMEMORY; }
src = path_in; dst = buffer;
root_end = get_root_end(path_in); if (root_end) root_end = buffer + (root_end - path_in);
/* Copy path root */ if (root_end) { memcpy(dst, src, (root_end - buffer + 1) * sizeof(WCHAR)); src += root_end - buffer + 1; if(PathCchStripPrefix(dst, length + 6) == S_OK) { /* Fill in \ in X:\ if the \ is missing */ if (is_drive_spec( dst ) && dst[2]!= '\\') { dst[2] = '\\'; dst[3] = 0; } dst = buffer + lstrlenW(buffer); root_end = dst; } else dst += root_end - buffer + 1; }
while (*src) { if (src[0] == '.') { if (src[1] == '.') { /* Keep one . after * */ if (dst > buffer && dst[-1] == '*') { *dst++ = *src++; continue; }
/* Keep the .. if not surrounded by \ */ if ((src[2] != '\\' && src[2]) || (dst > buffer && dst[-1] != '\\')) { *dst++ = *src++; *dst++ = *src++; continue; }
/* Remove the \ before .. if the \ is not part of root */ if (dst > buffer && dst[-1] == '\\' && (!root_end || dst - 1 > root_end)) { *--dst = '\0'; /* Remove characters until a \ is encountered */ while (dst > buffer) { if (dst[-1] == '\\') { *--dst = 0; break; } else *--dst = 0; } } /* Remove the extra \ after .. if the \ before .. wasn't deleted */ else if (src[2] == '\\') src++;
src += 2; } else { /* Keep the . if not surrounded by \ */ if ((src[1] != '\\' && src[1]) || (dst > buffer && dst[-1] != '\\')) { *dst++ = *src++; continue; }
/* Remove the \ before . if the \ is not part of root */ if (dst > buffer && dst[-1] == '\\' && (!root_end || dst - 1 > root_end)) dst--; /* Remove the extra \ after . if the \ before . wasn't deleted */ else if (src[1] == '\\') src++;
src++; }
/* If X:\ is not complete, then complete it */ if (is_drive_spec( buffer ) && buffer[2] != '\\') { root_end = buffer + 2; dst = buffer + 3; buffer[2] = '\\'; /* If next character is \, use the \ to fill in */ if (src[0] == '\\') src++; } } /* Copy over */ else *dst++ = *src++; } /* End the path */ *dst = 0;
/* Strip multiple trailing . */ if (!(flags & PATHCCH_DO_NOT_NORMALIZE_SEGMENTS)) { while (dst > buffer && dst[-1] == '.') { /* Keep a . after * */ if (dst - 1 > buffer && dst[-2] == '*') break; /* If . follow a : at the second character, remove the . and add a \ */ else if (dst - 1 > buffer && dst[-2] == ':' && dst - 2 == buffer + 1) *--dst = '\\'; else *--dst = 0; } }
/* If result path is empty, fill in \ */ if (!*buffer) { buffer[0] = '\\'; buffer[1] = 0; }
/* Extend the path if needed */ length = lstrlenW(buffer); if (((length + 1 > MAX_PATH && is_drive_spec( buffer )) || (is_drive_spec( buffer ) && flags & PATHCCH_ENSURE_IS_EXTENDED_LENGTH_PATH)) && !(flags & PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS)) { memmove(buffer + 4, buffer, (length + 1) * sizeof(WCHAR)); buffer[0] = '\\'; buffer[1] = '\\'; buffer[2] = '?'; buffer[3] = '\\'; }
/* Add a trailing backslash to the path if needed */ if (flags & PATHCCH_ENSURE_TRAILING_SLASH) PathCchAddBackslash(buffer, buffer_size);
*path_out = buffer; return S_OK;}
HRESULT WINAPI PathAllocCombine(const WCHAR *path1, const WCHAR *path2, DWORD flags, WCHAR **out){ SIZE_T combined_length, length2; WCHAR *combined_path; BOOL add_backslash = FALSE; HRESULT hr;
TRACE("%s %s %#lx %p\n", wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags, out);
if ((!path1 && !path2) || !out) { if (out) *out = NULL; return E_INVALIDARG; }
if (!path1 || !path2) return PathAllocCanonicalize(path1 ? path1 : path2, flags, out);
/* If path2 is fully qualified, use path2 only */ if (is_drive_spec( path2 ) || (path2[0] == '\\' && path2[1] == '\\')) { path1 = path2; path2 = NULL; add_backslash = (is_drive_spec(path1) && !path1[2]) || (is_prefixed_disk(path1) && !path1[6]); }
length2 = path2 ? lstrlenW(path2) : 0; /* path1 length + path2 length + possible backslash + NULL */ combined_length = lstrlenW(path1) + length2 + 2;
combined_path = HeapAlloc(GetProcessHeap(), 0, combined_length * sizeof(WCHAR)); if (!combined_path) { *out = NULL; return E_OUTOFMEMORY; }
lstrcpyW(combined_path, path1); PathCchStripPrefix(combined_path, combined_length); if (add_backslash) PathCchAddBackslashEx(combined_path, combined_length, NULL, NULL);
if (path2 && path2[0]) { if (path2[0] == '\\' && path2[1] != '\\') { PathCchStripToRoot(combined_path, combined_length); path2++; }
PathCchAddBackslashEx(combined_path, combined_length, NULL, NULL); lstrcatW(combined_path, path2); }
hr = PathAllocCanonicalize(combined_path, flags, out); HeapFree(GetProcessHeap(), 0, combined_path); return hr;}
HRESULT WINAPI PathCchAddBackslash(WCHAR *path, SIZE_T size){ return PathCchAddBackslashEx(path, size, NULL, NULL);}
HRESULT WINAPI PathCchAddBackslashEx(WCHAR *path, SIZE_T size, WCHAR **endptr, SIZE_T *remaining){ BOOL needs_termination; SIZE_T length;
TRACE("%s, %Iu, %p, %p\n", debugstr_w(path), size, endptr, remaining);
length = lstrlenW(path); needs_termination = size && length && path[length - 1] != '\\';
if (length >= (needs_termination ? size - 1 : size)) { if (endptr) *endptr = NULL; if (remaining) *remaining = 0; return STRSAFE_E_INSUFFICIENT_BUFFER; }
if (!needs_termination) { if (endptr) *endptr = path + length; if (remaining) *remaining = size - length; return S_FALSE; }
path[length++] = '\\'; path[length] = 0;
if (endptr) *endptr = path + length; if (remaining) *remaining = size - length;
return S_OK;}
HRESULT WINAPI PathCchAddExtension(WCHAR *path, SIZE_T size, const WCHAR *extension){ const WCHAR *existing_extension, *next; SIZE_T path_length, extension_length, dot_length; BOOL has_dot; HRESULT hr;
TRACE("%s %Iu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
if (!path || !size || size > PATHCCH_MAX_CCH || !extension) return E_INVALIDARG;
next = extension; while (*next) { if ((*next == '.' && next > extension) || *next == ' ' || *next == '\\') return E_INVALIDARG; next++; }
has_dot = extension[0] == '.';
hr = PathCchFindExtension(path, size, &existing_extension); if (FAILED(hr)) return hr; if (*existing_extension) return S_FALSE;
path_length = wcsnlen(path, size); dot_length = has_dot ? 0 : 1; extension_length = lstrlenW(extension);
if (path_length + dot_length + extension_length + 1 > size) return STRSAFE_E_INSUFFICIENT_BUFFER;
/* If extension is empty or only dot, return S_OK with path unchanged */ if (!extension[0] || (extension[0] == '.' && !extension[1])) return S_OK;
if (!has_dot) { path[path_length] = '.'; path_length++; }
lstrcpyW(path + path_length, extension); return S_OK;}
HRESULT WINAPI PathCchAppend(WCHAR *path1, SIZE_T size, const WCHAR *path2){ TRACE("%s %Iu %s\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2));
return PathCchAppendEx(path1, size, path2, PATHCCH_NONE);}
HRESULT WINAPI PathCchAppendEx(WCHAR *path1, SIZE_T size, const WCHAR *path2, DWORD flags){ HRESULT hr; WCHAR *result;
TRACE("%s %Iu %s %#lx\n", wine_dbgstr_w(path1), size, wine_dbgstr_w(path2), flags);
if (!path1 || !size) return E_INVALIDARG;
/* Create a temporary buffer for result because we need to keep path1 unchanged if error occurs. * And PathCchCombineEx writes empty result if there is error so we can't just use path1 as output * buffer for PathCchCombineEx */ result = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR)); if (!result) return E_OUTOFMEMORY;
/* Avoid the single backslash behavior with PathCchCombineEx when appending */ if (path2 && path2[0] == '\\' && path2[1] != '\\') path2++;
hr = PathCchCombineEx(result, size, path1, path2, flags); if (SUCCEEDED(hr)) memcpy(path1, result, size * sizeof(WCHAR));
HeapFree(GetProcessHeap(), 0, result); return hr;}
HRESULT WINAPI PathCchCanonicalize(WCHAR *out, SIZE_T size, const WCHAR *in){ TRACE("%p %Iu %s\n", out, size, wine_dbgstr_w(in));
/* Not X:\ and path > MAX_PATH - 4, return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) */ if (lstrlenW(in) > MAX_PATH - 4 && !(is_drive_spec( in ) && in[2] == '\\')) return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE);
return PathCchCanonicalizeEx(out, size, in, PATHCCH_NONE);}
HRESULT WINAPI PathCchCanonicalizeEx(WCHAR *out, SIZE_T size, const WCHAR *in, DWORD flags){ WCHAR *buffer; SIZE_T length; HRESULT hr;
TRACE("%p %Iu %s %#lx\n", out, size, wine_dbgstr_w(in), flags);
if (!size) return E_INVALIDARG;
hr = PathAllocCanonicalize(in, flags, &buffer); if (FAILED(hr)) return hr;
length = lstrlenW(buffer); if (size < length + 1) { /* No root and path > MAX_PATH - 4, return HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE) */ if (length > MAX_PATH - 4 && !(in[0] == '\\' || (is_drive_spec( in ) && in[2] == '\\'))) hr = HRESULT_FROM_WIN32(ERROR_FILENAME_EXCED_RANGE); else hr = STRSAFE_E_INSUFFICIENT_BUFFER; }
if (SUCCEEDED(hr)) { memcpy(out, buffer, (length + 1) * sizeof(WCHAR));
/* Fill a backslash at the end of X: */ if (is_drive_spec( out ) && !out[2] && size > 3) { out[2] = '\\'; out[3] = 0; } }
LocalFree(buffer); return hr;}
HRESULT WINAPI PathCchCombine(WCHAR *out, SIZE_T size, const WCHAR *path1, const WCHAR *path2){ TRACE("%p %s %s\n", out, wine_dbgstr_w(path1), wine_dbgstr_w(path2));
return PathCchCombineEx(out, size, path1, path2, PATHCCH_NONE);}
HRESULT WINAPI PathCchCombineEx(WCHAR *out, SIZE_T size, const WCHAR *path1, const WCHAR *path2, DWORD flags){ HRESULT hr; WCHAR *buffer; SIZE_T length;
TRACE("%p %s %s %#lx\n", out, wine_dbgstr_w(path1), wine_dbgstr_w(path2), flags);
if (!out || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
hr = PathAllocCombine(path1, path2, flags, &buffer); if (FAILED(hr)) { out[0] = 0; return hr; }
length = lstrlenW(buffer); if (length + 1 > size) { out[0] = 0; LocalFree(buffer); return STRSAFE_E_INSUFFICIENT_BUFFER; } else { memcpy(out, buffer, (length + 1) * sizeof(WCHAR)); LocalFree(buffer); return S_OK; }}
HRESULT WINAPI PathCchFindExtension(const WCHAR *path, SIZE_T size, const WCHAR **extension){ const WCHAR *lastpoint = NULL; SIZE_T counter = 0;
TRACE("%s %Iu %p\n", wine_dbgstr_w(path), size, extension);
if (!path || !size || size > PATHCCH_MAX_CCH) { *extension = NULL; return E_INVALIDARG; }
while (*path) { if (*path == '\\' || *path == ' ') lastpoint = NULL; else if (*path == '.') lastpoint = path;
path++; counter++; if (counter == size || counter == PATHCCH_MAX_CCH) { *extension = NULL; return E_INVALIDARG; } }
*extension = lastpoint ? lastpoint : path; return S_OK;}
BOOL WINAPI PathCchIsRoot(const WCHAR *path){ const WCHAR *root_end; const WCHAR *next; BOOL is_unc;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return FALSE;
root_end = get_root_end(path); if (!root_end) return FALSE;
if ((is_unc = is_prefixed_unc(path)) || (path[0] == '\\' && path[1] == '\\' && path[2] != '?')) { next = root_end + 1; /* No extra segments */ if ((is_unc && !*next) || (!is_unc && !*next)) return TRUE;
/* Has first segment with an ending backslash but no remaining characters */ if (get_next_segment(next, &next) && !*next) return FALSE; /* Has first segment with no ending backslash */ else if (!*next) return TRUE; /* Has first segment with an ending backslash and has remaining characters*/ else { /* Second segment must have no backslash and no remaining characters */ return !get_next_segment(next, &next) && !*next; } } else if (*root_end == '\\' && !root_end[1]) return TRUE; else return FALSE;}
HRESULT WINAPI PathCchRemoveBackslash(WCHAR *path, SIZE_T path_size){ WCHAR *path_end; SIZE_T free_size;
TRACE("%s %Iu\n", debugstr_w(path), path_size);
return PathCchRemoveBackslashEx(path, path_size, &path_end, &free_size);}
HRESULT WINAPI PathCchRemoveBackslashEx(WCHAR *path, SIZE_T path_size, WCHAR **path_end, SIZE_T *free_size){ const WCHAR *root_end; SIZE_T path_length;
TRACE("%s %Iu %p %p\n", debugstr_w(path), path_size, path_end, free_size);
if (!path_size || !path_end || !free_size) { if (path_end) *path_end = NULL; if (free_size) *free_size = 0; return E_INVALIDARG; }
path_length = wcsnlen(path, path_size); if (path_length == path_size && !path[path_length]) return E_INVALIDARG;
root_end = get_root_end(path); if (path_length > 0 && path[path_length - 1] == '\\') { *path_end = path + path_length - 1; *free_size = path_size - path_length + 1; /* If the last character is beyond end of root */ if (!root_end || path + path_length - 1 > root_end) { path[path_length - 1] = 0; return S_OK; } else return S_FALSE; } else { *path_end = path + path_length; *free_size = path_size - path_length; return S_FALSE; }}
HRESULT WINAPI PathCchRemoveExtension(WCHAR *path, SIZE_T size){ const WCHAR *extension; WCHAR *next; HRESULT hr;
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
hr = PathCchFindExtension(path, size, &extension); if (FAILED(hr)) return hr;
next = path + (extension - path); while (next - path < size && *next) *next++ = 0;
return next == extension ? S_FALSE : S_OK;}
HRESULT WINAPI PathCchRemoveFileSpec(WCHAR *path, SIZE_T size){ WCHAR *last, *root_end;
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
if (FAILED(PathCchSkipRoot(path, (const WCHAR **)&root_end))) root_end = path;
/* The backslash at the end of UNC and \\* are not considered part of root in this case */ if (root_end > path && root_end[-1] == '\\' && ((is_prefixed_unc(path) && path[8]) || (path[0] == '\\' && path[1] == '\\' && path[2] && path[2] != '?'))) root_end--;
if (!(last = StrRChrW(root_end, NULL, '\\'))) last = root_end; if (last > root_end && last[-1] == '\\' && last[1] != '?') --last; if (last - path >= size) return E_INVALIDARG; if (!*last) return S_FALSE; *last = 0; return S_OK;}
HRESULT WINAPI PathCchRenameExtension(WCHAR *path, SIZE_T size, const WCHAR *extension){ HRESULT hr;
TRACE("%s %Iu %s\n", wine_dbgstr_w(path), size, wine_dbgstr_w(extension));
hr = PathCchRemoveExtension(path, size); if (FAILED(hr)) return hr;
hr = PathCchAddExtension(path, size, extension); return FAILED(hr) ? hr : S_OK;}
HRESULT WINAPI PathCchSkipRoot(const WCHAR *path, const WCHAR **root_end){ TRACE("%s %p\n", debugstr_w(path), root_end);
if (!path || !path[0] || !root_end || (!wcsnicmp(path, L"\\\\?", 3) && !is_prefixed_volume(path) && !is_prefixed_unc(path) && !is_prefixed_disk(path))) return E_INVALIDARG;
*root_end = get_root_end(path); if (*root_end) { (*root_end)++; if (is_prefixed_unc(path)) { get_next_segment(*root_end, root_end); get_next_segment(*root_end, root_end); } else if (path[0] == '\\' && path[1] == '\\' && path[2] != '?') { /* Skip share server */ get_next_segment(*root_end, root_end); /* If mount point is empty, don't skip over mount point */ if (**root_end != '\\') get_next_segment(*root_end, root_end); } }
return *root_end ? S_OK : E_INVALIDARG;}
HRESULT WINAPI PathCchStripPrefix(WCHAR *path, SIZE_T size){ TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
if (is_prefixed_unc(path)) { /* \\?\UNC\a -> \\a */ if (size < lstrlenW(path + 8) + 3) return E_INVALIDARG; lstrcpyW(path + 2, path + 8); return S_OK; } else if (is_prefixed_disk(path)) { /* \\?\C:\ -> C:\ */ if (size < lstrlenW(path + 4) + 1) return E_INVALIDARG; lstrcpyW(path, path + 4); return S_OK; } else return S_FALSE;}
HRESULT WINAPI PathCchStripToRoot(WCHAR *path, SIZE_T size){ const WCHAR *root_end; WCHAR *segment_end;
TRACE("%s %Iu\n", wine_dbgstr_w(path), size);
if (!path || !*path || !size || size > PATHCCH_MAX_CCH) return E_INVALIDARG;
if (PathCchSkipRoot(path, &root_end) == S_OK) { if (root_end && root_end > path && root_end[-1] == '\\' && ((is_prefixed_unc(path) && path[8]) || (path[0] == '\\' && path[1] == '\\' && path[2] && path[2] != '?'))) root_end--; if (root_end - path >= size) return E_INVALIDARG;
segment_end = path + (root_end - path); if (!*segment_end) return S_FALSE;
*segment_end = 0; return S_OK; } else { *path = 0; return E_INVALIDARG; }}
BOOL WINAPI PathIsUNCEx(const WCHAR *path, const WCHAR **server){ const WCHAR *result = NULL;
TRACE("%s %p\n", wine_dbgstr_w(path), server);
if (is_prefixed_unc(path)) result = path + 8; else if (path[0] == '\\' && path[1] == '\\' && path[2] != '?') result = path + 2;
if (server) *server = result; return !!result;}
#ifndef STATIC_PATHCCH/* Other functions not part of the PathCch library */
BOOL WINAPI PathIsUNCA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
return path && (path[0] == '\\') && (path[1] == '\\');}
BOOL WINAPI PathIsUNCW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
return path && (path[0] == '\\') && (path[1] == '\\');}
BOOL WINAPI PathIsRelativeA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (!path || !*path || IsDBCSLeadByte(*path)) return TRUE;
return !(*path == '\\' || (*path && path[1] == ':'));}
BOOL WINAPI PathIsRelativeW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return TRUE;
return !(*path == '\\' || (*path && path[1] == ':'));}
BOOL WINAPI PathIsUNCServerShareA(const char *path){ BOOL seen_slash = FALSE;
TRACE("%s\n", wine_dbgstr_a(path));
if (path && *path++ == '\\' && *path++ == '\\') { while (*path) { if (*path == '\\') { if (seen_slash) return FALSE; seen_slash = TRUE; }
path = CharNextA(path); } }
return seen_slash;}
BOOL WINAPI PathIsUNCServerShareW(const WCHAR *path){ BOOL seen_slash = FALSE;
TRACE("%s\n", wine_dbgstr_w(path));
if (path && *path++ == '\\' && *path++ == '\\') { while (*path) { if (*path == '\\') { if (seen_slash) return FALSE; seen_slash = TRUE; }
path++; } }
return seen_slash;}
BOOL WINAPI PathIsRootA(const char *path){ WCHAR pathW[MAX_PATH];
TRACE("%s\n", wine_dbgstr_a(path));
if (!MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, MAX_PATH)) return FALSE; if (is_prefixed_unc(pathW) || is_prefixed_disk(pathW) || is_prefixed_volume(pathW)) return FALSE;
return PathIsRootW(pathW);}
BOOL WINAPI PathIsRootW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
return PathCchIsRoot(path);}
BOOL WINAPI PathRemoveFileSpecA(char *path){ char *root_end = NULL, *ptr;
TRACE("%s\n", debugstr_a(path));
if (!path || !*path) return FALSE;
if (is_drive_specA(path)) { root_end = path + 2; if (*root_end == '\\') ++root_end; } else { root_end = path; if (*root_end == '\\') ++root_end; if (root_end[1] != '?') { if (*root_end == '\\') ++root_end; if (root_end - path > 1 && is_drive_specA(root_end)) root_end += 2; if (*root_end == '\\' && root_end[1] && root_end[1] != '\\') ++root_end; } } ptr = StrRChrA(root_end, NULL, '\\'); if (ptr && ptr != root_end) { if (ptr[-1] == '\\') --ptr; *ptr = 0; return TRUE; } if (!*root_end) return FALSE; *root_end = 0; return TRUE;}
BOOL WINAPI PathRemoveFileSpecW(WCHAR *path){ WCHAR *root_end = NULL, *ptr;
TRACE("%s\n", debugstr_w(path));
if (!path || !*path) return FALSE;
if (is_prefixed_volume(path)) root_end = path + 48; else if (is_prefixed_disk(path)) root_end = path + 6; else if (is_drive_spec(path)) root_end = path + 2; if (!root_end) { root_end = path; if (*root_end == '\\') ++root_end; if (root_end[1] != '?') { if (*root_end == '\\') ++root_end; if (root_end - path > 1 && is_drive_spec(root_end)) root_end += 2; if (*root_end == '\\' && root_end[1] && root_end[1] != '\\') ++root_end; } } else if (*root_end == '\\') ++root_end; ptr = StrRChrW(root_end, NULL, '\\'); if (ptr && ptr != root_end) { if (ptr[-1] == '\\') --ptr; *ptr = 0; return TRUE; } if (!*root_end) return FALSE; *root_end = 0; return TRUE;}
BOOL WINAPI PathStripToRootA(char *path){ WCHAR pathW[MAX_PATH];
TRACE("%s\n", wine_dbgstr_a(path));
if (!MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, MAX_PATH)) return FALSE;
*path = 0; if (is_prefixed_unc(pathW) || is_prefixed_disk(pathW) || is_prefixed_volume(pathW)) return FALSE; if (!PathStripToRootW(pathW)) return FALSE; return !!WideCharToMultiByte(CP_ACP, 0, pathW, -1, path, MAX_PATH, 0, 0);}
BOOL WINAPI PathStripToRootW(WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
return SUCCEEDED(PathCchStripToRoot(path, PATHCCH_MAX_CCH));}
LPSTR WINAPI PathAddBackslashA(char *path){ unsigned int len; char *prev = path;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path || (len = strlen(path)) >= MAX_PATH) return NULL;
if (len) { do { path = CharNextA(prev); if (*path) prev = path; } while (*path);
if (*prev != '\\') { *path++ = '\\'; *path = '\0'; } }
return path;}
LPWSTR WINAPI PathAddBackslashW(WCHAR *path){ unsigned int len;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || (len = lstrlenW(path)) >= MAX_PATH) return NULL;
if (len) { path += len; if (path[-1] != '\\') { *path++ = '\\'; *path = '\0'; } }
return path;}
LPSTR WINAPI PathFindExtensionA(const char *path){ const char *lastpoint = NULL;
TRACE("%s\n", wine_dbgstr_a(path));
if (path) { while (*path) { if (*path == '\\' || *path == ' ') lastpoint = NULL; else if (*path == '.') lastpoint = path; path = CharNextA(path); } }
return (LPSTR)(lastpoint ? lastpoint : path);}
LPWSTR WINAPI PathFindExtensionW(const WCHAR *path){ const WCHAR *lastpoint = NULL;
TRACE("%s\n", wine_dbgstr_w(path));
if (path) { while (*path) { if (*path == '\\' || *path == ' ') lastpoint = NULL; else if (*path == '.') lastpoint = path; path++; } }
return (LPWSTR)(lastpoint ? lastpoint : path);}
BOOL WINAPI PathAddExtensionA(char *path, const char *ext){ unsigned int len;
TRACE("%s, %s\n", wine_dbgstr_a(path), wine_dbgstr_a(ext));
if (!path || !ext || *(PathFindExtensionA(path))) return FALSE;
len = strlen(path); if (len + strlen(ext) >= MAX_PATH) return FALSE;
strcpy(path + len, ext); return TRUE;}
BOOL WINAPI PathAddExtensionW(WCHAR *path, const WCHAR *ext){ unsigned int len;
TRACE("%s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(ext));
if (!path || !ext || *(PathFindExtensionW(path))) return FALSE;
len = lstrlenW(path); if (len + lstrlenW(ext) >= MAX_PATH) return FALSE;
lstrcpyW(path + len, ext); return TRUE;}
BOOL WINAPI PathCanonicalizeW(WCHAR *buffer, const WCHAR *path){ const WCHAR *src = path; WCHAR *dst = buffer;
TRACE("%p, %s\n", buffer, wine_dbgstr_w(path));
if (dst) *dst = '\0';
if (!dst || !path) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
if (!*path) { *buffer++ = '\\'; *buffer = '\0'; return TRUE; }
/* Copy path root */ if (*src == '\\') { *dst++ = *src++; } else if (*src && src[1] == ':') { /* X:\ */ *dst++ = *src++; *dst++ = *src++; if (*src == '\\') *dst++ = *src++; }
/* Canonicalize the rest of the path */ while (*src) { if (*src == '.') { if (src[1] == '\\' && (src == path || src[-1] == '\\' || src[-1] == ':')) { src += 2; /* Skip .\ */ } else if (src[1] == '.' && dst != buffer && dst[-1] == '\\') { /* \.. backs up a directory, over the root if it has no \ following X:. * .. is ignored if it would remove a UNC server name or initial \\ */ if (dst != buffer) { *dst = '\0'; /* Allow PathIsUNCServerShareA test on lpszBuf */ if (dst > buffer + 1 && dst[-1] == '\\' && (dst[-2] != '\\' || dst > buffer + 2)) { if (dst[-2] == ':' && (dst > buffer + 3 || dst[-3] == ':')) { dst -= 2; while (dst > buffer && *dst != '\\') dst--; if (*dst == '\\') dst++; /* Reset to last '\' */ else dst = buffer; /* Start path again from new root */ } else if (dst[-2] != ':' && !PathIsUNCServerShareW(buffer)) dst -= 2; } while (dst > buffer && *dst != '\\') dst--; if (dst == buffer) { *dst++ = '\\'; src++; } } src += 2; /* Skip .. in src path */ } else *dst++ = *src++; } else *dst++ = *src++; }
/* Append \ to naked drive specs */ if (dst - buffer == 2 && dst[-1] == ':') *dst++ = '\\'; *dst++ = '\0'; return TRUE;}
BOOL WINAPI PathCanonicalizeA(char *buffer, const char *path){ WCHAR pathW[MAX_PATH], bufferW[MAX_PATH]; BOOL ret; int len;
TRACE("%p, %s\n", buffer, wine_dbgstr_a(path));
if (buffer) *buffer = '\0';
if (!buffer || !path) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; }
len = MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, ARRAY_SIZE(pathW)); if (!len) return FALSE;
ret = PathCanonicalizeW(bufferW, pathW); WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, 0, 0);
return ret;}
WCHAR * WINAPI PathCombineW(WCHAR *dst, const WCHAR *dir, const WCHAR *file){ BOOL use_both = FALSE, strip = FALSE; WCHAR tmp[MAX_PATH];
TRACE("%p, %s, %s\n", dst, wine_dbgstr_w(dir), wine_dbgstr_w(file));
/* Invalid parameters */ if (!dst) return NULL;
if (!dir && !file) { dst[0] = 0; return NULL; }
if ((!file || !*file) && dir) { /* Use dir only */ lstrcpynW(tmp, dir, ARRAY_SIZE(tmp)); } else if (!dir || !*dir || !PathIsRelativeW(file)) { if (!dir || !*dir || *file != '\\' || PathIsUNCW(file)) { /* Use file only */ lstrcpynW(tmp, file, ARRAY_SIZE(tmp)); } else { use_both = TRUE; strip = TRUE; } } else use_both = TRUE;
if (use_both) { lstrcpynW(tmp, dir, ARRAY_SIZE(tmp)); if (strip) { PathStripToRootW(tmp); file++; /* Skip '\' */ }
if (!PathAddBackslashW(tmp) || lstrlenW(tmp) + lstrlenW(file) >= MAX_PATH) { dst[0] = 0; return NULL; }
lstrcatW(tmp, file); }
PathCanonicalizeW(dst, tmp); return dst;}
LPSTR WINAPI PathCombineA(char *dst, const char *dir, const char *file){ WCHAR dstW[MAX_PATH], dirW[MAX_PATH], fileW[MAX_PATH];
TRACE("%p, %s, %s\n", dst, wine_dbgstr_a(dir), wine_dbgstr_a(file));
/* Invalid parameters */ if (!dst) return NULL;
if (!dir && !file) goto fail;
if (dir && !MultiByteToWideChar(CP_ACP, 0, dir, -1, dirW, ARRAY_SIZE(dirW))) goto fail;
if (file && !MultiByteToWideChar(CP_ACP, 0, file, -1, fileW, ARRAY_SIZE(fileW))) goto fail;
if (PathCombineW(dstW, dir ? dirW : NULL, file ? fileW : NULL)) if (WideCharToMultiByte(CP_ACP, 0, dstW, -1, dst, MAX_PATH, 0, 0)) return dst;fail: dst[0] = 0; return NULL;}
BOOL WINAPI PathAppendA(char *path, const char *append){ TRACE("%s, %s\n", wine_dbgstr_a(path), wine_dbgstr_a(append));
if (path && append) { if (!PathIsUNCA(append)) while (*append == '\\') append++;
if (PathCombineA(path, path, append)) return TRUE; }
return FALSE;}
BOOL WINAPI PathAppendW(WCHAR *path, const WCHAR *append){ TRACE("%s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(append));
if (path && append) { if (!PathIsUNCW(append)) while (*append == '\\') append++;
if (PathCombineW(path, path, append)) return TRUE; }
return FALSE;}
int WINAPI PathCommonPrefixA(const char *file1, const char *file2, char *path){ const char *iter1 = file1; const char *iter2 = file2; unsigned int len = 0;
TRACE("%s, %s, %p.\n", wine_dbgstr_a(file1), wine_dbgstr_a(file2), path);
if (path) *path = '\0';
if (!file1 || !file2) return 0;
/* Handle roots first */ if (PathIsUNCA(file1)) { if (!PathIsUNCA(file2)) return 0; iter1 += 2; iter2 += 2; } else if (PathIsUNCA(file2)) return 0;
for (;;) { /* Update len */ if ((!*iter1 || *iter1 == '\\') && (!*iter2 || *iter2 == '\\')) len = iter1 - file1; /* Common to this point */
if (!*iter1 || (tolower(*iter1) != tolower(*iter2))) break; /* Strings differ at this point */
iter1++; iter2++; }
if (len == 2) len++; /* Feature/Bug compatible with Win32 */
if (len && path) { memcpy(path, file1, len); path[len] = '\0'; }
return len;}
int WINAPI PathCommonPrefixW(const WCHAR *file1, const WCHAR *file2, WCHAR *path){ const WCHAR *iter1 = file1; const WCHAR *iter2 = file2; unsigned int len = 0;
TRACE("%s, %s, %p\n", wine_dbgstr_w(file1), wine_dbgstr_w(file2), path);
if (path) *path = '\0';
if (!file1 || !file2) return 0;
/* Handle roots first */ if (PathIsUNCW(file1)) { if (!PathIsUNCW(file2)) return 0; iter1 += 2; iter2 += 2; } else if (PathIsUNCW(file2)) return 0;
for (;;) { /* Update len */ if ((!*iter1 || *iter1 == '\\') && (!*iter2 || *iter2 == '\\')) len = iter1 - file1; /* Common to this point */
if (!*iter1 || (towupper(*iter1) != towupper(*iter2))) break; /* Strings differ at this point */
iter1++; iter2++; }
if (len == 2) len++; /* Feature/Bug compatible with Win32 */
if (len && path) { memcpy(path, file1, len * sizeof(WCHAR)); path[len] = '\0'; }
return len;}
BOOL WINAPI PathIsPrefixA(const char *prefix, const char *path){ TRACE("%s, %s\n", wine_dbgstr_a(prefix), wine_dbgstr_a(path));
return prefix && path && PathCommonPrefixA(path, prefix, NULL) == (int)strlen(prefix);}
BOOL WINAPI PathIsPrefixW(const WCHAR *prefix, const WCHAR *path){ TRACE("%s, %s\n", wine_dbgstr_w(prefix), wine_dbgstr_w(path));
return prefix && path && PathCommonPrefixW(path, prefix, NULL) == (int)lstrlenW(prefix);}
char * WINAPI PathFindFileNameA(const char *path){ const char *last_slash = path;
TRACE("%s\n", wine_dbgstr_a(path));
while (path && *path) { if ((*path == '\\' || *path == '/' || *path == ':') && path[1] && path[1] != '\\' && path[1] != '/') last_slash = path + 1; path = CharNextA(path); }
return (char *)last_slash;}
WCHAR * WINAPI PathFindFileNameW(const WCHAR *path){ const WCHAR *last_slash = path;
TRACE("%s\n", wine_dbgstr_w(path));
while (path && *path) { if ((*path == '\\' || *path == '/' || *path == ':') && path[1] && path[1] != '\\' && path[1] != '/') last_slash = path + 1; path++; }
return (WCHAR *)last_slash;}
char * WINAPI PathGetArgsA(const char *path){ BOOL seen_quote = FALSE;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return NULL;
while (*path) { if (*path == ' ' && !seen_quote) return (char *)path + 1;
if (*path == '"') seen_quote = !seen_quote; path = CharNextA(path); }
return (char *)path;}
WCHAR * WINAPI PathGetArgsW(const WCHAR *path){ BOOL seen_quote = FALSE;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return NULL;
while (*path) { if (*path == ' ' && !seen_quote) return (WCHAR *)path + 1;
if (*path == '"') seen_quote = !seen_quote; path++; }
return (WCHAR *)path;}
UINT WINAPI PathGetCharTypeW(WCHAR ch){ UINT flags = 0;
TRACE("%#x\n", ch);
if (!ch || ch < ' ' || ch == '<' || ch == '>' || ch == '"' || ch == '|' || ch == '/') flags = GCT_INVALID; /* Invalid */ else if (ch == '*' || ch == '?') flags = GCT_WILD; /* Wildchars */ else if (ch == '\\' || ch == ':') return GCT_SEPARATOR; /* Path separators */ else { if (ch < 126) { if (((ch & 0x1) && ch != ';') || !ch || iswalnum(ch) || ch == '$' || ch == '&' || ch == '(' || ch == '.' || ch == '@' || ch == '^' || ch == '\'' || ch == '`') { flags |= GCT_SHORTCHAR; /* All these are valid for DOS */ } } else flags |= GCT_SHORTCHAR; /* Bug compatible with win32 */
flags |= GCT_LFNCHAR; /* Valid for long file names */ }
return flags;}
UINT WINAPI PathGetCharTypeA(UCHAR ch){ return PathGetCharTypeW(ch);}
int WINAPI PathGetDriveNumberA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (path && *path && path[1] == ':') { if (*path >= 'a' && *path <= 'z') return *path - 'a'; if (*path >= 'A' && *path <= 'Z') return *path - 'A'; } return -1;}
int WINAPI PathGetDriveNumberW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return -1;
if (!wcsncmp(path, L"\\\\?\\", 4)) path += 4;
if (!path[0] || path[1] != ':') return -1; if (path[0] >= 'A' && path[0] <= 'Z') return path[0] - 'A'; if (path[0] >= 'a' && path[0] <= 'z') return path[0] - 'a'; return -1;}
BOOL WINAPI PathIsFileSpecA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return FALSE;
while (*path) { if (*path == '\\' || *path == ':') return FALSE; path = CharNextA(path); }
return TRUE;}
BOOL WINAPI PathIsFileSpecW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return FALSE;
while (*path) { if (*path == '\\' || *path == ':') return FALSE; path++; }
return TRUE;}
BOOL WINAPI PathIsUNCServerA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (!(path && path[0] == '\\' && path[1] == '\\')) return FALSE;
while (*path) { if (*path == '\\') return FALSE; path = CharNextA(path); }
return TRUE;}
BOOL WINAPI PathIsUNCServerW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!(path && path[0] == '\\' && path[1] == '\\')) return FALSE;
return !wcschr(path + 2, '\\');}
void WINAPI PathRemoveBlanksA(char *path){ char *start, *first;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path || !*path) return;
start = first = path;
while (*path == ' ') path = CharNextA(path);
while (*path) *start++ = *path++;
if (start != first) while (start[-1] == ' ') start--;
*start = '\0';}
void WINAPI PathRemoveBlanksW(WCHAR *path){ WCHAR *start, *first;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return;
start = first = path;
while (*path == ' ') path++;
while (*path) *start++ = *path++;
if (start != first) while (start[-1] == ' ') start--;
*start = '\0';}
void WINAPI PathRemoveExtensionA(char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return;
path = PathFindExtensionA(path); if (path && *path) *path = '\0';}
void WINAPI PathRemoveExtensionW(WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return;
path = PathFindExtensionW(path); if (path && *path) *path = '\0';}
BOOL WINAPI PathRenameExtensionA(char *path, const char *ext){ char *extension;
TRACE("%s, %s\n", wine_dbgstr_a(path), wine_dbgstr_a(ext));
extension = PathFindExtensionA(path);
if (!extension || (extension - path + strlen(ext) >= MAX_PATH)) return FALSE;
strcpy(extension, ext); return TRUE;}
BOOL WINAPI PathRenameExtensionW(WCHAR *path, const WCHAR *ext){ WCHAR *extension;
TRACE("%s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(ext));
extension = PathFindExtensionW(path);
if (!extension || (extension - path + lstrlenW(ext) >= MAX_PATH)) return FALSE;
lstrcpyW(extension, ext); return TRUE;}
void WINAPI PathUnquoteSpacesA(char *path){ unsigned int len;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path || *path != '"') return;
len = strlen(path) - 1; if (path[len] == '"') { path[len] = '\0'; for (; *path; path++) *path = path[1]; }}
void WINAPI PathUnquoteSpacesW(WCHAR *path){ unsigned int len;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || *path != '"') return;
len = lstrlenW(path) - 1; if (path[len] == '"') { path[len] = '\0'; for (; *path; path++) *path = path[1]; }}
char * WINAPI PathRemoveBackslashA(char *path){ char *ptr;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return NULL;
ptr = CharPrevA(path, path + strlen(path)); if (!PathIsRootA(path) && *ptr == '\\') *ptr = '\0';
return ptr;}
WCHAR * WINAPI PathRemoveBackslashW(WCHAR *path){ WCHAR *ptr;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return NULL;
ptr = path + lstrlenW(path); if (ptr > path) ptr--; if (!PathIsRootW(path) && *ptr == '\\') *ptr = '\0';
return ptr;}
BOOL WINAPI PathIsLFNFileSpecA(const char *path){ unsigned int name_len = 0, ext_len = 0;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return FALSE;
while (*path) { if (*path == ' ') return TRUE; /* DOS names cannot have spaces */ if (*path == '.') { if (ext_len) return TRUE; /* DOS names have only one dot */ ext_len = 1; } else if (ext_len) { ext_len++; if (ext_len > 4) return TRUE; /* DOS extensions are <= 3 chars*/ } else { name_len++; if (name_len > 8) return TRUE; /* DOS names are <= 8 chars */ } path = CharNextA(path); }
return FALSE; /* Valid DOS path */}
BOOL WINAPI PathIsLFNFileSpecW(const WCHAR *path){ unsigned int name_len = 0, ext_len = 0;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return FALSE;
while (*path) { if (*path == ' ') return TRUE; /* DOS names cannot have spaces */ if (*path == '.') { if (ext_len) return TRUE; /* DOS names have only one dot */ ext_len = 1; } else if (ext_len) { ext_len++; if (ext_len > 4) return TRUE; /* DOS extensions are <= 3 chars*/ } else { name_len++; if (name_len > 8) return TRUE; /* DOS names are <= 8 chars */ } path++; }
return FALSE; /* Valid DOS path */}
#define PATH_CHAR_CLASS_LETTER 0x00000001#define PATH_CHAR_CLASS_ASTERIX 0x00000002#define PATH_CHAR_CLASS_DOT 0x00000004#define PATH_CHAR_CLASS_BACKSLASH 0x00000008#define PATH_CHAR_CLASS_COLON 0x00000010#define PATH_CHAR_CLASS_SEMICOLON 0x00000020#define PATH_CHAR_CLASS_COMMA 0x00000040#define PATH_CHAR_CLASS_SPACE 0x00000080#define PATH_CHAR_CLASS_OTHER_VALID 0x00000100#define PATH_CHAR_CLASS_DOUBLEQUOTE 0x00000200
#define PATH_CHAR_CLASS_INVALID 0x00000000#define PATH_CHAR_CLASS_ANY 0xffffffff
static const DWORD path_charclass[] ={ /* 0x00 */ PATH_CHAR_CLASS_INVALID, /* 0x01 */ PATH_CHAR_CLASS_INVALID, /* 0x02 */ PATH_CHAR_CLASS_INVALID, /* 0x03 */ PATH_CHAR_CLASS_INVALID, /* 0x04 */ PATH_CHAR_CLASS_INVALID, /* 0x05 */ PATH_CHAR_CLASS_INVALID, /* 0x06 */ PATH_CHAR_CLASS_INVALID, /* 0x07 */ PATH_CHAR_CLASS_INVALID, /* 0x08 */ PATH_CHAR_CLASS_INVALID, /* 0x09 */ PATH_CHAR_CLASS_INVALID, /* 0x0a */ PATH_CHAR_CLASS_INVALID, /* 0x0b */ PATH_CHAR_CLASS_INVALID, /* 0x0c */ PATH_CHAR_CLASS_INVALID, /* 0x0d */ PATH_CHAR_CLASS_INVALID, /* 0x0e */ PATH_CHAR_CLASS_INVALID, /* 0x0f */ PATH_CHAR_CLASS_INVALID, /* 0x10 */ PATH_CHAR_CLASS_INVALID, /* 0x11 */ PATH_CHAR_CLASS_INVALID, /* 0x12 */ PATH_CHAR_CLASS_INVALID, /* 0x13 */ PATH_CHAR_CLASS_INVALID, /* 0x14 */ PATH_CHAR_CLASS_INVALID, /* 0x15 */ PATH_CHAR_CLASS_INVALID, /* 0x16 */ PATH_CHAR_CLASS_INVALID, /* 0x17 */ PATH_CHAR_CLASS_INVALID, /* 0x18 */ PATH_CHAR_CLASS_INVALID, /* 0x19 */ PATH_CHAR_CLASS_INVALID, /* 0x1a */ PATH_CHAR_CLASS_INVALID, /* 0x1b */ PATH_CHAR_CLASS_INVALID, /* 0x1c */ PATH_CHAR_CLASS_INVALID, /* 0x1d */ PATH_CHAR_CLASS_INVALID, /* 0x1e */ PATH_CHAR_CLASS_INVALID, /* 0x1f */ PATH_CHAR_CLASS_INVALID, /* ' ' */ PATH_CHAR_CLASS_SPACE, /* '!' */ PATH_CHAR_CLASS_OTHER_VALID, /* '"' */ PATH_CHAR_CLASS_DOUBLEQUOTE, /* '#' */ PATH_CHAR_CLASS_OTHER_VALID, /* '$' */ PATH_CHAR_CLASS_OTHER_VALID, /* '%' */ PATH_CHAR_CLASS_OTHER_VALID, /* '&' */ PATH_CHAR_CLASS_OTHER_VALID, /* '\'' */ PATH_CHAR_CLASS_OTHER_VALID, /* '(' */ PATH_CHAR_CLASS_OTHER_VALID, /* ')' */ PATH_CHAR_CLASS_OTHER_VALID, /* '*' */ PATH_CHAR_CLASS_ASTERIX, /* '+' */ PATH_CHAR_CLASS_OTHER_VALID, /* ',' */ PATH_CHAR_CLASS_COMMA, /* '-' */ PATH_CHAR_CLASS_OTHER_VALID, /* '.' */ PATH_CHAR_CLASS_DOT, /* '/' */ PATH_CHAR_CLASS_INVALID, /* '0' */ PATH_CHAR_CLASS_OTHER_VALID, /* '1' */ PATH_CHAR_CLASS_OTHER_VALID, /* '2' */ PATH_CHAR_CLASS_OTHER_VALID, /* '3' */ PATH_CHAR_CLASS_OTHER_VALID, /* '4' */ PATH_CHAR_CLASS_OTHER_VALID, /* '5' */ PATH_CHAR_CLASS_OTHER_VALID, /* '6' */ PATH_CHAR_CLASS_OTHER_VALID, /* '7' */ PATH_CHAR_CLASS_OTHER_VALID, /* '8' */ PATH_CHAR_CLASS_OTHER_VALID, /* '9' */ PATH_CHAR_CLASS_OTHER_VALID, /* ':' */ PATH_CHAR_CLASS_COLON, /* ';' */ PATH_CHAR_CLASS_SEMICOLON, /* '<' */ PATH_CHAR_CLASS_INVALID, /* '=' */ PATH_CHAR_CLASS_OTHER_VALID, /* '>' */ PATH_CHAR_CLASS_INVALID, /* '?' */ PATH_CHAR_CLASS_LETTER, /* '@' */ PATH_CHAR_CLASS_OTHER_VALID, /* 'A' */ PATH_CHAR_CLASS_ANY, /* 'B' */ PATH_CHAR_CLASS_ANY, /* 'C' */ PATH_CHAR_CLASS_ANY, /* 'D' */ PATH_CHAR_CLASS_ANY, /* 'E' */ PATH_CHAR_CLASS_ANY, /* 'F' */ PATH_CHAR_CLASS_ANY, /* 'G' */ PATH_CHAR_CLASS_ANY, /* 'H' */ PATH_CHAR_CLASS_ANY, /* 'I' */ PATH_CHAR_CLASS_ANY, /* 'J' */ PATH_CHAR_CLASS_ANY, /* 'K' */ PATH_CHAR_CLASS_ANY, /* 'L' */ PATH_CHAR_CLASS_ANY, /* 'M' */ PATH_CHAR_CLASS_ANY, /* 'N' */ PATH_CHAR_CLASS_ANY, /* 'O' */ PATH_CHAR_CLASS_ANY, /* 'P' */ PATH_CHAR_CLASS_ANY, /* 'Q' */ PATH_CHAR_CLASS_ANY, /* 'R' */ PATH_CHAR_CLASS_ANY, /* 'S' */ PATH_CHAR_CLASS_ANY, /* 'T' */ PATH_CHAR_CLASS_ANY, /* 'U' */ PATH_CHAR_CLASS_ANY, /* 'V' */ PATH_CHAR_CLASS_ANY, /* 'W' */ PATH_CHAR_CLASS_ANY, /* 'X' */ PATH_CHAR_CLASS_ANY, /* 'Y' */ PATH_CHAR_CLASS_ANY, /* 'Z' */ PATH_CHAR_CLASS_ANY, /* '[' */ PATH_CHAR_CLASS_OTHER_VALID, /* '\\' */ PATH_CHAR_CLASS_BACKSLASH, /* ']' */ PATH_CHAR_CLASS_OTHER_VALID, /* '^' */ PATH_CHAR_CLASS_OTHER_VALID, /* '_' */ PATH_CHAR_CLASS_OTHER_VALID, /* '`' */ PATH_CHAR_CLASS_OTHER_VALID, /* 'a' */ PATH_CHAR_CLASS_ANY, /* 'b' */ PATH_CHAR_CLASS_ANY, /* 'c' */ PATH_CHAR_CLASS_ANY, /* 'd' */ PATH_CHAR_CLASS_ANY, /* 'e' */ PATH_CHAR_CLASS_ANY, /* 'f' */ PATH_CHAR_CLASS_ANY, /* 'g' */ PATH_CHAR_CLASS_ANY, /* 'h' */ PATH_CHAR_CLASS_ANY, /* 'i' */ PATH_CHAR_CLASS_ANY, /* 'j' */ PATH_CHAR_CLASS_ANY, /* 'k' */ PATH_CHAR_CLASS_ANY, /* 'l' */ PATH_CHAR_CLASS_ANY, /* 'm' */ PATH_CHAR_CLASS_ANY, /* 'n' */ PATH_CHAR_CLASS_ANY, /* 'o' */ PATH_CHAR_CLASS_ANY, /* 'p' */ PATH_CHAR_CLASS_ANY, /* 'q' */ PATH_CHAR_CLASS_ANY, /* 'r' */ PATH_CHAR_CLASS_ANY, /* 's' */ PATH_CHAR_CLASS_ANY, /* 't' */ PATH_CHAR_CLASS_ANY, /* 'u' */ PATH_CHAR_CLASS_ANY, /* 'v' */ PATH_CHAR_CLASS_ANY, /* 'w' */ PATH_CHAR_CLASS_ANY, /* 'x' */ PATH_CHAR_CLASS_ANY, /* 'y' */ PATH_CHAR_CLASS_ANY, /* 'z' */ PATH_CHAR_CLASS_ANY, /* '{' */ PATH_CHAR_CLASS_OTHER_VALID, /* '|' */ PATH_CHAR_CLASS_INVALID, /* '}' */ PATH_CHAR_CLASS_OTHER_VALID, /* '~' */ PATH_CHAR_CLASS_OTHER_VALID};
BOOL WINAPI PathIsValidCharA(char c, DWORD class){ if ((unsigned)c > 0x7e) return class & PATH_CHAR_CLASS_OTHER_VALID;
return class & path_charclass[(unsigned)c];}
BOOL WINAPI PathIsValidCharW(WCHAR c, DWORD class){ if (c > 0x7e) return class & PATH_CHAR_CLASS_OTHER_VALID;
return class & path_charclass[c];}
char * WINAPI PathFindNextComponentA(const char *path){ char *slash;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path || !*path) return NULL;
if ((slash = StrChrA(path, '\\'))) { if (slash[1] == '\\') slash++; return slash + 1; }
return (char *)path + strlen(path);}
WCHAR * WINAPI PathFindNextComponentW(const WCHAR *path){ WCHAR *slash;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return NULL;
if ((slash = StrChrW(path, '\\'))) { if (slash[1] == '\\') slash++; return slash + 1; }
return (WCHAR *)path + lstrlenW(path);}
char * WINAPI PathSkipRootA(const char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (!path || !*path) return NULL;
if (*path == '\\' && path[1] == '\\') { /* Network share: skip share server and mount point */ path += 2; if ((path = StrChrA(path, '\\')) && (path = StrChrA(path + 1, '\\'))) path++; return (char *)path; }
if (IsDBCSLeadByte(*path)) return NULL;
/* Check x:\ */ if (path[0] && path[1] == ':' && path[2] == '\\') return (char *)path + 3;
return NULL;}
WCHAR * WINAPI PathSkipRootW(const WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return NULL;
if (*path == '\\' && path[1] == '\\') { /* Network share: skip share server and mount point */ path += 2; if ((path = StrChrW(path, '\\')) && (path = StrChrW(path + 1, '\\'))) path++; return (WCHAR *)path; }
/* Check x:\ */ if (path[0] && path[1] == ':' && path[2] == '\\') return (WCHAR *)path + 3;
return NULL;}
void WINAPI PathStripPathA(char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (path) { char *filename = PathFindFileNameA(path); if (filename != path) RtlMoveMemory(path, filename, strlen(filename) + 1); }}
void WINAPI PathStripPathW(WCHAR *path){ WCHAR *filename;
TRACE("%s\n", wine_dbgstr_w(path)); filename = PathFindFileNameW(path); if (filename != path) RtlMoveMemory(path, filename, (lstrlenW(filename) + 1) * sizeof(WCHAR));}
BOOL WINAPI PathSearchAndQualifyA(const char *path, char *buffer, UINT length){ TRACE("%s, %p, %u\n", wine_dbgstr_a(path), buffer, length);
if (SearchPathA(NULL, path, NULL, length, buffer, NULL)) return TRUE;
return !!GetFullPathNameA(path, length, buffer, NULL);}
BOOL WINAPI PathSearchAndQualifyW(const WCHAR *path, WCHAR *buffer, UINT length){ TRACE("%s, %p, %u\n", wine_dbgstr_w(path), buffer, length);
if (SearchPathW(NULL, path, NULL, length, buffer, NULL)) return TRUE; return !!GetFullPathNameW(path, length, buffer, NULL);}
BOOL WINAPI PathRelativePathToA(char *path, const char *from, DWORD attributes_from, const char *to, DWORD attributes_to){ WCHAR pathW[MAX_PATH], fromW[MAX_PATH], toW[MAX_PATH]; BOOL ret;
TRACE("%p, %s, %#lx, %s, %#lx\n", path, wine_dbgstr_a(from), attributes_from, wine_dbgstr_a(to), attributes_to);
if (!path || !from || !to) return FALSE;
MultiByteToWideChar(CP_ACP, 0, from, -1, fromW, ARRAY_SIZE(fromW)); MultiByteToWideChar(CP_ACP, 0, to, -1, toW, ARRAY_SIZE(toW)); ret = PathRelativePathToW(pathW, fromW, attributes_from, toW, attributes_to); WideCharToMultiByte(CP_ACP, 0, pathW, -1, path, MAX_PATH, 0, 0);
return ret;}
BOOL WINAPI PathRelativePathToW(WCHAR *path, const WCHAR *from, DWORD attributes_from, const WCHAR *to, DWORD attributes_to){ WCHAR fromW[MAX_PATH], toW[MAX_PATH]; DWORD len;
TRACE("%p, %s, %#lx, %s, %#lx\n", path, wine_dbgstr_w(from), attributes_from, wine_dbgstr_w(to), attributes_to);
if (!path || !from || !to) return FALSE;
*path = '\0'; lstrcpynW(fromW, from, ARRAY_SIZE(fromW)); lstrcpynW(toW, to, ARRAY_SIZE(toW));
if (!(attributes_from & FILE_ATTRIBUTE_DIRECTORY)) PathRemoveFileSpecW(fromW); if (!(attributes_to & FILE_ATTRIBUTE_DIRECTORY)) PathRemoveFileSpecW(toW);
/* Paths can only be relative if they have a common root */ if (!(len = PathCommonPrefixW(fromW, toW, 0))) return FALSE;
/* Strip off 'from' components to the root, by adding "..\" */ from = fromW + len; if (!*from) { path[0] = '.'; path[1] = '\0'; } if (*from == '\\') from++;
while (*from) { from = PathFindNextComponentW(from); lstrcatW(path, *from ? L"..\\" : L".."); }
/* From the root add the components of 'to' */ to += len; /* We check to[-1] to avoid skipping end of string. See the notes for this function. */ if (*to && to[-1]) { if (*to != '\\') to--; len = lstrlenW(path); if (len + lstrlenW(to) >= MAX_PATH) { *path = '\0'; return FALSE; } lstrcpyW(path + len, to); }
return TRUE;}
HRESULT WINAPI PathMatchSpecExA(const char *path, const char *mask, DWORD flags){ WCHAR *pathW, *maskW; HRESULT ret;
TRACE("%s, %s\n", wine_dbgstr_a(path), wine_dbgstr_a(mask));
if (flags) FIXME("Ignoring flags %#lx.\n", flags);
if (!lstrcmpA(mask, "*.*")) return S_OK; /* Matches every path */
pathW = heap_strdupAtoW( path ); maskW = heap_strdupAtoW( mask ); ret = PathMatchSpecExW( pathW, maskW, flags ); heap_free( pathW ); heap_free( maskW ); return ret;}
BOOL WINAPI PathMatchSpecA(const char *path, const char *mask){ return PathMatchSpecExA(path, mask, 0) == S_OK;}
static BOOL path_match_maskW(const WCHAR *name, const WCHAR *mask){ while (*name && *mask && *mask != ';') { if (*mask == '*') { do { if (path_match_maskW(name, mask + 1)) return TRUE; /* try substrings */ } while (*name++); return FALSE; }
if (towupper(*mask) != towupper(*name) && *mask != '?') return FALSE;
name++; mask++; }
if (!*name) { while (*mask == '*') mask++; if (!*mask || *mask == ';') return TRUE; }
return FALSE;}
HRESULT WINAPI PathMatchSpecExW(const WCHAR *path, const WCHAR *mask, DWORD flags){ TRACE("%s, %s\n", wine_dbgstr_w(path), wine_dbgstr_w(mask));
if (flags) FIXME("Ignoring flags %#lx.\n", flags);
if (!lstrcmpW(mask, L"*.*")) return S_OK; /* Matches every path */
while (*mask) { while (*mask == ' ') mask++; /* Eat leading spaces */
if (path_match_maskW(path, mask)) return S_OK; /* Matches the current path */
while (*mask && *mask != ';') mask++; /* masks separated by ';' */
if (*mask == ';') mask++; }
return S_FALSE;}
BOOL WINAPI PathMatchSpecW(const WCHAR *path, const WCHAR *mask){ return PathMatchSpecExW(path, mask, 0) == S_OK;}
void WINAPI PathQuoteSpacesA(char *path){ TRACE("%s\n", wine_dbgstr_a(path));
if (path && StrChrA(path, ' ')) { size_t len = strlen(path) + 1;
if (len + 2 < MAX_PATH) { memmove(path + 1, path, len); path[0] = '"'; path[len] = '"'; path[len + 1] = '\0'; } }}
void WINAPI PathQuoteSpacesW(WCHAR *path){ TRACE("%s\n", wine_dbgstr_w(path));
if (path && StrChrW(path, ' ')) { int len = lstrlenW(path) + 1;
if (len + 2 < MAX_PATH) { memmove(path + 1, path, len * sizeof(WCHAR)); path[0] = '"'; path[len] = '"'; path[len + 1] = '\0'; } }}
BOOL WINAPI PathIsSameRootA(const char *path1, const char *path2){ const char *start; int len;
TRACE("%s, %s\n", wine_dbgstr_a(path1), wine_dbgstr_a(path2));
if (!path1 || !path2 || !(start = PathSkipRootA(path1))) return FALSE;
len = PathCommonPrefixA(path1, path2, NULL) + 1; return start - path1 <= len;}
BOOL WINAPI PathIsSameRootW(const WCHAR *path1, const WCHAR *path2){ const WCHAR *start; int len;
TRACE("%s, %s\n", wine_dbgstr_w(path1), wine_dbgstr_w(path2));
if (!path1 || !path2 || !(start = PathSkipRootW(path1))) return FALSE;
len = PathCommonPrefixW(path1, path2, NULL) + 1; return start - path1 <= len;}
BOOL WINAPI PathFileExistsA(const char *path){ UINT prev_mode; DWORD attrs;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path) return FALSE;
/* Prevent a dialog box if path is on a disk that has been ejected. */ prev_mode = SetErrorMode(SEM_FAILCRITICALERRORS); attrs = GetFileAttributesA(path); SetErrorMode(prev_mode); return attrs != INVALID_FILE_ATTRIBUTES;}
BOOL WINAPI PathFileExistsW(const WCHAR *path){ UINT prev_mode; DWORD attrs;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path) return FALSE;
prev_mode = SetErrorMode(SEM_FAILCRITICALERRORS); attrs = GetFileAttributesW(path); SetErrorMode(prev_mode); return attrs != INVALID_FILE_ATTRIBUTES;}
int WINAPI PathParseIconLocationA(char *path){ int ret = 0; char *comma;
TRACE("%s\n", debugstr_a(path));
if (!path) return 0;
if ((comma = strchr(path, ','))) { *comma++ = '\0'; ret = StrToIntA(comma); } PathUnquoteSpacesA(path); PathRemoveBlanksA(path);
return ret;}
int WINAPI PathParseIconLocationW(WCHAR *path){ WCHAR *comma; int ret = 0;
TRACE("%s\n", debugstr_w(path));
if (!path) return 0;
if ((comma = StrChrW(path, ','))) { *comma++ = '\0'; ret = StrToIntW(comma); } PathUnquoteSpacesW(path); PathRemoveBlanksW(path);
return ret;}
BOOL WINAPI PathUnExpandEnvStringsA(const char *path, char *buffer, UINT buf_len){ WCHAR bufferW[MAX_PATH], *pathW; DWORD len; BOOL ret;
TRACE("%s, %p, %d\n", debugstr_a(path), buffer, buf_len);
pathW = heap_strdupAtoW(path); if (!pathW) return FALSE;
ret = PathUnExpandEnvStringsW(pathW, bufferW, MAX_PATH); HeapFree(GetProcessHeap(), 0, pathW); if (!ret) return FALSE;
len = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL); if (buf_len < len + 1) return FALSE;
WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, buf_len, NULL, NULL); return TRUE;}
struct envvars_map{ const WCHAR *var; WCHAR path[MAX_PATH]; DWORD len;};
static void init_envvars_map(struct envvars_map *map){ while (map->var) { map->len = ExpandEnvironmentStringsW(map->var, map->path, ARRAY_SIZE(map->path)); /* exclude null from length */ if (map->len) map->len--; map++; }}
BOOL WINAPI PathUnExpandEnvStringsW(const WCHAR *path, WCHAR *buffer, UINT buf_len){ static struct envvars_map null_var = {L"", {0}, 0}; struct envvars_map *match = &null_var, *cur; struct envvars_map envvars[] = { { L"%ALLUSERSPROFILE%" }, { L"%APPDATA%" }, { L"%ProgramFiles%" }, { L"%SystemRoot%" }, { L"%SystemDrive%" }, { L"%USERPROFILE%" }, { NULL } }; DWORD pathlen; UINT needed;
TRACE("%s, %p, %d\n", debugstr_w(path), buffer, buf_len);
pathlen = lstrlenW(path); init_envvars_map(envvars); cur = envvars; while (cur->var) { /* path can't contain expanded value or value wasn't retrieved */ if (cur->len == 0 || cur->len > pathlen || CompareStringOrdinal( cur->path, cur->len, path, cur->len, TRUE ) != CSTR_EQUAL) { cur++; continue; }
if (cur->len > match->len) match = cur; cur++; }
needed = lstrlenW(match->var) + 1 + pathlen - match->len; if (match->len == 0 || needed > buf_len) return FALSE;
lstrcpyW(buffer, match->var); lstrcatW(buffer, &path[match->len]); TRACE("ret %s\n", debugstr_w(buffer));
return TRUE;}
static const struct{ URL_SCHEME scheme_number; const WCHAR *scheme_name;}url_schemes[] ={ { URL_SCHEME_FTP, L"ftp"}, { URL_SCHEME_HTTP, L"http"}, { URL_SCHEME_GOPHER, L"gopher"}, { URL_SCHEME_MAILTO, L"mailto"}, { URL_SCHEME_NEWS, L"news"}, { URL_SCHEME_NNTP, L"nntp"}, { URL_SCHEME_TELNET, L"telnet"}, { URL_SCHEME_WAIS, L"wais"}, { URL_SCHEME_FILE, L"file"}, { URL_SCHEME_MK, L"mk"}, { URL_SCHEME_HTTPS, L"https"}, { URL_SCHEME_SHELL, L"shell"}, { URL_SCHEME_SNEWS, L"snews"}, { URL_SCHEME_LOCAL, L"local"}, { URL_SCHEME_JAVASCRIPT, L"javascript"}, { URL_SCHEME_VBSCRIPT, L"vbscript"}, { URL_SCHEME_ABOUT, L"about"}, { URL_SCHEME_RES, L"res"},};
static const WCHAR *parse_scheme( const WCHAR *p ){ while (*p <= 0x7f && (iswalnum( *p ) || *p == '+' || *p == '-' || *p == '.')) ++p; return p;}
static DWORD get_scheme_code(const WCHAR *scheme, DWORD scheme_len){ unsigned int i;
for (i = 0; i < ARRAY_SIZE(url_schemes); ++i) { if (scheme_len == lstrlenW(url_schemes[i].scheme_name) && !wcsnicmp(scheme, url_schemes[i].scheme_name, scheme_len)) return url_schemes[i].scheme_number; }
return URL_SCHEME_UNKNOWN;}
HRESULT WINAPI ParseURLA(const char *url, PARSEDURLA *result){ WCHAR scheme[INTERNET_MAX_SCHEME_LENGTH]; const char *ptr = url; int len;
TRACE("%s, %p\n", wine_dbgstr_a(url), result);
if (result->cbSize != sizeof(*result)) return E_INVALIDARG;
while (*ptr && (isalnum( *ptr ) || *ptr == '-' || *ptr == '+' || *ptr == '.')) ptr++;
if (*ptr != ':' || ptr <= url + 1) { result->pszProtocol = NULL; return URL_E_INVALID_SYNTAX; }
result->pszProtocol = url; result->cchProtocol = ptr - url; result->pszSuffix = ptr + 1; result->cchSuffix = strlen(result->pszSuffix);
len = MultiByteToWideChar(CP_ACP, 0, url, ptr - url, scheme, ARRAY_SIZE(scheme)); result->nScheme = get_scheme_code(scheme, len);
return S_OK;}
HRESULT WINAPI ParseURLW(const WCHAR *url, PARSEDURLW *result){ const WCHAR *ptr = url;
TRACE("%s, %p\n", wine_dbgstr_w(url), result);
if (result->cbSize != sizeof(*result)) return E_INVALIDARG;
while (*ptr && (iswalnum(*ptr) || *ptr == '-' || *ptr == '+' || *ptr == '.')) ptr++;
if (*ptr != ':' || ptr <= url + 1) { result->pszProtocol = NULL; return URL_E_INVALID_SYNTAX; }
result->pszProtocol = url; result->cchProtocol = ptr - url; result->pszSuffix = ptr + 1; result->cchSuffix = lstrlenW(result->pszSuffix); result->nScheme = get_scheme_code(url, ptr - url);
return S_OK;}
HRESULT WINAPI UrlUnescapeA(char *url, char *unescaped, DWORD *unescaped_len, DWORD flags){ BOOL stop_unescaping = FALSE; const char *src; char *dst, next; DWORD needed; HRESULT hr;
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_a(url), unescaped, unescaped_len, flags);
if (!url) return E_INVALIDARG;
if (flags & URL_UNESCAPE_INPLACE) dst = url; else { if (!unescaped || !unescaped_len) return E_INVALIDARG; dst = unescaped; }
for (src = url, needed = 0; *src; src++, needed++) { if (flags & URL_DONT_UNESCAPE_EXTRA_INFO && (*src == '#' || *src == '?')) { stop_unescaping = TRUE; next = *src; } else if (*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2)) && !stop_unescaping) { INT ih; char buf[3]; memcpy(buf, src + 1, 2); buf[2] = '\0'; ih = strtol(buf, NULL, 16); next = (CHAR) ih; src += 2; /* Advance to end of escape */ } else next = *src;
if (flags & URL_UNESCAPE_INPLACE || needed < *unescaped_len) *dst++ = next; }
if (flags & URL_UNESCAPE_INPLACE || needed < *unescaped_len) { *dst = '\0'; hr = S_OK; } else { needed++; /* add one for the '\0' */ hr = E_POINTER; }
if (!(flags & URL_UNESCAPE_INPLACE)) *unescaped_len = needed;
if (hr == S_OK) TRACE("result %s\n", flags & URL_UNESCAPE_INPLACE ? wine_dbgstr_a(url) : wine_dbgstr_a(unescaped));
return hr;}
static int get_utf8_len(unsigned char code){ if (code < 0x80) return 1; else if ((code & 0xe0) == 0xc0) return 2; else if ((code & 0xf0) == 0xe0) return 3; else if ((code & 0xf8) == 0xf0) return 4; return 0;}
HRESULT WINAPI UrlUnescapeW(WCHAR *url, WCHAR *unescaped, DWORD *unescaped_len, DWORD flags){ WCHAR *dst, next, utf16_buf[4]; BOOL stop_unescaping = FALSE; int utf8_len, utf16_len, i; const WCHAR *src; char utf8_buf[4]; DWORD needed; HRESULT hr;
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(url), unescaped, unescaped_len, flags);
if (!url) return E_INVALIDARG;
if (flags & URL_UNESCAPE_INPLACE) dst = url; else { if (!unescaped || !unescaped_len) return E_INVALIDARG; dst = unescaped; }
for (src = url, needed = 0; *src; src++, needed++) { utf16_len = 0; if (flags & URL_DONT_UNESCAPE_EXTRA_INFO && (*src == '#' || *src == '?')) { stop_unescaping = TRUE; next = *src; } else if (*src == '%' && isxdigit(*(src + 1)) && isxdigit(*(src + 2)) && !stop_unescaping) { INT ih; WCHAR buf[5] = L"0x";
memcpy(buf + 2, src + 1, 2*sizeof(WCHAR)); buf[4] = 0; StrToIntExW(buf, STIF_SUPPORT_HEX, &ih); src += 2; /* Advance to end of escape */
if (flags & URL_UNESCAPE_AS_UTF8) { utf8_buf[0] = ih; utf8_len = get_utf8_len(ih); for (i = 1; i < utf8_len && *(src + 1) == '%' && *(src + 2) && *(src + 3); i++) { memcpy(buf + 2, src + 2, 2 * sizeof(WCHAR)); StrToIntExW(buf, STIF_SUPPORT_HEX, &ih); /* Check if it is a valid continuation byte. */ if ((ih & 0xc0) == 0x80) { utf8_buf[i] = ih; src += 3; } else break; }
utf16_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8_buf, i, utf16_buf, ARRAYSIZE(utf16_buf)); if (utf16_len) needed += utf16_len - 1; else next = 0xfffd; } else next = (WCHAR) ih; } else next = *src;
if (flags & URL_UNESCAPE_INPLACE || needed < *unescaped_len) { if (utf16_len) { memcpy(dst, utf16_buf, utf16_len * sizeof(*utf16_buf)); dst += utf16_len; } else *dst++ = next; } }
if (flags & URL_UNESCAPE_INPLACE || needed < *unescaped_len) { *dst = '\0'; hr = S_OK; } else { needed++; /* add one for the '\0' */ hr = E_POINTER; }
if (!(flags & URL_UNESCAPE_INPLACE)) *unescaped_len = needed;
if (hr == S_OK) TRACE("result %s\n", flags & URL_UNESCAPE_INPLACE ? wine_dbgstr_w(url) : wine_dbgstr_w(unescaped));
return hr;}
HRESULT WINAPI PathCreateFromUrlA(const char *pszUrl, char *pszPath, DWORD *pcchPath, DWORD dwReserved){ WCHAR bufW[MAX_PATH]; WCHAR *pathW = bufW; UNICODE_STRING urlW; HRESULT ret; DWORD lenW = ARRAY_SIZE(bufW), lenA;
if (!pszUrl || !pszPath || !pcchPath || !*pcchPath) return E_INVALIDARG;
if(!RtlCreateUnicodeStringFromAsciiz(&urlW, pszUrl)) return E_INVALIDARG; if((ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved)) == E_POINTER) { pathW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR)); ret = PathCreateFromUrlW(urlW.Buffer, pathW, &lenW, dwReserved); } if(ret == S_OK) { RtlUnicodeToMultiByteSize(&lenA, pathW, lenW * sizeof(WCHAR)); if(*pcchPath > lenA) { RtlUnicodeToMultiByteN(pszPath, *pcchPath - 1, &lenA, pathW, lenW * sizeof(WCHAR)); pszPath[lenA] = 0; *pcchPath = lenA; } else { *pcchPath = lenA + 1; ret = E_POINTER; } } if(pathW != bufW) HeapFree(GetProcessHeap(), 0, pathW); RtlFreeUnicodeString(&urlW); return ret;}
HRESULT WINAPI PathCreateFromUrlW(const WCHAR *url, WCHAR *path, DWORD *pcchPath, DWORD dwReserved){ DWORD nslashes, unescape, len; const WCHAR *src; WCHAR *tpath, *dst; HRESULT hr = S_OK;
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(url), path, pcchPath, dwReserved);
if (!url || !path || !pcchPath || !*pcchPath) return E_INVALIDARG;
if (wcsnicmp( url, L"file:", 5)) return E_INVALIDARG;
url += 5;
src = url; nslashes = 0; while (*src == '/' || *src == '\\') { nslashes++; src++; }
/* We need a temporary buffer so we can compute what size to ask for. * We know that the final string won't be longer than the current pszUrl * plus at most two backslashes. All the other transformations make it * shorter. */ len = 2 + lstrlenW(url) + 1; if (*pcchPath < len) tpath = heap_alloc(len * sizeof(WCHAR)); else tpath = path;
len = 0; dst = tpath; unescape = 1; switch (nslashes) { case 0: /* 'file:' + escaped DOS path */ break; case 1: /* 'file:/' + escaped DOS path */ /* fall through */ case 3: /* 'file:///' (implied localhost) + escaped DOS path */ if (!is_escaped_drive_spec( src )) src -= 1; break; case 2: if (lstrlenW(src) >= 10 && !wcsnicmp( src, L"localhost", 9) && (src[9] == '/' || src[9] == '\\')) { /* 'file://localhost/' + escaped DOS path */ src += 10; } else if (is_escaped_drive_spec( src )) { /* 'file://' + unescaped DOS path */ unescape = 0; } else { /* 'file://hostname:port/path' (where path is escaped) * or 'file:' + escaped UNC path (\\server\share\path) * The second form is clearly specific to Windows and it might * even be doing a network lookup to try to figure it out. */ while (*src && *src != '/' && *src != '\\') src++; len = src - url; StrCpyNW(dst, url, len + 1); dst += len; if (*src && is_escaped_drive_spec( src + 1 )) { /* 'Forget' to add a trailing '/', just like Windows */ src++; } } break; case 4: /* 'file://' + unescaped UNC path (\\server\share\path) */ unescape = 0; if (is_escaped_drive_spec( src )) break; /* fall through */ default: /* 'file:/...' + escaped UNC path (\\server\share\path) */ src -= 2; }
/* Copy the remainder of the path */ len += lstrlenW(src); lstrcpyW(dst, src);
/* First do the Windows-specific path conversions */ for (dst = tpath; *dst; dst++) if (*dst == '/') *dst = '\\'; if (is_escaped_drive_spec( tpath )) tpath[1] = ':'; /* c| -> c: */
/* And only then unescape the path (i.e. escaped slashes are left as is) */ if (unescape) { hr = UrlUnescapeW(tpath, NULL, &len, URL_UNESCAPE_INPLACE); if (hr == S_OK) { /* When working in-place UrlUnescapeW() does not set len */ len = lstrlenW(tpath); } }
if (*pcchPath < len + 1) { hr = E_POINTER; *pcchPath = len + 1; } else { *pcchPath = len; if (tpath != path) lstrcpyW(path, tpath); } if (tpath != path) heap_free(tpath);
TRACE("Returning (%lu) %s\n", *pcchPath, wine_dbgstr_w(path)); return hr;}
HRESULT WINAPI PathCreateFromUrlAlloc(const WCHAR *url, WCHAR **path, DWORD reserved){ WCHAR pathW[MAX_PATH]; DWORD size; HRESULT hr;
size = MAX_PATH; hr = PathCreateFromUrlW(url, pathW, &size, reserved); if (SUCCEEDED(hr)) { /* Yes, this is supposed to crash if 'path' is NULL */ *path = StrDupW(pathW); }
return hr;}
BOOL WINAPI PathIsURLA(const char *path){ PARSEDURLA base; HRESULT hr;
TRACE("%s\n", wine_dbgstr_a(path));
if (!path || !*path) return FALSE;
/* get protocol */ base.cbSize = sizeof(base); hr = ParseURLA(path, &base); return hr == S_OK && (base.nScheme != URL_SCHEME_INVALID);}
BOOL WINAPI PathIsURLW(const WCHAR *path){ PARSEDURLW base; HRESULT hr;
TRACE("%s\n", wine_dbgstr_w(path));
if (!path || !*path) return FALSE;
/* get protocol */ base.cbSize = sizeof(base); hr = ParseURLW(path, &base); return hr == S_OK && (base.nScheme != URL_SCHEME_INVALID);}
#define WINE_URL_BASH_AS_SLASH 0x01#define WINE_URL_COLLAPSE_SLASHES 0x02#define WINE_URL_ESCAPE_SLASH 0x04#define WINE_URL_ESCAPE_HASH 0x08#define WINE_URL_ESCAPE_QUESTION 0x10#define WINE_URL_STOP_ON_HASH 0x20#define WINE_URL_STOP_ON_QUESTION 0x40
static BOOL url_needs_escape(WCHAR ch, DWORD flags, DWORD int_flags){ if (flags & URL_ESCAPE_SPACES_ONLY) return ch == ' ';
if ((flags & URL_ESCAPE_PERCENT) && (ch == '%')) return TRUE;
if ((flags & URL_ESCAPE_AS_UTF8) && (ch >= 0x80)) return TRUE;
if (ch <= 31 || (ch >= 127 && ch <= 255) ) return TRUE;
if (iswalnum(ch)) return FALSE;
switch (ch) { case ' ': case '<': case '>': case '\"': case '{': case '}': case '|': case '\\': case '^': case ']': case '[': case '`': case '&': return TRUE; case '/': return !!(int_flags & WINE_URL_ESCAPE_SLASH); case '?': return !!(int_flags & WINE_URL_ESCAPE_QUESTION); case '#': return !!(int_flags & WINE_URL_ESCAPE_HASH); default: return FALSE; }}
HRESULT WINAPI UrlEscapeA(const char *url, char *escaped, DWORD *escaped_len, DWORD flags){ WCHAR bufW[INTERNET_MAX_URL_LENGTH]; WCHAR *escapedW = bufW; UNICODE_STRING urlW; HRESULT hr; DWORD lenW = ARRAY_SIZE(bufW), lenA;
if (!escaped || !escaped_len || !*escaped_len) return E_INVALIDARG;
if (!RtlCreateUnicodeStringFromAsciiz(&urlW, url)) return E_INVALIDARG;
if (flags & URL_ESCAPE_AS_UTF8) { RtlFreeUnicodeString(&urlW); return E_NOTIMPL; }
if ((hr = UrlEscapeW(urlW.Buffer, escapedW, &lenW, flags)) == E_POINTER) { escapedW = heap_alloc(lenW * sizeof(WCHAR)); hr = UrlEscapeW(urlW.Buffer, escapedW, &lenW, flags); }
if (hr == S_OK) { RtlUnicodeToMultiByteSize(&lenA, escapedW, lenW * sizeof(WCHAR)); if (*escaped_len > lenA) { RtlUnicodeToMultiByteN(escaped, *escaped_len - 1, &lenA, escapedW, lenW * sizeof(WCHAR)); escaped[lenA] = 0; *escaped_len = lenA; } else { *escaped_len = lenA + 1; hr = E_POINTER; } } if (escapedW != bufW) heap_free(escapedW); RtlFreeUnicodeString(&urlW); return hr;}
HRESULT WINAPI UrlEscapeW(const WCHAR *url, WCHAR *escaped, DWORD *escaped_len, DWORD flags){ DWORD needed = 0, slashes = 0, int_flags; WCHAR next[12], *dst, *dst_ptr; BOOL stop_escaping = FALSE; PARSEDURLW parsed_url; const WCHAR *src; INT i, len; HRESULT hr;
TRACE("%p, %s, %p, %p, %#lx\n", url, wine_dbgstr_w(url), escaped, escaped_len, flags);
if (!url || !escaped_len || !escaped || *escaped_len == 0) return E_INVALIDARG;
if (flags & ~(URL_ESCAPE_SPACES_ONLY | URL_ESCAPE_SEGMENT_ONLY | URL_DONT_ESCAPE_EXTRA_INFO | URL_ESCAPE_PERCENT | URL_ESCAPE_AS_UTF8)) { FIXME("Unimplemented flags: %08lx\n", flags); }
dst_ptr = dst = heap_alloc(*escaped_len * sizeof(WCHAR)); if (!dst_ptr) return E_OUTOFMEMORY;
/* fix up flags */ if (flags & URL_ESCAPE_SPACES_ONLY) /* if SPACES_ONLY specified, reset the other controls */ flags &= ~(URL_DONT_ESCAPE_EXTRA_INFO | URL_ESCAPE_PERCENT | URL_ESCAPE_SEGMENT_ONLY); else /* if SPACES_ONLY *not* specified the assume DONT_ESCAPE_EXTRA_INFO */ flags |= URL_DONT_ESCAPE_EXTRA_INFO;
int_flags = 0; if (flags & URL_ESCAPE_SEGMENT_ONLY) int_flags = WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH | WINE_URL_ESCAPE_SLASH; else { parsed_url.cbSize = sizeof(parsed_url); if (ParseURLW(url, &parsed_url) != S_OK) parsed_url.nScheme = URL_SCHEME_INVALID;
TRACE("scheme = %d (%s)\n", parsed_url.nScheme, debugstr_wn(parsed_url.pszProtocol, parsed_url.cchProtocol));
if (flags & URL_DONT_ESCAPE_EXTRA_INFO) int_flags = WINE_URL_STOP_ON_HASH | WINE_URL_STOP_ON_QUESTION;
switch(parsed_url.nScheme) { case URL_SCHEME_FILE: int_flags |= WINE_URL_BASH_AS_SLASH | WINE_URL_COLLAPSE_SLASHES | WINE_URL_ESCAPE_HASH; int_flags &= ~WINE_URL_STOP_ON_HASH; break;
case URL_SCHEME_HTTP: case URL_SCHEME_HTTPS: int_flags |= WINE_URL_BASH_AS_SLASH; if(parsed_url.pszSuffix[0] != '/' && parsed_url.pszSuffix[0] != '\\') int_flags |= WINE_URL_ESCAPE_SLASH; break;
case URL_SCHEME_MAILTO: int_flags |= WINE_URL_ESCAPE_SLASH | WINE_URL_ESCAPE_QUESTION | WINE_URL_ESCAPE_HASH; int_flags &= ~(WINE_URL_STOP_ON_QUESTION | WINE_URL_STOP_ON_HASH); break;
case URL_SCHEME_INVALID: break;
case URL_SCHEME_FTP: default: if(parsed_url.pszSuffix[0] != '/') int_flags |= WINE_URL_ESCAPE_SLASH; break; } }
for (src = url; *src; ) { WCHAR cur = *src; len = 0;
if ((int_flags & WINE_URL_COLLAPSE_SLASHES) && src == url + parsed_url.cchProtocol + 1) { while (cur == '/' || cur == '\\') { slashes++; cur = *++src; } if (slashes == 2 && !wcsnicmp(src, L"localhost", 9)) { /* file://localhost/ -> file:/// */ if(src[9] == '/' || src[9] == '\\') src += 10; slashes = 3; }
switch (slashes) { case 1: case 3: next[0] = next[1] = next[2] = '/'; len = 3; break; case 0: len = 0; break; default: next[0] = next[1] = '/'; len = 2; break; } } if (len == 0) { if (cur == '#' && (int_flags & WINE_URL_STOP_ON_HASH)) stop_escaping = TRUE;
if (cur == '?' && (int_flags & WINE_URL_STOP_ON_QUESTION)) stop_escaping = TRUE;
if (cur == '\\' && (int_flags & WINE_URL_BASH_AS_SLASH) && !stop_escaping) cur = '/';
if (url_needs_escape(cur, flags, int_flags) && !stop_escaping) { if (flags & URL_ESCAPE_AS_UTF8) { char utf[16];
if ((cur >= 0xd800 && cur <= 0xdfff) && (src[1] >= 0xdc00 && src[1] <= 0xdfff)) { len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, 2, utf, sizeof(utf), NULL, NULL); src++; } else len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, &cur, 1, utf, sizeof(utf), NULL, NULL);
if (!len) { utf[0] = 0xef; utf[1] = 0xbf; utf[2] = 0xbd; len = 3; }
for (i = 0; i < len; ++i) { next[i*3+0] = '%'; next[i*3+1] = hexDigits[(utf[i] >> 4) & 0xf]; next[i*3+2] = hexDigits[utf[i] & 0xf]; } len *= 3; } else { next[0] = '%'; next[1] = hexDigits[(cur >> 4) & 0xf]; next[2] = hexDigits[cur & 0xf]; len = 3; } } else { next[0] = cur; len = 1; } src++; }
if (needed + len <= *escaped_len) { memcpy(dst, next, len*sizeof(WCHAR)); dst += len; } needed += len; }
if (needed < *escaped_len) { *dst = '\0'; memcpy(escaped, dst_ptr, (needed+1)*sizeof(WCHAR)); hr = S_OK; } else { needed++; /* add one for the '\0' */ hr = E_POINTER; } *escaped_len = needed;
heap_free(dst_ptr); return hr;}
HRESULT WINAPI UrlCanonicalizeA(const char *src_url, char *canonicalized, DWORD *canonicalized_len, DWORD flags){ LPWSTR url, canonical; HRESULT hr;
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_a(src_url), canonicalized, canonicalized_len, flags);
if (!src_url || !canonicalized || !canonicalized_len || !*canonicalized_len) return E_INVALIDARG;
url = heap_strdupAtoW(src_url); canonical = heap_alloc(*canonicalized_len * sizeof(WCHAR)); if (!url || !canonical) { heap_free(url); heap_free(canonical); return E_OUTOFMEMORY; }
hr = UrlCanonicalizeW(url, canonical, canonicalized_len, flags); if (hr == S_OK) WideCharToMultiByte(CP_ACP, 0, canonical, -1, canonicalized, *canonicalized_len + 1, NULL, NULL);
heap_free(url); heap_free(canonical); return hr;}
static bool scheme_is_opaque( URL_SCHEME scheme ){ switch (scheme) { case URL_SCHEME_ABOUT: case URL_SCHEME_JAVASCRIPT: case URL_SCHEME_MAILTO: case URL_SCHEME_SHELL: case URL_SCHEME_VBSCRIPT: return true;
default: return false; }}
static bool scheme_preserves_backslashes( URL_SCHEME scheme ){ switch (scheme) { case URL_SCHEME_FTP: case URL_SCHEME_INVALID: case URL_SCHEME_LOCAL: case URL_SCHEME_MK: case URL_SCHEME_RES: case URL_SCHEME_UNKNOWN: case URL_SCHEME_WAIS: return true;
default: return false; }}
static bool scheme_uses_hostname( URL_SCHEME scheme ){ switch (scheme) { case URL_SCHEME_ABOUT: case URL_SCHEME_JAVASCRIPT: case URL_SCHEME_MAILTO: case URL_SCHEME_MK: case URL_SCHEME_SHELL: case URL_SCHEME_VBSCRIPT: return false;
default: return true; }}
static bool scheme_char_is_separator( URL_SCHEME scheme, WCHAR c ){ if (c == '/') return true; if (c == '\\' && scheme != URL_SCHEME_INVALID && scheme != URL_SCHEME_UNKNOWN) return true; return false;}
static bool scheme_char_is_hostname_separator( URL_SCHEME scheme, DWORD flags, WCHAR c ){ switch (c) { case 0: case '/': return true; case '\\': return !scheme_preserves_backslashes( scheme ); case '?': return scheme != URL_SCHEME_FILE || (flags & (URL_WININET_COMPATIBILITY | URL_FILE_USE_PATHURL)); case '#': return scheme != URL_SCHEME_FILE; default: return false; }}
static bool scheme_char_is_dot_separator( URL_SCHEME scheme, DWORD flags, WCHAR c ){ switch (c) { case 0: case '/': case '?': return true; case '#': return (scheme != URL_SCHEME_FILE || !(flags & (URL_WININET_COMPATIBILITY | URL_FILE_USE_PATHURL))); case '\\': return (scheme != URL_SCHEME_INVALID && scheme != URL_SCHEME_UNKNOWN && scheme != URL_SCHEME_MK); default: return false; }}
/* There are essentially two types of behaviour concerning dot simplification, * not counting opaque schemes: * * 1) Simplify dots if and only if the first element is not a single or double * dot. If a double dot would rewind past the root, ignore it. For example: * * http://hostname/a/../../b/. -> http://hostname/b/ * http://hostname/./../../b/. -> http://hostname/./../../b/. * * 2) Effectively treat all paths as relative. Always simplify, except if a * double dot would rewind past the root, in which case emit it verbatim. * For example: * * wine://hostname/a/../../b/. -> wine://hostname/../b/ * wine://hostname/./../../b/. -> wine://hostname/../b/ * * For unclear reasons, this behaviour also correlates with whether a final * slash is always emitted after a single or double dot (e.g. if * URL_DONT_SIMPLIFY is specified). The former type does not emit a slash; the * latter does. */static bool scheme_is_always_relative( URL_SCHEME scheme, DWORD flags ){ switch (scheme) { case URL_SCHEME_INVALID: case URL_SCHEME_UNKNOWN: return true;
case URL_SCHEME_FILE: return flags & (URL_WININET_COMPATIBILITY | URL_FILE_USE_PATHURL);
default: return false; }}
struct string_buffer{ WCHAR *string; size_t len, capacity;};
static void append_string( struct string_buffer *buffer, const WCHAR *str, size_t len ){ array_reserve( (void **)&buffer->string, &buffer->capacity, buffer->len + len, sizeof(WCHAR) ); memcpy( buffer->string + buffer->len, str, len * sizeof(WCHAR) ); buffer->len += len;}
static void append_char( struct string_buffer *buffer, WCHAR c ){ append_string( buffer, &c, 1 );}
static char get_slash_dir( URL_SCHEME scheme, DWORD flags, char src, const struct string_buffer *dst ){ if (src && scheme_preserves_backslashes( scheme )) return src;
if (scheme == URL_SCHEME_FILE && (flags & (URL_FILE_USE_PATHURL | URL_WININET_COMPATIBILITY)) && !wmemchr( dst->string, '#', dst->len )) return '\\';
return '/';}
static void rewrite_url( struct string_buffer *dst, const WCHAR *url, DWORD *flags_ptr ){ DWORD flags = *flags_ptr; bool pathurl = (flags & (URL_FILE_USE_PATHURL | URL_WININET_COMPATIBILITY)); bool is_relative = false, has_hostname = false, has_initial_slash = false; const WCHAR *query = NULL, *hash = NULL; URL_SCHEME scheme = URL_SCHEME_INVALID; size_t query_len = 0, hash_len = 0; const WCHAR *scheme_end, *src_end; const WCHAR *hostname = NULL; size_t hostname_len = 0; const WCHAR *src = url; size_t root_offset;
/* Determine the scheme. */
scheme_end = parse_scheme( url );
if (*scheme_end == ':' && scheme_end >= url + 2) { size_t scheme_len = scheme_end + 1 - url;
scheme = get_scheme_code( url, scheme_len - 1 );
for (size_t i = 0; i < scheme_len; ++i) append_char( dst, tolower( *src++ )); } else if (url[0] == '\\' && url[1] == '\\') { append_string( dst, L"file:", 5 ); if (!pathurl && !(flags & URL_UNESCAPE)) flags |= URL_ESCAPE_UNSAFE | URL_ESCAPE_PERCENT; scheme = URL_SCHEME_FILE;
has_hostname = true; }
if (is_escaped_drive_spec( url )) { append_string( dst, L"file://", 7 ); if (!pathurl && !(flags & URL_UNESCAPE)) flags |= URL_ESCAPE_UNSAFE | URL_ESCAPE_PERCENT; scheme = URL_SCHEME_FILE;
hostname_len = 0; has_hostname = true; } else if (scheme == URL_SCHEME_MK) { if (src[0] == '@') { while (*src && *src != '/') append_char( dst, *src++ ); if (*src == '/') append_char( dst, *src++ ); else append_char( dst, '/' );
if ((src[0] == '.' && scheme_char_is_dot_separator( scheme, flags, src[1] )) || (src[0] == '.' && src[1] == '.' && scheme_char_is_dot_separator( scheme, flags, src[2] ))) is_relative = true; } } else if (scheme_uses_hostname( scheme ) && scheme_char_is_separator( scheme, src[0] ) && scheme_char_is_separator( scheme, src[1] )) { append_char( dst, scheme_preserves_backslashes( scheme ) ? src[0] : '/' ); append_char( dst, scheme_preserves_backslashes( scheme ) ? src[1] : '/' ); src += 2; if (scheme == URL_SCHEME_FILE && is_slash( src[0] ) && is_slash( src[1] )) { while (is_slash( *src )) ++src; }
hostname = src;
while (!scheme_char_is_hostname_separator( scheme, flags, *src )) ++src; hostname_len = src - hostname; has_hostname = true; has_initial_slash = true; } else if (scheme_char_is_separator( scheme, src[0] )) { has_initial_slash = true;
if (scheme == URL_SCHEME_UNKNOWN || scheme == URL_SCHEME_INVALID) { /* Special case: an unknown scheme starting with a single slash * considers the "root" to be the single slash. * Most other schemes treat it as an empty path segment instead. */ append_char( dst, *src++ );
if (*src == '\\') ++src; } else if (scheme == URL_SCHEME_FILE) { src++;
append_string( dst, L"//", 2 );
hostname_len = 0; has_hostname = true; } } else { if (scheme == URL_SCHEME_FILE) { if (is_escaped_drive_spec( src )) { append_string( dst, L"//", 2 ); hostname_len = 0; has_hostname = true; } else { if (flags & URL_FILE_USE_PATHURL) append_string( dst, L"//", 2 ); } } }
if (scheme == URL_SCHEME_FILE && (flags & URL_FILE_USE_PATHURL)) flags |= URL_UNESCAPE;
*flags_ptr = flags;
if (has_hostname) { if (scheme == URL_SCHEME_FILE) { bool is_drive = false;
if (is_slash( *src )) ++src;
if (hostname_len >= 2 && is_escaped_drive_spec( hostname )) { hostname_len = 0; src = hostname; is_drive = true; } else if (is_escaped_drive_spec( src )) { is_drive = true; }
if (pathurl) { if (hostname_len == 9 && !wcsnicmp( hostname, L"localhost", 9 )) { hostname_len = 0; if (is_slash( *src )) ++src; if (is_escaped_drive_spec( src )) is_drive = true; }
if (!is_drive) { if (hostname_len) { append_string( dst, L"\\\\", 2 ); append_string( dst, hostname, hostname_len ); }
if ((*src && *src != '?') || (flags & URL_WININET_COMPATIBILITY)) append_char( dst, get_slash_dir( scheme, flags, 0, dst )); } } else { if (hostname_len) append_string( dst, hostname, hostname_len ); append_char( dst, '/' ); }
if (is_drive) { /* Root starts after the first slash when file flags are in use, * but directly after the drive specification if not. */ if (pathurl) { while (!scheme_char_is_hostname_separator( scheme, flags, *src )) append_char( dst, *src++ ); if (is_slash( *src )) { append_char( dst, '\\' ); src++; } } else { append_char( dst, *src++ ); append_char( dst, *src++ ); if (is_slash( *src )) { append_char( dst, '/' ); src++; } } } } else { for (size_t i = 0; i < hostname_len; ++i) { if (scheme == URL_SCHEME_UNKNOWN || scheme == URL_SCHEME_INVALID) append_char( dst, hostname[i] ); else append_char( dst, tolower( hostname[i] )); }
if (*src == '/' || *src == '\\') { append_char( dst, scheme_preserves_backslashes( scheme ) ? *src : '/' ); src++; } else { append_char( dst, '/' ); } }
if ((src[0] == '.' && scheme_char_is_dot_separator( scheme, flags, src[1] )) || (src[0] == '.' && src[1] == '.' && scheme_char_is_dot_separator( scheme, flags, src[2] ))) { if (!scheme_is_always_relative( scheme, flags )) is_relative = true; } }
/* root_offset now points to the point past which we will not rewind. * If there is a hostname, it points to the character after the closing * slash. */
root_offset = dst->len;
/* Break up the rest of the URL into the body, query, and hash parts. */
src_end = src + wcslen( src );
if (scheme_is_opaque( scheme )) { /* +1 for null terminator */ append_string( dst, src, src_end + 1 - src ); return; }
if (scheme == URL_SCHEME_FILE) { if (!pathurl) { if (src[0] == '#') hash = src; else if (is_slash( src[0] ) && src[1] == '#') hash = src + 1;
if (src[0] == '?') query = src; else if (is_slash( src[0] ) && src[1] == '?') query = src + 1; } else { query = wcschr( src, '?' ); }
if (!hash) { for (const WCHAR *p = src; p < src_end; ++p) { if (!wcsnicmp( p, L".htm#" , 5)) hash = p + 4; else if (!wcsnicmp( p, L".html#", 6 )) hash = p + 5; } } } else { query = wcschr( src, '?' ); hash = wcschr( src, '#' ); }
if (query) query_len = ((hash && hash > query) ? hash : src_end) - query; if (hash) hash_len = ((query && query > hash) ? query : src_end) - hash;
if (query) src_end = query; if (hash && hash < src_end) src_end = hash;
if (scheme == URL_SCHEME_UNKNOWN && !has_initial_slash) { if (!(flags & URL_DONT_SIMPLIFY) && src[0] == '.' && src_end == src + 1) src++; flags |= URL_DONT_SIMPLIFY; }
while (src < src_end) { bool is_dots = false; size_t len;
for (len = 0; src + len < src_end && !scheme_char_is_separator( scheme, src[len] ); ++len) ;
if (src[0] == '.' && scheme_char_is_dot_separator( scheme, flags, src[1] )) { if (!is_relative) { if (flags & URL_DONT_SIMPLIFY) { is_dots = true; } else { ++src; if (*src == '/' || *src == '\\') ++src; continue; } } } else if (src[0] == '.' && src[1] == '.' && scheme_char_is_dot_separator( scheme, flags, src[2] )) { if (!is_relative) { if (flags & URL_DONT_SIMPLIFY) { is_dots = true; } else if (dst->len == root_offset && scheme_is_always_relative( scheme, flags )) { /* We could also use is_dots here, except that we need to * update root afterwards. */
append_char( dst, *src++ ); append_char( dst, *src++ ); if (*src == '/' || *src == '\\') append_char( dst, get_slash_dir( scheme, flags, *src++, dst )); else append_char( dst, get_slash_dir( scheme, flags, 0, dst )); root_offset = dst->len; continue; } else { if (dst->len > root_offset) --dst->len; /* rewind past the last slash */
while (dst->len > root_offset && !scheme_char_is_separator( scheme, dst->string[dst->len - 1] )) --dst->len;
src += 2; if (*src == '/' || *src == '\\') ++src; continue; } } }
if (len) { append_string( dst, src, len ); src += len; }
if (*src == '?' || *src == '#' || !*src) { if (scheme == URL_SCHEME_UNKNOWN && !has_initial_slash) is_dots = false;
if (is_dots && scheme_is_always_relative( scheme, flags )) append_char( dst, get_slash_dir( scheme, flags, 0, dst )); } else /* slash */ { append_char( dst, get_slash_dir( scheme, flags, *src++, dst )); } }
/* If the source was non-empty but collapsed to an empty string, output a * single slash. */ if (!dst->len && src_end != url) append_char( dst, '/' );
/* UNKNOWN and FILE schemes usually reorder the ? before the #, but others * emit them in the original order. */ if (query && hash && scheme != URL_SCHEME_FILE && scheme != URL_SCHEME_INVALID && scheme != URL_SCHEME_UNKNOWN) { if (query < hash) { append_string( dst, query, query_len ); append_string( dst, hash, hash_len ); } else { append_string( dst, hash, hash_len ); append_string( dst, query, query_len ); } } else if (!(scheme == URL_SCHEME_FILE && (flags & URL_FILE_USE_PATHURL))) { if (query) append_string( dst, query, query_len );
if (hash) append_string( dst, hash, hash_len ); }
append_char( dst, 0 );}
HRESULT WINAPI UrlCanonicalizeW(const WCHAR *src_url, WCHAR *canonicalized, DWORD *canonicalized_len, DWORD flags){ struct string_buffer rewritten = {0}; DWORD escape_flags; HRESULT hr = S_OK; const WCHAR *src; WCHAR *url, *dst; DWORD len;
TRACE("%s, %p, %p, %#lx\n", wine_dbgstr_w(src_url), canonicalized, canonicalized_len, flags);
if (!src_url || !canonicalized || !canonicalized_len || !*canonicalized_len) return E_INVALIDARG;
if (!*src_url) { *canonicalized = 0; return S_OK; }
/* PATHURL takes precedence. */ if (flags & URL_FILE_USE_PATHURL) flags &= ~URL_WININET_COMPATIBILITY;
/* strip initial and final C0 control characters and space */ src = src_url; while (*src > 0 && *src <= 0x20) ++src; len = wcslen( src ); while (len && src[len - 1] > 0 && src[len - 1] <= 0x20) --len;
if (!(url = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
dst = url; for (size_t i = 0; i < len; ++i) { if (src[i] != '\t' && src[i] != '\n' && src[i] != '\r') *dst++ = src[i]; } *dst++ = 0;
rewrite_url( &rewritten, url, &flags );
if (flags & URL_UNESCAPE) { len = rewritten.len; UrlUnescapeW( rewritten.string, NULL, &len, URL_UNESCAPE_INPLACE); rewritten.len = wcslen( rewritten.string ) + 1; }
/* URL_ESCAPE_SEGMENT_ONLY seems to be ignored. */ escape_flags = flags & (URL_ESCAPE_UNSAFE | URL_ESCAPE_SPACES_ONLY | URL_ESCAPE_PERCENT | URL_DONT_ESCAPE_EXTRA_INFO);
if (escape_flags) { escape_flags &= ~URL_ESCAPE_UNSAFE; hr = UrlEscapeW( rewritten.string, canonicalized, canonicalized_len, escape_flags ); } else { /* No escaping needed, just copy the string */ if (rewritten.len <= *canonicalized_len) { memcpy( canonicalized, rewritten.string, rewritten.len * sizeof(WCHAR) ); *canonicalized_len = rewritten.len - 1; } else { hr = E_POINTER; *canonicalized_len = rewritten.len; } }
heap_free( rewritten.string ); heap_free( url );
if (hr == S_OK) TRACE("result %s\n", wine_dbgstr_w(canonicalized));
return hr;}
HRESULT WINAPI UrlApplySchemeA(const char *url, char *out, DWORD *out_len, DWORD flags){ LPWSTR inW, outW; HRESULT hr; DWORD len;
TRACE("%s, %p, %p:out size %ld, %#lx\n", wine_dbgstr_a(url), out, out_len, out_len ? *out_len : 0, flags);
if (!url || !out || !out_len) return E_INVALIDARG;
inW = heap_alloc(2 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); outW = inW + INTERNET_MAX_URL_LENGTH;
MultiByteToWideChar(CP_ACP, 0, url, -1, inW, INTERNET_MAX_URL_LENGTH); len = INTERNET_MAX_URL_LENGTH;
hr = UrlApplySchemeW(inW, outW, &len, flags); if (hr != S_OK) { heap_free(inW); return hr; }
len = WideCharToMultiByte(CP_ACP, 0, outW, -1, NULL, 0, NULL, NULL); if (len > *out_len) { hr = E_POINTER; goto cleanup; }
WideCharToMultiByte(CP_ACP, 0, outW, -1, out, *out_len, NULL, NULL); len--;
cleanup: *out_len = len; heap_free(inW); return hr;}
static HRESULT url_guess_scheme(const WCHAR *url, WCHAR *out, DWORD *out_len){ WCHAR reg_path[MAX_PATH], value[MAX_PATH], data[MAX_PATH]; DWORD value_len, data_len, dwType, i; WCHAR Wxx, Wyy; HKEY newkey; INT index; BOOL j;
MultiByteToWideChar(CP_ACP, 0, "Software\\Microsoft\\Windows\\CurrentVersion\\URL\\Prefixes", -1, reg_path, MAX_PATH); RegOpenKeyExW(HKEY_LOCAL_MACHINE, reg_path, 0, 1, &newkey); index = 0; while (value_len = data_len = MAX_PATH, RegEnumValueW(newkey, index, value, &value_len, 0, &dwType, (LPVOID)data, &data_len) == 0) { TRACE("guess %d %s is %s\n", index, wine_dbgstr_w(value), wine_dbgstr_w(data));
j = FALSE; for (i = 0; i < value_len; ++i) { Wxx = url[i]; Wyy = value[i]; /* remember that TRUE is not-equal */ j = ChrCmpIW(Wxx, Wyy); if (j) break; } if ((i == value_len) && !j) { if (lstrlenW(data) + lstrlenW(url) + 1 > *out_len) { *out_len = lstrlenW(data) + lstrlenW(url) + 1; RegCloseKey(newkey); return E_POINTER; } lstrcpyW(out, data); lstrcatW(out, url); *out_len = lstrlenW(out); TRACE("matched and set to %s\n", wine_dbgstr_w(out)); RegCloseKey(newkey); return S_OK; } index++; } RegCloseKey(newkey); return E_FAIL;}
static HRESULT url_create_from_path(const WCHAR *path, WCHAR *url, DWORD *url_len){ PARSEDURLW parsed_url; WCHAR *new_url; DWORD needed; HRESULT hr;
parsed_url.cbSize = sizeof(parsed_url); if (ParseURLW(path, &parsed_url) == S_OK) { if (parsed_url.nScheme != URL_SCHEME_INVALID && parsed_url.cchProtocol > 1) { needed = lstrlenW(path); if (needed >= *url_len) { *url_len = needed + 1; return E_POINTER; } else { *url_len = needed; return S_FALSE; } } }
new_url = heap_alloc((lstrlenW(path) + 9) * sizeof(WCHAR)); /* "file:///" + path length + 1 */ lstrcpyW(new_url, L"file:"); if (is_drive_spec( path )) lstrcatW(new_url, L"///"); lstrcatW(new_url, path); hr = UrlEscapeW(new_url, url, url_len, URL_ESCAPE_PERCENT); heap_free(new_url); return hr;}
static HRESULT url_apply_default_scheme(const WCHAR *url, WCHAR *out, DWORD *length){ DWORD data_len, dwType; WCHAR data[MAX_PATH]; HKEY newkey;
/* get and prepend default */ RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\URL\\DefaultPrefix", 0, 1, &newkey); data_len = sizeof(data); RegQueryValueExW(newkey, NULL, 0, &dwType, (BYTE *)data, &data_len); RegCloseKey(newkey); if (lstrlenW(data) + lstrlenW(url) + 1 > *length) { *length = lstrlenW(data) + lstrlenW(url) + 1; return E_POINTER; } lstrcpyW(out, data); lstrcatW(out, url); *length = lstrlenW(out); TRACE("used default %s\n", wine_dbgstr_w(out)); return S_OK;}
HRESULT WINAPI UrlApplySchemeW(const WCHAR *url, WCHAR *out, DWORD *length, DWORD flags){ PARSEDURLW in_scheme; DWORD res1; HRESULT hr;
TRACE("%s, %p, %p:out size %ld, %#lx\n", wine_dbgstr_w(url), out, length, length ? *length : 0, flags);
if (!url || !out || !length) return E_INVALIDARG;
if (flags & URL_APPLY_GUESSFILE) { if ((*length > 1 && ':' == url[1]) || PathIsUNCW(url)) { res1 = *length; hr = url_create_from_path(url, out, &res1); if (hr == S_OK || hr == E_POINTER) { *length = res1; return hr; } else if (hr == S_FALSE) { return hr; } } }
in_scheme.cbSize = sizeof(in_scheme); /* See if the base has a scheme */ res1 = ParseURLW(url, &in_scheme); if (res1) { /* no scheme in input, need to see if we need to guess */ if (flags & URL_APPLY_GUESSSCHEME) { if ((hr = url_guess_scheme(url, out, length)) != E_FAIL) return hr; } }
/* If we are here, then either invalid scheme, * or no scheme and can't/failed guess. */ if ((((res1 == 0) && (flags & URL_APPLY_FORCEAPPLY)) || ((res1 != 0)) ) && (flags & URL_APPLY_DEFAULT)) return url_apply_default_scheme(url, out, length);
return S_FALSE;}
INT WINAPI UrlCompareA(const char *url1, const char *url2, BOOL ignore_slash){ INT ret, len, len1, len2;
if (!ignore_slash) return strcmp(url1, url2); len1 = strlen(url1); if (url1[len1-1] == '/') len1--; len2 = strlen(url2); if (url2[len2-1] == '/') len2--; if (len1 == len2) return strncmp(url1, url2, len1); len = min(len1, len2); ret = strncmp(url1, url2, len); if (ret) return ret; if (len1 > len2) return 1; return -1;}
INT WINAPI UrlCompareW(const WCHAR *url1, const WCHAR *url2, BOOL ignore_slash){ size_t len, len1, len2; INT ret;
if (!ignore_slash) return lstrcmpW(url1, url2); len1 = lstrlenW(url1); if (url1[len1-1] == '/') len1--; len2 = lstrlenW(url2); if (url2[len2-1] == '/') len2--; if (len1 == len2) return wcsncmp(url1, url2, len1); len = min(len1, len2); ret = wcsncmp(url1, url2, len); if (ret) return ret; if (len1 > len2) return 1; return -1;}
HRESULT WINAPI UrlFixupW(const WCHAR *url, WCHAR *translatedUrl, DWORD maxChars){ DWORD srcLen;
FIXME("%s, %p, %ld stub\n", wine_dbgstr_w(url), translatedUrl, maxChars);
if (!url) return E_FAIL;
srcLen = lstrlenW(url) + 1;
/* For now just copy the URL directly */ lstrcpynW(translatedUrl, url, (maxChars < srcLen) ? maxChars : srcLen);
return S_OK;}
const char * WINAPI UrlGetLocationA(const char *url){ PARSEDURLA base;
base.cbSize = sizeof(base); if (ParseURLA(url, &base) != S_OK) return NULL; /* invalid scheme */
/* if scheme is file: then never return pointer */ if (!strncmp(base.pszProtocol, "file", min(4, base.cchProtocol))) return NULL;
/* Look for '#' and return its addr */ return strchr(base.pszSuffix, '#');}
const WCHAR * WINAPI UrlGetLocationW(const WCHAR *url){ PARSEDURLW base;
base.cbSize = sizeof(base); if (ParseURLW(url, &base) != S_OK) return NULL; /* invalid scheme */
/* if scheme is file: then never return pointer */ if (!wcsncmp(base.pszProtocol, L"file", min(4, base.cchProtocol))) return NULL;
/* Look for '#' and return its addr */ return wcschr(base.pszSuffix, '#');}
HRESULT WINAPI UrlGetPartA(const char *url, char *out, DWORD *out_len, DWORD part, DWORD flags){ LPWSTR inW, outW; DWORD len, len2; HRESULT hr;
if (!url || !out || !out_len || !*out_len) return E_INVALIDARG;
inW = heap_alloc(2 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); outW = inW + INTERNET_MAX_URL_LENGTH;
MultiByteToWideChar(CP_ACP, 0, url, -1, inW, INTERNET_MAX_URL_LENGTH);
len = INTERNET_MAX_URL_LENGTH; hr = UrlGetPartW(inW, outW, &len, part, flags); if (FAILED(hr)) { heap_free(inW); return hr; }
len2 = WideCharToMultiByte(CP_ACP, 0, outW, len + 1, NULL, 0, NULL, NULL); if (len2 > *out_len) { *out_len = len2; heap_free(inW); return E_POINTER; } len2 = WideCharToMultiByte(CP_ACP, 0, outW, len + 1, out, *out_len, NULL, NULL); *out_len = len2 - 1; heap_free(inW); if (hr == S_OK && !*out_len) hr = S_FALSE; return hr;}
static const WCHAR *parse_url_element( const WCHAR *url, const WCHAR *separators ){ const WCHAR *p;
if ((p = wcspbrk( url, separators ))) return p; return url + wcslen( url );}
static void parse_url( const WCHAR *url, struct parsed_url *pl ){ const WCHAR *work;
memset(pl, 0, sizeof(*pl)); pl->scheme = url; work = parse_scheme( pl->scheme ); if (work < url + 2 || *work != ':') return; pl->scheme_len = work - pl->scheme; work++; pl->scheme_number = get_scheme_code(pl->scheme, pl->scheme_len); if (!is_slash( work[0] ) || !is_slash( work[1] )) { if (pl->scheme_number != URL_SCHEME_FILE) pl->scheme_number = URL_SCHEME_UNKNOWN; return; } work += 2;
if (pl->scheme_number != URL_SCHEME_FILE) { pl->username = work; work = parse_url_element( pl->username, L":@/\\?#" ); pl->username_len = work - pl->username; if (*work == ':') { pl->password = work + 1; work = parse_url_element( pl->password, L"@/\\?#" ); pl->password_len = work - pl->password; if (*work == '@') { work++; } else { /* what we just parsed must be the hostname and port * so reset pointers and clear then let it parse */ pl->username_len = pl->password_len = 0; work = pl->username; pl->username = pl->password = 0; } } else if (*work == '@') { /* no password */ pl->password_len = 0; pl->password = 0; work++; } else { /* what was parsed was hostname, so reset pointers and let it parse */ pl->username_len = pl->password_len = 0; work = pl->username; pl->username = pl->password = 0; } }
pl->hostname = work; if (pl->scheme_number == URL_SCHEME_FILE) { work = parse_url_element( pl->hostname, L"/\\?#" ); pl->hostname_len = work - pl->hostname; if (pl->hostname_len >= 2 && pl->hostname[1] == ':') pl->hostname_len = 0; } else { work = parse_url_element( pl->hostname, L":/\\?#" ); pl->hostname_len = work - pl->hostname;
if (*work == ':') { pl->port = work + 1; work = parse_url_element( pl->port, L"/\\?#" ); pl->port_len = work - pl->port; } }
if ((pl->query = wcschr( work, '?' ))) { ++pl->query; pl->query_len = lstrlenW(pl->query); }}
HRESULT WINAPI UrlGetPartW(const WCHAR *url, WCHAR *out, DWORD *out_len, DWORD part, DWORD flags){ LPCWSTR addr, schaddr; struct parsed_url pl; DWORD size, schsize;
TRACE("%s, %p, %p(%ld), %#lx, %#lx\n", wine_dbgstr_w(url), out, out_len, *out_len, part, flags);
if (!url || !out || !out_len || !*out_len) return E_INVALIDARG;
parse_url(url, &pl);
switch (pl.scheme_number) { case URL_SCHEME_FTP: case URL_SCHEME_GOPHER: case URL_SCHEME_HTTP: case URL_SCHEME_HTTPS: case URL_SCHEME_TELNET: case URL_SCHEME_NEWS: case URL_SCHEME_NNTP: case URL_SCHEME_SNEWS: break;
case URL_SCHEME_FILE: if (part != URL_PART_SCHEME && part != URL_PART_QUERY && part != URL_PART_HOSTNAME) return E_FAIL; break;
default: if (part != URL_PART_SCHEME && part != URL_PART_QUERY) return E_FAIL; }
switch (part) { case URL_PART_SCHEME: flags &= ~URL_PARTFLAG_KEEPSCHEME; addr = pl.scheme; size = pl.scheme_len; break;
case URL_PART_HOSTNAME: addr = pl.hostname; size = pl.hostname_len; break;
case URL_PART_USERNAME: if (!pl.username) return E_INVALIDARG; addr = pl.username; size = pl.username_len; break;
case URL_PART_PASSWORD: if (!pl.password) return E_INVALIDARG; addr = pl.password; size = pl.password_len; break;
case URL_PART_PORT: if (!pl.port) return E_INVALIDARG; addr = pl.port; size = pl.port_len; break;
case URL_PART_QUERY: flags &= ~URL_PARTFLAG_KEEPSCHEME; addr = pl.query; size = pl.query_len; break;
default: return E_INVALIDARG; }
if (flags == URL_PARTFLAG_KEEPSCHEME && pl.scheme_number != URL_SCHEME_FILE) { if (!pl.scheme || !pl.scheme_len) return E_FAIL; schaddr = pl.scheme; schsize = pl.scheme_len; if (*out_len < schsize + size + 2) { *out_len = schsize + size + 2; return E_POINTER; } memcpy(out, schaddr, schsize*sizeof(WCHAR)); out[schsize] = ':'; memcpy(out + schsize+1, addr, size*sizeof(WCHAR)); out[schsize+1+size] = 0; *out_len = schsize + 1 + size; } else { if (*out_len < size + 1) { *out_len = size + 1; return E_POINTER; }
if (part == URL_PART_SCHEME) { unsigned int i;
for (i = 0; i < size; ++i) out[i] = tolower( addr[i] ); } else { memcpy( out, addr, size * sizeof(WCHAR) ); } out[size] = 0; *out_len = size; } TRACE("len=%ld %s\n", *out_len, wine_dbgstr_w(out));
return S_OK;}
BOOL WINAPI UrlIsA(const char *url, URLIS Urlis){ const char *last; PARSEDURLA base;
TRACE("%s, %d\n", debugstr_a(url), Urlis);
if (!url) return FALSE;
switch (Urlis) {
case URLIS_OPAQUE: base.cbSize = sizeof(base); if (ParseURLA(url, &base) != S_OK) return FALSE; /* invalid scheme */ return scheme_is_opaque( base.nScheme );
case URLIS_FILEURL: return (CompareStringA(LOCALE_INVARIANT, NORM_IGNORECASE, url, 5, "file:", 5) == CSTR_EQUAL);
case URLIS_DIRECTORY: last = url + strlen(url) - 1; return (last >= url && (*last == '/' || *last == '\\' ));
case URLIS_URL: return PathIsURLA(url);
case URLIS_NOHISTORY: case URLIS_APPLIABLE: case URLIS_HASQUERY: default: FIXME("(%s %d): stub\n", debugstr_a(url), Urlis); }
return FALSE;}
BOOL WINAPI UrlIsW(const WCHAR *url, URLIS Urlis){ const WCHAR *last; PARSEDURLW base;
TRACE("%s, %d\n", debugstr_w(url), Urlis);
if (!url) return FALSE;
switch (Urlis) { case URLIS_OPAQUE: base.cbSize = sizeof(base); if (ParseURLW(url, &base) != S_OK) return FALSE; /* invalid scheme */ switch (base.nScheme) { case URL_SCHEME_MAILTO: case URL_SCHEME_SHELL: case URL_SCHEME_JAVASCRIPT: case URL_SCHEME_VBSCRIPT: case URL_SCHEME_ABOUT: return TRUE; } return FALSE;
case URLIS_FILEURL: return !wcsnicmp( url, L"file:", 5 );
case URLIS_DIRECTORY: last = url + lstrlenW(url) - 1; return (last >= url && (*last == '/' || *last == '\\'));
case URLIS_URL: return PathIsURLW(url);
case URLIS_NOHISTORY: case URLIS_APPLIABLE: case URLIS_HASQUERY: default: FIXME("(%s %d): stub\n", debugstr_w(url), Urlis); }
return FALSE;}
BOOL WINAPI UrlIsOpaqueA(const char *url){ return UrlIsA(url, URLIS_OPAQUE);}
BOOL WINAPI UrlIsOpaqueW(const WCHAR *url){ return UrlIsW(url, URLIS_OPAQUE);}
BOOL WINAPI UrlIsNoHistoryA(const char *url){ return UrlIsA(url, URLIS_NOHISTORY);}
BOOL WINAPI UrlIsNoHistoryW(const WCHAR *url){ return UrlIsW(url, URLIS_NOHISTORY);}
HRESULT WINAPI UrlCreateFromPathA(const char *path, char *url, DWORD *url_len, DWORD reserved){ WCHAR bufW[INTERNET_MAX_URL_LENGTH]; DWORD lenW = ARRAY_SIZE(bufW), lenA; UNICODE_STRING pathW; WCHAR *urlW = bufW; HRESULT hr;
if (!RtlCreateUnicodeStringFromAsciiz(&pathW, path)) return E_INVALIDARG;
if ((hr = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, reserved)) == E_POINTER) { urlW = heap_alloc(lenW * sizeof(WCHAR)); hr = UrlCreateFromPathW(pathW.Buffer, urlW, &lenW, reserved); }
if (SUCCEEDED(hr)) { RtlUnicodeToMultiByteSize(&lenA, urlW, lenW * sizeof(WCHAR)); if (*url_len > lenA) { RtlUnicodeToMultiByteN(url, *url_len - 1, &lenA, urlW, lenW * sizeof(WCHAR)); url[lenA] = 0; *url_len = lenA; } else { *url_len = lenA + 1; hr = E_POINTER; } } if (urlW != bufW) heap_free(urlW); RtlFreeUnicodeString(&pathW); return hr;}
HRESULT WINAPI UrlCreateFromPathW(const WCHAR *path, WCHAR *url, DWORD *url_len, DWORD reserved){ HRESULT hr;
TRACE("%s, %p, %p, %#lx\n", debugstr_w(path), url, url_len, reserved);
if (reserved || !url || !url_len) return E_INVALIDARG;
hr = url_create_from_path(path, url, url_len); if (hr == S_FALSE) lstrcpyW(url, path);
return hr;}
HRESULT WINAPI UrlCombineA(const char *base, const char *relative, char *combined, DWORD *combined_len, DWORD flags){ WCHAR *baseW, *relativeW, *combinedW; DWORD len, len2; HRESULT hr;
TRACE("%s, %s, %ld, %#lx\n", debugstr_a(base), debugstr_a(relative), combined_len ? *combined_len : 0, flags);
if (!base || !relative || !combined_len) return E_INVALIDARG;
baseW = heap_alloc(3 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); relativeW = baseW + INTERNET_MAX_URL_LENGTH; combinedW = relativeW + INTERNET_MAX_URL_LENGTH;
MultiByteToWideChar(CP_ACP, 0, base, -1, baseW, INTERNET_MAX_URL_LENGTH); MultiByteToWideChar(CP_ACP, 0, relative, -1, relativeW, INTERNET_MAX_URL_LENGTH); len = *combined_len;
hr = UrlCombineW(baseW, relativeW, combined ? combinedW : NULL, &len, flags); if (hr != S_OK) { *combined_len = len; heap_free(baseW); return hr; }
len2 = WideCharToMultiByte(CP_ACP, 0, combinedW, len, NULL, 0, NULL, NULL); if (len2 > *combined_len) { *combined_len = len2; heap_free(baseW); return E_POINTER; } WideCharToMultiByte(CP_ACP, 0, combinedW, len+1, combined, *combined_len + 1, NULL, NULL); *combined_len = len2; heap_free(baseW); return S_OK;}
HRESULT WINAPI UrlCombineW(const WCHAR *baseW, const WCHAR *relativeW, WCHAR *combined, DWORD *combined_len, DWORD flags){ DWORD i, len, process_case = 0, myflags, sizeloc = 0; LPWSTR work, preliminary, mbase, canonicalized; PARSEDURLW base, relative; HRESULT hr;
TRACE("%s, %s, %ld, %#lx\n", debugstr_w(baseW), debugstr_w(relativeW), combined_len ? *combined_len : 0, flags);
if (!baseW || !relativeW || !combined_len) return E_INVALIDARG;
base.cbSize = sizeof(base); relative.cbSize = sizeof(relative);
/* Get space for duplicates of the input and the output */ preliminary = heap_alloc(3 * INTERNET_MAX_URL_LENGTH * sizeof(WCHAR)); mbase = preliminary + INTERNET_MAX_URL_LENGTH; canonicalized = mbase + INTERNET_MAX_URL_LENGTH; *preliminary = '\0';
/* Canonicalize the base input prior to looking for the scheme */ myflags = flags & (URL_DONT_SIMPLIFY | URL_UNESCAPE); len = INTERNET_MAX_URL_LENGTH; UrlCanonicalizeW(baseW, mbase, &len, myflags);
/* See if the base has a scheme */ if (ParseURLW(mbase, &base) != S_OK) { /* If base has no scheme return relative. */ TRACE("no scheme detected in Base\n"); process_case = 1; } else do { BOOL manual_search = FALSE;
work = (LPWSTR)base.pszProtocol; for (i = 0; i < base.cchProtocol; ++i) work[i] = RtlDowncaseUnicodeChar(work[i]);
/* mk is a special case */ if (base.nScheme == URL_SCHEME_MK) { WCHAR *ptr = wcsstr(base.pszSuffix, L"::"); if (ptr) { int delta;
ptr += 2; delta = ptr-base.pszSuffix; base.cchProtocol += delta; base.pszSuffix += delta; base.cchSuffix -= delta; } } else { /* get size of location field (if it exists) */ work = (LPWSTR)base.pszSuffix; sizeloc = 0; if (*work++ == '/') { if (*work++ == '/') { /* At this point have start of location and * it ends at next '/' or end of string. */ while (*work && (*work != '/')) work++; sizeloc = (DWORD)(work - base.pszSuffix); } } }
/* If there is a '?', then the remaining part can only contain a * query string or fragment, so start looking for the last leaf * from the '?'. Otherwise, if there is a '#' and the characters * immediately preceding it are ".htm[l]", then begin looking for * the last leaf starting from the '#'. Otherwise the '#' is not * meaningful and just start looking from the end. */ if ((work = wcspbrk(base.pszSuffix + sizeloc, L"#?"))) { if (*work == '?' || base.nScheme == URL_SCHEME_HTTP || base.nScheme == URL_SCHEME_HTTPS) manual_search = TRUE; else if (work - base.pszSuffix > 4) { if (!wcsnicmp(work - 4, L".htm", 4)) manual_search = TRUE; }
if (!manual_search && work - base.pszSuffix > 5) { if (!wcsnicmp(work - 5, L".html", 5)) manual_search = TRUE; } }
if (manual_search) { /* search backwards starting from the current position */ while (*work != '/' && work > base.pszSuffix + sizeloc) --work; base.cchSuffix = work - base.pszSuffix + 1; } else { /* search backwards starting from the end of the string */ work = wcsrchr((base.pszSuffix+sizeloc), '/'); if (work) { len = (DWORD)(work - base.pszSuffix + 1); base.cchSuffix = len; } else base.cchSuffix = sizeloc; }
/* * At this point: * .pszSuffix points to location (starting with '//') * .cchSuffix length of location (above) and rest less the last * leaf (if any) * sizeloc length of location (above) up to but not including * the last '/' */
if (ParseURLW(relativeW, &relative) != S_OK) { /* No scheme in relative */ TRACE("no scheme detected in Relative\n"); relative.pszSuffix = relativeW; /* case 3,4,5 depends on this */ relative.cchSuffix = lstrlenW( relativeW ); if (*relativeW == ':') { /* Case that is either left alone or uses base. */ if (flags & URL_PLUGGABLE_PROTOCOL) { process_case = 5; break; } process_case = 1; break; } if (is_drive_spec( relativeW )) { /* case that becomes "file:///" */ lstrcpyW(preliminary, L"file:///"); process_case = 1; break; } if ((relativeW[0] == '/' || relativeW[0] == '\\') && (relativeW[1] == '/' || relativeW[1] == '\\')) { /* Relative has location and the rest. */ process_case = 3; break; } if (*relativeW == '/' || *relativeW == '\\') { /* Relative is root to location. */ process_case = 4; break; } if (*relativeW == '#') { if (!(work = wcschr(base.pszSuffix+base.cchSuffix, '#'))) work = (LPWSTR)base.pszSuffix + lstrlenW(base.pszSuffix);
memcpy(preliminary, base.pszProtocol, (work-base.pszProtocol)*sizeof(WCHAR)); preliminary[work-base.pszProtocol] = '\0'; process_case = 1; break; } process_case = (*base.pszSuffix == '/' || base.nScheme == URL_SCHEME_MK) ? 5 : 3; break; } else { work = (LPWSTR)relative.pszProtocol; for (i = 0; i < relative.cchProtocol; ++i) work[i] = RtlDowncaseUnicodeChar(work[i]); }
/* Handle cases where relative has scheme. */ if ((base.cchProtocol == relative.cchProtocol) && !wcsncmp(base.pszProtocol, relative.pszProtocol, base.cchProtocol)) { /* since the schemes are the same */ if (*relative.pszSuffix == '/' && *(relative.pszSuffix+1) == '/') { /* Relative replaces location and what follows. */ process_case = 3; break; } if (*relative.pszSuffix == '/') { /* Relative is root to location */ process_case = 4; break; } /* replace either just location if base's location starts with a * slash or otherwise everything */ process_case = (*base.pszSuffix == '/') ? 5 : 1; break; }
if (*relative.pszSuffix == '/' && *(relative.pszSuffix+1) == '/') { /* Relative replaces scheme, location, and following and handles PLUGGABLE */ process_case = 2; break; } process_case = 1; break; } while (FALSE); /* a little trick to allow easy exit from nested if's */
hr = S_OK; switch (process_case) { case 1: /* Return relative appended to whatever is in combined (which may the string "file:///" */ lstrcatW(preliminary, relativeW); break;
case 2: /* Relative replaces scheme and location */ lstrcpyW(preliminary, relativeW); break;
case 3: /* Return the base scheme with relative. Basically keeps the scheme and replaces the domain and following. */ memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1)*sizeof(WCHAR)); work = preliminary + base.cchProtocol + 1; lstrcpyW(work, relative.pszSuffix); break;
case 4: /* Return the base scheme and location but everything after the location is relative. (Replace document from root on.) */ memcpy(preliminary, base.pszProtocol, (base.cchProtocol+1+sizeloc)*sizeof(WCHAR)); work = preliminary + base.cchProtocol + 1 + sizeloc; if (flags & URL_PLUGGABLE_PROTOCOL) *(work++) = '/'; lstrcpyW(work, relative.pszSuffix); break;
case 5: /* Return the base without its document (if any) and append relative after its scheme. */ memcpy(preliminary, base.pszProtocol, (base.cchProtocol + 1 + base.cchSuffix)*sizeof(WCHAR)); work = preliminary + base.cchProtocol + 1 + base.cchSuffix - 1; if (*work++ != '/') *(work++) = '/'; lstrcpyW(work, relative.pszSuffix); break;
default: FIXME("Unexpected case %ld.\n", process_case); hr = E_INVALIDARG; }
if (hr == S_OK) { if (*combined_len == 0) *combined_len = 1; hr = UrlCanonicalizeW(preliminary, canonicalized, combined_len, flags & ~URL_FILE_USE_PATHURL); if (SUCCEEDED(hr) && combined) lstrcpyW( combined, canonicalized );
TRACE("return-%ld len=%ld, %s\n", process_case, *combined_len, debugstr_w(combined)); }
heap_free(preliminary); return hr;}
HRESULT WINAPI HashData(const unsigned char *src, DWORD src_len, unsigned char *dest, DWORD dest_len){ INT src_count = src_len - 1, dest_count = dest_len - 1;
if (!src || !dest) return E_INVALIDARG;
while (dest_count >= 0) { dest[dest_count] = (dest_count & 0xff); dest_count--; }
while (src_count >= 0) { dest_count = dest_len - 1; while (dest_count >= 0) { dest[dest_count] = hashdata_lookup[src[src_count] ^ dest[dest_count]]; dest_count--; } src_count--; }
return S_OK;}
HRESULT WINAPI UrlHashA(const char *url, unsigned char *dest, DWORD dest_len){ __TRY { HashData((const BYTE *)url, (int)strlen(url), dest, dest_len); } __EXCEPT_PAGE_FAULT { return E_INVALIDARG; } __ENDTRY return S_OK;}
HRESULT WINAPI UrlHashW(const WCHAR *url, unsigned char *dest, DWORD dest_len){ char urlA[MAX_PATH];
TRACE("%s, %p, %ld\n", debugstr_w(url), dest, dest_len);
__TRY { WideCharToMultiByte(CP_ACP, 0, url, -1, urlA, MAX_PATH, NULL, NULL); HashData((const BYTE *)urlA, (int)strlen(urlA), dest, dest_len); } __EXCEPT_PAGE_FAULT { return E_INVALIDARG; } __ENDTRY return S_OK;}
BOOL WINAPI IsInternetESCEnabled(void){ FIXME(": stub\n"); return FALSE;}
#endif // !STATIC_PATHCCH