Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324/* * * Copyright 1997 Marcus Meissner * Copyright 1998 Juergen Schmied * Copyright 2005 Mike McCormack * Copyright 2009 Andrew Hill * Copyright 2013 Dominik Hornung * Copyright 2017 Hermes Belusca-Maito * Copyright 2018-2024 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com> * * 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 * * NOTES * Nearly complete information about the binary formats * of .lnk files available at http://www.wotsit.org * * You can use winedump to examine the contents of a link file: * winedump lnk sc.lnk * * MSI advertised shortcuts are totally undocumented. They provide an * icon for a program that is not yet installed, and invoke MSI to * install the program when the shortcut is clicked on. They are * created by passing a special string to SetPath, and the information * in that string is parsed an stored. *//* * In the following is listed more documentation about the Shell Link file format, * as well as its interface. * * General introduction about "Shell Links" (MSDN): * https://learn.microsoft.com/en-us/windows/win32/shell/links * * * Details of the file format: * * - Official MSDN documentation "[MS-SHLLINK]: Shell Link (.LNK) Binary File Format": * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/16cb4ca1-9339-4d0c-a68d-bf1d6cc0f943 * * - Forensics: * http://forensicswiki.org/wiki/LNK * http://computerforensics.parsonage.co.uk/downloads/TheMeaningofLIFE.pdf * https://ithreats.files.wordpress.com/2009/05/lnk_the_windows_shortcut_file_format.pdf * https://github.com/libyal/liblnk/blob/master/documentation/Windows%20Shortcut%20File%20(LNK)%20format.asciidoc * * - List of possible shell link header flags (SHELL_LINK_DATA_FLAGS enumeration): * https://learn.microsoft.com/en-us/windows/win32/api/shlobj_core/ne-shlobj_core-shell_link_data_flags * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/ae350202-3ba9-4790-9e9e-98935f4ee5af * * * In addition to storing its target by using a PIDL, a shell link file also * stores metadata to make the shell able to track the link target, in situations * where the link target is moved amongst local or network directories, or moved * to different volumes. For this, two structures are used: * * - The first and oldest one (from NewShell/WinNT4) is the "LinkInfo" structure, * stored in a serialized manner at the beginning of the shell link file: * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/6813269d-0cc8-4be2-933f-e96e8e3412dc * The official API for manipulating this is located in LINKINFO.DLL . * * - The second, more recent one, is an extra binary block appended to the * extra-data list of the shell link file: this is the "TrackerDataBlock": * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/df8e3748-fba5-4524-968a-f72be06d71fc * Its purpose is for link tracking, and works in coordination with the * "Distributed Link Tracking" service ('TrkWks' client, 'TrkSvr' server). * See a detailed explanation at: * http://www.serverwatch.com/tutorials/article.php/1476701/Searching-for-the-Missing-Link-Distributed-Link-Tracking.htm * * * MSI installations most of the time create so-called "advertised shortcuts". * They provide an icon for a program that may not be installed yet, and invoke * MSI to install the program when the shortcut is opened (resolved). * The philosophy of this approach is explained in detail inside the MSDN article * "Application Resiliency: Unlock the Hidden Features of Windows Installer" * (by Michael Sanford), here: * https://learn.microsoft.com/en-us/previous-versions/dotnet/articles/aa302344(v=msdn.10) * * This functionality is implemented by adding a binary "Darwin" data block * of type "EXP_DARWIN_LINK", signature EXP_DARWIN_ID_SIG == 0xA0000006, * to the shell link file: * https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/48f8a4c4-99fe-4787-a39f-b1367103eba8 * or, this could be done more simply by specifying a special link target path * with the IShellLink::SetPath() function. Defining the following GUID: * SHELL32_AdvtShortcutComponent = "::{9db1186e-40df-11d1-aa8c-00c04fb67863}:" * setting a target of the form: * "::{SHELL32_AdvtShortcutComponent}:<MSI_App_ID>" * would automatically create the necessary binary block. * * With that, the target of the shortcut now becomes the MSI data. The latter * is parsed from MSI and retrieved by the shell that then can run the program. * * This MSI functionality, dubbed "link blessing", actually originates from an * older technology introduced in Internet Explorer 3 (and now obsolete since * Internet Explorer 7), called "MS Internet Component Download (MSICD)", see * this MSDN introductory article: * https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa741198(v=vs.85) * and leveraged in Internet Explorer 4 with "Software Update Channels", see: * https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa740931(v=vs.85) * Applications supporting this technology could present shell links having * a special target, see subsection "Modifying the Shortcut" in the article: * https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa741201(v=vs.85)#pub_shor * * Similarly as for the MSI shortcuts, these MSICD shortcuts are created by * specifying a special link target path with the IShellLink::SetPath() function, * defining the following GUID: * SHELL32_AdvtShortcutProduct = "::{9db1186f-40df-11d1-aa8c-00c04fb67863}:" * and setting a target of the form: * "::{SHELL32_AdvtShortcutProduct}:<AppName>::<Path>" . * A tool, called "blesslnk.exe", was also provided for automatizing the process; * its ReadMe can be found in the (now outdated) MS "Internet Client SDK" (INetSDK, * for MS Windows 95 and NT), whose contents can be read at: * http://www.msfn.org/board/topic/145352-new-windows-lnk-vulnerability/?page=4#comment-944223 * The MS INetSDK can be found at: * https://web.archive.org/web/20100924000013/http://support.microsoft.com/kb/177877 * * Internally the shell link target of these MSICD shortcuts is converted into * a binary data block of a type similar to Darwin / "EXP_DARWIN_LINK", but with * a different signature EXP_LOGO3_ID_SIG == 0xA0000007 . Such shell links are * called "Logo3" shortcuts. They were evoked in this user comment in "The Old * New Thing" blog: * https://web.archive.org/web/20190110073640/https://blogs.msdn.microsoft.com/oldnewthing/20121210-00/?p=5883#comment-1025083 * * The shell exports the API 'SoftwareUpdateMessageBox' (in shdocvw.dll) that * displays a message when an update for an application supporting this * technology is available. * */
#include "precomp.h"
#include <appmgmt.h>
WINE_DEFAULT_DEBUG_CHANNEL(shell);
/* * Allows to define whether or not Windows-compatible behaviour * should be adopted when setting and retrieving icon location paths. * See CShellLink::SetIconLocation(LPCWSTR pszIconPath, INT iIcon) * for more details. */#define ICON_LINK_WINDOWS_COMPAT
#define SHLINK_LOCAL 0#define SHLINK_REMOTE 1
/* link file formats */
#include "pshpack1.h"
struct LOCATION_INFO{ DWORD dwTotalSize; DWORD dwHeaderSize; DWORD dwFlags; DWORD dwVolTableOfs; DWORD dwLocalPathOfs; DWORD dwNetworkVolTableOfs; DWORD dwFinalPathOfs;};
struct LOCAL_VOLUME_INFO{ DWORD dwSize; DWORD dwType; DWORD dwVolSerial; DWORD dwVolLabelOfs;};
struct volume_info{ DWORD type; DWORD serial; WCHAR label[12]; /* assume 8.3 */};
#include "poppack.h"
/* IShellLink Implementation */
static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
/* strdup on the process heap */static LPWSTR __inline HEAP_strdupAtoW(HANDLE heap, DWORD flags, LPCSTR str){ INT len; LPWSTR p;
assert(str);
len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0); p = (LPWSTR)HeapAlloc(heap, flags, len * sizeof(WCHAR)); if (!p) return p; MultiByteToWideChar(CP_ACP, 0, str, -1, p, len); return p;}
static LPWSTR __inline strdupW(LPCWSTR src){ LPWSTR dest; if (!src) return NULL; dest = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wcslen(src) + 1) * sizeof(WCHAR)); if (dest) wcscpy(dest, src); return dest;}
static BOOL PathEnvSubstIsDirectory(LPCWSTR pszPath){ // Note: Don't call SHExpandEnvironmentStringsW here, we need the required length WCHAR szStack[MAX_PATH]; DWORD cch = ExpandEnvironmentStringsW(pszPath, szStack, _countof(szStack)); if (cch <= _countof(szStack)) return cch && PathIsDirectory(szStack);
PWSTR szHeap = (PWSTR)SHAlloc(cch); if (!szHeap) return FALSE; BOOL bResult = ExpandEnvironmentStringsW(pszPath, szHeap, cch) && PathIsDirectory(szHeap); SHFree(szHeap); return bResult;}
// TODO: Use it for constructor & destructor tooVOID CShellLink::Reset(){ ILFree(m_pPidl); m_pPidl = NULL;
HeapFree(GetProcessHeap(), 0, m_sPath); m_sPath = NULL; ZeroMemory(&volume, sizeof(volume));
HeapFree(GetProcessHeap(), 0, m_sDescription); m_sDescription = NULL; HeapFree(GetProcessHeap(), 0, m_sPathRel); m_sPathRel = NULL; HeapFree(GetProcessHeap(), 0, m_sWorkDir); m_sWorkDir = NULL; HeapFree(GetProcessHeap(), 0, m_sArgs); m_sArgs = NULL; HeapFree(GetProcessHeap(), 0, m_sIcoPath); m_sIcoPath = NULL;
m_bRunAs = FALSE; m_bDirty = FALSE;
if (m_pDBList) SHFreeDataBlockList(m_pDBList); m_pDBList = NULL;
/**/sProduct = sComponent = NULL;/**/}
CShellLink::CShellLink(){ m_Header.dwSize = sizeof(m_Header); m_Header.clsid = CLSID_ShellLink; m_Header.dwFlags = 0;
m_Header.dwFileAttributes = 0; ZeroMemory(&m_Header.ftCreationTime, sizeof(m_Header.ftCreationTime)); ZeroMemory(&m_Header.ftLastAccessTime, sizeof(m_Header.ftLastAccessTime)); ZeroMemory(&m_Header.ftLastWriteTime, sizeof(m_Header.ftLastWriteTime)); m_Header.nFileSizeLow = 0;
m_Header.nIconIndex = 0; m_Header.nShowCommand = SW_SHOWNORMAL; m_Header.wHotKey = 0;
m_pPidl = NULL;
m_sPath = NULL; ZeroMemory(&volume, sizeof(volume));
m_sDescription = NULL; m_sPathRel = NULL; m_sWorkDir = NULL; m_sArgs = NULL; m_sIcoPath = NULL; m_bRunAs = FALSE; m_bDirty = FALSE; m_pDBList = NULL; m_bInInit = FALSE; m_hIcon = NULL;
m_sLinkPath = NULL;
/**/sProduct = sComponent = NULL;/**/}
CShellLink::~CShellLink(){ TRACE("-- destroying IShellLink(%p)\n", this);
ILFree(m_pPidl);
HeapFree(GetProcessHeap(), 0, m_sPath);
HeapFree(GetProcessHeap(), 0, m_sDescription); HeapFree(GetProcessHeap(), 0, m_sPathRel); HeapFree(GetProcessHeap(), 0, m_sWorkDir); HeapFree(GetProcessHeap(), 0, m_sArgs); HeapFree(GetProcessHeap(), 0, m_sIcoPath); HeapFree(GetProcessHeap(), 0, m_sLinkPath); SHFreeDataBlockList(m_pDBList);}
HRESULT STDMETHODCALLTYPE CShellLink::GetClassID(CLSID *pclsid){ TRACE("%p %p\n", this, pclsid);
if (pclsid == NULL) return E_POINTER; *pclsid = CLSID_ShellLink; return S_OK;}
/************************************************************************ * IPersistStream_IsDirty (IPersistStream) */HRESULT STDMETHODCALLTYPE CShellLink::IsDirty(){ TRACE("(%p)\n", this); return (m_bDirty ? S_OK : S_FALSE);}
HRESULT STDMETHODCALLTYPE CShellLink::Load(LPCOLESTR pszFileName, DWORD dwMode){ TRACE("(%p, %s, %x)\n", this, debugstr_w(pszFileName), dwMode);
if (dwMode == 0) dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
CComPtr<IStream> stm; HRESULT hr = SHCreateStreamOnFileW(pszFileName, dwMode, &stm); if (SUCCEEDED(hr)) { HeapFree(GetProcessHeap(), 0, m_sLinkPath); m_sLinkPath = strdupW(pszFileName); hr = Load(stm); ShellLink_UpdatePath(m_sPathRel, pszFileName, m_sWorkDir, &m_sPath); m_bDirty = FALSE; } TRACE("-- returning hr %08x\n", hr); return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::Save(LPCOLESTR pszFileName, BOOL fRemember){ BOOL bAlreadyExists; WCHAR szFullPath[MAX_PATH];
TRACE("(%p)->(%s)\n", this, debugstr_w(pszFileName));
if (!pszFileName) return E_FAIL;
bAlreadyExists = PathFileExistsW(pszFileName);
CComPtr<IStream> stm; HRESULT hr = SHCreateStreamOnFileW(pszFileName, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &stm); if (SUCCEEDED(hr)) { hr = Save(stm, FALSE);
if (SUCCEEDED(hr)) { GetFullPathNameW(pszFileName, _countof(szFullPath), szFullPath, NULL); if (bAlreadyExists) SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATHW, szFullPath, NULL); else SHChangeNotify(SHCNE_CREATE, SHCNF_PATHW, szFullPath, NULL);
if (m_sLinkPath) HeapFree(GetProcessHeap(), 0, m_sLinkPath);
m_sLinkPath = strdupW(pszFileName); m_bDirty = FALSE; } else { DeleteFileW(pszFileName); WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName)); } }
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SaveCompleted(LPCOLESTR pszFileName){ FIXME("(%p)->(%s)\n", this, debugstr_w(pszFileName)); return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetCurFile(LPOLESTR *ppszFileName){ *ppszFileName = NULL;
if (!m_sLinkPath) { /* IPersistFile::GetCurFile called before IPersistFile::Save */ return S_FALSE; }
*ppszFileName = (LPOLESTR)CoTaskMemAlloc((wcslen(m_sLinkPath) + 1) * sizeof(WCHAR)); if (!*ppszFileName) { /* out of memory */ return E_OUTOFMEMORY; }
/* copy last saved filename */ wcscpy(*ppszFileName, m_sLinkPath);
return S_OK;}
static HRESULT Stream_LoadString(IStream* stm, BOOL unicode, LPWSTR *pstr){ TRACE("%p\n", stm);
USHORT len; DWORD count = 0; HRESULT hr = stm->Read(&len, sizeof(len), &count); if (FAILED(hr) || count != sizeof(len)) return E_FAIL;
if (unicode) len *= sizeof(WCHAR);
TRACE("reading %d\n", len); LPSTR temp = (LPSTR)HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR)); if (!temp) return E_OUTOFMEMORY; count = 0; hr = stm->Read(temp, len, &count); if (FAILED(hr) || count != len) { HeapFree(GetProcessHeap(), 0, temp); return E_FAIL; }
TRACE("read %s\n", debugstr_an(temp, len));
/* convert to unicode if necessary */ LPWSTR str; if (!unicode) { count = MultiByteToWideChar(CP_ACP, 0, temp, len, NULL, 0); str = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (count + 1) * sizeof(WCHAR)); if (!str) { HeapFree(GetProcessHeap(), 0, temp); return E_OUTOFMEMORY; } MultiByteToWideChar(CP_ACP, 0, temp, len, str, count); HeapFree(GetProcessHeap(), 0, temp); } else { count /= sizeof(WCHAR); str = (LPWSTR)temp; } str[count] = 0;
*pstr = str;
return S_OK;}
/* * NOTE: The following 5 functions are part of LINKINFO.DLL */static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, CShellLink::volume_info *volume){ WCHAR drive[4] = { path[0], ':', '\\', 0 };
volume->type = GetDriveTypeW(drive); BOOL bRet = GetVolumeInformationW(drive, volume->label, _countof(volume->label), &volume->serial, NULL, NULL, NULL, 0); TRACE("ret = %d type %d serial %08x name %s\n", bRet, volume->type, volume->serial, debugstr_w(volume->label)); return bRet;}
static HRESULT Stream_ReadChunk(IStream* stm, LPVOID *data){ struct sized_chunk { DWORD size; unsigned char data[1]; } *chunk;
TRACE("%p\n", stm);
DWORD size; ULONG count; HRESULT hr = stm->Read(&size, sizeof(size), &count); if (FAILED(hr) || count != sizeof(size)) return E_FAIL;
chunk = static_cast<sized_chunk *>(HeapAlloc(GetProcessHeap(), 0, size)); if (!chunk) return E_OUTOFMEMORY;
chunk->size = size; hr = stm->Read(chunk->data, size - sizeof(size), &count); if (FAILED(hr) || count != (size - sizeof(size))) { HeapFree(GetProcessHeap(), 0, chunk); return E_FAIL; }
TRACE("Read %d bytes\n", chunk->size);
*data = chunk;
return S_OK;}
static BOOL Stream_LoadVolume(LOCAL_VOLUME_INFO *vol, CShellLink::volume_info *volume){ volume->serial = vol->dwVolSerial; volume->type = vol->dwType;
if (!vol->dwVolLabelOfs) return FALSE; if (vol->dwSize <= vol->dwVolLabelOfs) return FALSE; INT len = vol->dwSize - vol->dwVolLabelOfs;
LPSTR label = (LPSTR)vol; label += vol->dwVolLabelOfs; // FIXME: 0x14 Unicode MultiByteToWideChar(CP_ACP, 0, label, len, volume->label, _countof(volume->label));
return TRUE;}
static LPWSTR Stream_LoadPath(LPCSTR p, DWORD maxlen){ UINT len = 0;
while (len < maxlen && p[len]) len++;
UINT wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0); LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, (wlen + 1) * sizeof(WCHAR)); if (!path) return NULL; MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen); path[wlen] = 0;
return path;}
static HRESULT Stream_LoadLocation(IStream *stm, CShellLink::volume_info *volume, LPWSTR *path){ char *p = NULL; HRESULT hr = Stream_ReadChunk(stm, (LPVOID*) &p); if (FAILED(hr)) return hr;
LOCATION_INFO *loc = reinterpret_cast<LOCATION_INFO *>(p); if (loc->dwTotalSize < sizeof(LOCATION_INFO)) { HeapFree(GetProcessHeap(), 0, p); return E_FAIL; }
/* if there's valid local volume information, load it */ if (loc->dwVolTableOfs && ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize)) { LOCAL_VOLUME_INFO *volume_info;
volume_info = (LOCAL_VOLUME_INFO*) &p[loc->dwVolTableOfs]; Stream_LoadVolume(volume_info, volume); }
/* if there's a local path, load it */ DWORD n = loc->dwLocalPathOfs; if (n && n < loc->dwTotalSize) *path = Stream_LoadPath(&p[n], loc->dwTotalSize - n); // FIXME: Unicode offset (if present)
TRACE("type %d serial %08x name %s path %s\n", volume->type, volume->serial, debugstr_w(volume->label), debugstr_w(*path));
HeapFree(GetProcessHeap(), 0, p); return S_OK;}
/* * The format of the advertised shortcut info is: * * Offset Description * ------ ----------- * 0 Length of the block (4 bytes, usually 0x314) * 4 tag (dword) * 8 string data in ASCII * 8+0x104 string data in UNICODE * * In the original Win32 implementation the buffers are not initialized * to zero, so data trailing the string is random garbage. */HRESULT CShellLink::GetAdvertiseInfo(LPWSTR *str, DWORD dwSig){ LPEXP_DARWIN_LINK pInfo;
*str = NULL;
pInfo = (LPEXP_DARWIN_LINK)SHFindDataBlock(m_pDBList, dwSig); if (!pInfo) return E_FAIL;
/* Make sure that the size of the structure is valid */ if (pInfo->dbh.cbSize != sizeof(*pInfo)) { ERR("Ooops. This structure is not as expected...\n"); return E_FAIL; }
TRACE("dwSig %08x string = '%s'\n", pInfo->dbh.dwSignature, debugstr_w(pInfo->szwDarwinID));
*str = pInfo->szwDarwinID; return S_OK;}
/************************************************************************ * IPersistStream_Load (IPersistStream) */HRESULT STDMETHODCALLTYPE CShellLink::Load(IStream *stm){ TRACE("%p %p\n", this, stm);
if (!stm) return STG_E_INVALIDPOINTER;
/* Free all the old stuff */ Reset();
ULONG dwBytesRead = 0; HRESULT hr = stm->Read(&m_Header, sizeof(m_Header), &dwBytesRead); if (FAILED(hr)) return hr;
if (dwBytesRead != sizeof(m_Header)) return E_FAIL; if (m_Header.dwSize != sizeof(m_Header)) return E_FAIL; if (!IsEqualIID(m_Header.clsid, CLSID_ShellLink)) return E_FAIL;
/* Load the new data in order */
if (TRACE_ON(shell)) { SYSTEMTIME stCreationTime; SYSTEMTIME stLastAccessTime; SYSTEMTIME stLastWriteTime; WCHAR sTemp[MAX_PATH];
FileTimeToSystemTime(&m_Header.ftCreationTime, &stCreationTime); FileTimeToSystemTime(&m_Header.ftLastAccessTime, &stLastAccessTime); FileTimeToSystemTime(&m_Header.ftLastWriteTime, &stLastWriteTime);
GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stCreationTime, NULL, sTemp, _countof(sTemp)); TRACE("-- stCreationTime: %s\n", debugstr_w(sTemp)); GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stLastAccessTime, NULL, sTemp, _countof(sTemp)); TRACE("-- stLastAccessTime: %s\n", debugstr_w(sTemp)); GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &stLastWriteTime, NULL, sTemp, _countof(sTemp)); TRACE("-- stLastWriteTime: %s\n", debugstr_w(sTemp)); }
/* load all the new stuff */ if (m_Header.dwFlags & SLDF_HAS_ID_LIST) { hr = ILLoadFromStream(stm, &m_pPidl); if (FAILED(hr)) return hr; } pdump(m_pPidl);
/* Load the location information... */ if (m_Header.dwFlags & SLDF_HAS_LINK_INFO) { hr = Stream_LoadLocation(stm, &volume, &m_sPath); if (FAILED(hr)) return hr; } /* ... but if it is required not to use it, clear it */ if (m_Header.dwFlags & SLDF_FORCE_NO_LINKINFO) { HeapFree(GetProcessHeap(), 0, m_sPath); m_sPath = NULL; ZeroMemory(&volume, sizeof(volume)); }
BOOL unicode = !!(m_Header.dwFlags & SLDF_UNICODE);
if (m_Header.dwFlags & SLDF_HAS_NAME) { hr = Stream_LoadString(stm, unicode, &m_sDescription); if (FAILED(hr)) return hr; TRACE("Description -> %s\n", debugstr_w(m_sDescription)); }
if (m_Header.dwFlags & SLDF_HAS_RELPATH) { hr = Stream_LoadString(stm, unicode, &m_sPathRel); if (FAILED(hr)) return hr; TRACE("Relative Path-> %s\n", debugstr_w(m_sPathRel)); }
if (m_Header.dwFlags & SLDF_HAS_WORKINGDIR) { hr = Stream_LoadString(stm, unicode, &m_sWorkDir); if (FAILED(hr)) return hr; PathRemoveBackslash(m_sWorkDir); TRACE("Working Dir -> %s\n", debugstr_w(m_sWorkDir)); }
if (m_Header.dwFlags & SLDF_HAS_ARGS) { hr = Stream_LoadString(stm, unicode, &m_sArgs); if (FAILED(hr)) return hr; TRACE("Arguments -> %s\n", debugstr_w(m_sArgs)); }
if (m_Header.dwFlags & SLDF_HAS_ICONLOCATION) { hr = Stream_LoadString(stm, unicode, &m_sIcoPath); if (FAILED(hr)) return hr; TRACE("Icon file -> %s\n", debugstr_w(m_sIcoPath)); }
/* Now load the optional data block list */ hr = SHReadDataBlockList(stm, &m_pDBList); if (FAILED(hr)) // FIXME: Should we fail? return hr;
LPEXP_SPECIAL_FOLDER pSpecial = (LPEXP_SPECIAL_FOLDER)SHFindDataBlock(m_pDBList, EXP_SPECIAL_FOLDER_SIG); if (pSpecial && pSpecial->cbSize == sizeof(*pSpecial) && ILGetSize(m_pPidl) > pSpecial->cbOffset) { if (LPITEMIDLIST folder = SHCloneSpecialIDList(NULL, pSpecial->idSpecialFolder, FALSE)) { LPITEMIDLIST pidl = ILCombine(folder, (LPITEMIDLIST)((char*)m_pPidl + pSpecial->cbOffset)); if (pidl) { ILFree(m_pPidl); m_pPidl = pidl; TRACE("Replaced pidl base with CSIDL %u up to %ub.\n", pSpecial->idSpecialFolder, pSpecial->cbOffset); } ILFree(folder); } }
if (TRACE_ON(shell)) {#if (NTDDI_VERSION < NTDDI_LONGHORN) if (m_Header.dwFlags & SLDF_HAS_LOGO3ID) { hr = GetAdvertiseInfo(&sProduct, EXP_LOGO3_ID_SIG); if (SUCCEEDED(hr)) TRACE("Product -> %s\n", debugstr_w(sProduct)); }#endif if (m_Header.dwFlags & SLDF_HAS_DARWINID) { hr = GetAdvertiseInfo(&sComponent, EXP_DARWIN_ID_SIG); if (SUCCEEDED(hr)) TRACE("Component -> %s\n", debugstr_w(sComponent)); } }
if (m_Header.dwFlags & SLDF_RUNAS_USER) m_bRunAs = TRUE; else m_bRunAs = FALSE;
TRACE("OK\n");
pdump(m_pPidl);
return S_OK;}
/************************************************************************ * Stream_WriteString * * Helper function for IPersistStream_Save. Writes a unicode string * with terminating nul byte to a stream, preceded by the its length. */static HRESULT Stream_WriteString(IStream* stm, LPCWSTR str){ SIZE_T length; USHORT len; DWORD count;
length = wcslen(str) + 1; if (length > MAXUSHORT) { return E_INVALIDARG; }
len = (USHORT)length; HRESULT hr = stm->Write(&len, sizeof(len), &count); if (FAILED(hr)) return hr;
length *= sizeof(WCHAR);
hr = stm->Write(str, (ULONG)length, &count); if (FAILED(hr)) return hr;
return S_OK;}
/************************************************************************ * Stream_WriteLocationInfo * * Writes the location info to a stream * * FIXME: One day we might want to write the network volume information * and the final path. * Figure out how Windows deals with unicode paths here. */static HRESULT Stream_WriteLocationInfo(IStream* stm, LPCWSTR path, CShellLink::volume_info *volume) // FIXME: Write Unicode strings{ LOCAL_VOLUME_INFO *vol; LOCATION_INFO *loc;
TRACE("%p %s %p\n", stm, debugstr_w(path), volume);
/* figure out the size of everything */ DWORD label_size = WideCharToMultiByte(CP_ACP, 0, volume->label, -1, NULL, 0, NULL, NULL); DWORD path_size = WideCharToMultiByte(CP_ACP, 0, path, -1, NULL, 0, NULL, NULL); DWORD volume_info_size = sizeof(*vol) + label_size; DWORD final_path_size = 1; DWORD total_size = sizeof(*loc) + volume_info_size + path_size + final_path_size;
/* create pointers to everything */ loc = static_cast<LOCATION_INFO *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size)); vol = (LOCAL_VOLUME_INFO*) &loc[1]; LPSTR szLabel = (LPSTR) &vol[1]; LPSTR szPath = &szLabel[label_size]; LPSTR szFinalPath = &szPath[path_size];
/* fill in the location information header */ loc->dwTotalSize = total_size; loc->dwHeaderSize = sizeof(*loc); loc->dwFlags = 1; loc->dwVolTableOfs = sizeof(*loc); loc->dwLocalPathOfs = sizeof(*loc) + volume_info_size; loc->dwNetworkVolTableOfs = 0; loc->dwFinalPathOfs = sizeof(*loc) + volume_info_size + path_size;
/* fill in the volume information */ vol->dwSize = volume_info_size; vol->dwType = volume->type; vol->dwVolSerial = volume->serial; vol->dwVolLabelOfs = sizeof(*vol);
/* copy in the strings */ WideCharToMultiByte(CP_ACP, 0, volume->label, -1, szLabel, label_size, NULL, NULL); WideCharToMultiByte(CP_ACP, 0, path, -1, szPath, path_size, NULL, NULL); *szFinalPath = 0;
ULONG count = 0; HRESULT hr = stm->Write(loc, total_size, &count); HeapFree(GetProcessHeap(), 0, loc);
return hr;}
/************************************************************************ * IPersistStream_Save (IPersistStream) * * FIXME: makes assumptions about byte order */HRESULT STDMETHODCALLTYPE CShellLink::Save(IStream *stm, BOOL fClearDirty){ TRACE("%p %p %x\n", this, stm, fClearDirty);
m_Header.dwSize = sizeof(m_Header); m_Header.clsid = CLSID_ShellLink; m_Header.dwReserved3 = m_Header.dwReserved2 = m_Header.wReserved1 = 0;
/* Store target attributes */ WIN32_FIND_DATAW wfd = {}; WCHAR FsTarget[MAX_PATH]; if (GetPath(FsTarget, _countof(FsTarget), NULL, 0) == S_OK && PathFileExistsW(FsTarget)) { HANDLE hFind = FindFirstFileW(FsTarget, &wfd); if (hFind != INVALID_HANDLE_VALUE) FindClose(hFind); } m_Header.dwFileAttributes = wfd.dwFileAttributes; m_Header.ftCreationTime = wfd.ftCreationTime; m_Header.ftLastAccessTime = wfd.ftLastAccessTime; m_Header.ftLastWriteTime = wfd.ftLastWriteTime; m_Header.nFileSizeLow = wfd.nFileSizeLow;
/* * Reset the flags: keep only the flags related to data blocks as they were * already set in accordance by the different mutator member functions. * The other flags will be determined now by the presence or absence of data. */ UINT NT6SimpleFlags = LOBYTE(GetVersion()) > 6 ? (0x00040000 | 0x00400000 | 0x00800000 | 0x02000000) : 0; m_Header.dwFlags &= (SLDF_RUN_WITH_SHIMLAYER | SLDF_RUNAS_USER | SLDF_RUN_IN_SEPARATE | SLDF_HAS_DARWINID | SLDF_FORCE_NO_LINKINFO | NT6SimpleFlags |#if (NTDDI_VERSION < NTDDI_LONGHORN) SLDF_HAS_LOGO3ID |#endif SLDF_HAS_EXP_ICON_SZ | SLDF_HAS_EXP_SZ); // TODO: When we will support Vista+ functionality, add other flags to this list.
/* The stored strings are in UNICODE */ m_Header.dwFlags |= SLDF_UNICODE;
if (m_pPidl) m_Header.dwFlags |= SLDF_HAS_ID_LIST; if (m_sPath && *m_sPath && !(m_Header.dwFlags & SLDF_FORCE_NO_LINKINFO)) m_Header.dwFlags |= SLDF_HAS_LINK_INFO; if (m_sDescription && *m_sDescription) m_Header.dwFlags |= SLDF_HAS_NAME; if (m_sPathRel && *m_sPathRel) m_Header.dwFlags |= SLDF_HAS_RELPATH; if (m_sWorkDir && *m_sWorkDir) m_Header.dwFlags |= SLDF_HAS_WORKINGDIR; if (m_sArgs && *m_sArgs) m_Header.dwFlags |= SLDF_HAS_ARGS; if (m_sIcoPath && *m_sIcoPath) m_Header.dwFlags |= SLDF_HAS_ICONLOCATION; if (m_bRunAs) m_Header.dwFlags |= SLDF_RUNAS_USER;
/* Write the shortcut header */ ULONG count; HRESULT hr = stm->Write(&m_Header, sizeof(m_Header), &count); if (FAILED(hr)) { ERR("Write failed\n"); return hr; }
/* Save the data in order */
if (m_pPidl) { hr = ILSaveToStream(stm, m_pPidl); if (FAILED(hr)) { ERR("Failed to write PIDL\n"); return hr; } }
if (m_Header.dwFlags & SLDF_HAS_LINK_INFO) { hr = Stream_WriteLocationInfo(stm, m_sPath, &volume); if (FAILED(hr)) return hr; }
if (m_Header.dwFlags & SLDF_HAS_NAME) { hr = Stream_WriteString(stm, m_sDescription); if (FAILED(hr)) return hr; }
if (m_Header.dwFlags & SLDF_HAS_RELPATH) { hr = Stream_WriteString(stm, m_sPathRel); if (FAILED(hr)) return hr; }
if (m_Header.dwFlags & SLDF_HAS_WORKINGDIR) { hr = Stream_WriteString(stm, m_sWorkDir); if (FAILED(hr)) return hr; }
if (m_Header.dwFlags & SLDF_HAS_ARGS) { hr = Stream_WriteString(stm, m_sArgs); if (FAILED(hr)) return hr; }
if (m_Header.dwFlags & SLDF_HAS_ICONLOCATION) { hr = Stream_WriteString(stm, m_sIcoPath); if (FAILED(hr)) return hr; }
/* * Now save the data block list. * * NOTE that both advertised Product and Component are already saved * inside Logo3 and Darwin data blocks in the m_pDBList list, and the * m_Header.dwFlags is suitably initialized. */ hr = SHWriteDataBlockList(stm, m_pDBList); if (FAILED(hr)) return hr;
/* Clear the dirty bit if requested */ if (fClearDirty) m_bDirty = FALSE;
return hr;}
/************************************************************************ * IPersistStream_GetSizeMax (IPersistStream) */HRESULT STDMETHODCALLTYPE CShellLink::GetSizeMax(ULARGE_INTEGER *pcbSize){ TRACE("(%p)\n", this); return E_NOTIMPL;}
static BOOL SHELL_ExistsFileW(LPCWSTR path){ if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path)) return FALSE;
return TRUE;}
/************************************************************************** * ShellLink_UpdatePath * update absolute path in sPath using relative path in sPathRel */static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath){ if (!path || !psPath) return E_INVALIDARG;
if (!*psPath && sPathRel) { WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH]; LPWSTR final = NULL;
/* first try if [directory of link file] + [relative path] finds an existing file */
GetFullPathNameW(path, MAX_PATH * 2, buffer, &final); if (!final) final = buffer; wcscpy(final, sPathRel);
*abs_path = '\0';
if (SHELL_ExistsFileW(buffer)) { if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final)) wcscpy(abs_path, buffer); } else { /* try if [working directory] + [relative path] finds an existing file */ if (sWorkDir) { wcscpy(buffer, sWorkDir); wcscpy(PathAddBackslashW(buffer), sPathRel);
if (SHELL_ExistsFileW(buffer)) if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final)) wcscpy(abs_path, buffer); } }
/* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */ if (!*abs_path) wcscpy(abs_path, sPathRel);
*psPath = strdupW(abs_path); if (!*psPath) return E_OUTOFMEMORY; }
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetPath(LPSTR pszFile, INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags){ HRESULT hr; LPWSTR pszFileW; WIN32_FIND_DATAW wfd;
TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n", this, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(m_sPath));
/* Allocate a temporary UNICODE buffer */ pszFileW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, max(cchMaxPath, MAX_PATH) * sizeof(WCHAR)); if (!pszFileW) return E_OUTOFMEMORY;
/* Call the UNICODE function */ hr = GetPath(pszFileW, cchMaxPath, &wfd, fFlags);
/* Convert the file path back to ANSI */ WideCharToMultiByte(CP_ACP, 0, pszFileW, -1, pszFile, cchMaxPath, NULL, NULL);
/* Free the temporary buffer */ HeapFree(GetProcessHeap(), 0, pszFileW);
if (pfd) { ZeroMemory(pfd, sizeof(*pfd));
/* Copy the file data if a file path was returned */ if (*pszFile) { DWORD len;
/* Copy the fixed part */ CopyMemory(pfd, &wfd, FIELD_OFFSET(WIN32_FIND_DATAA, cFileName));
/* Convert the file names to ANSI */ len = lstrlenW(wfd.cFileName); WideCharToMultiByte(CP_ACP, 0, wfd.cFileName, len + 1, pfd->cFileName, sizeof(pfd->cFileName), NULL, NULL); len = lstrlenW(wfd.cAlternateFileName); WideCharToMultiByte(CP_ACP, 0, wfd.cAlternateFileName, len + 1, pfd->cAlternateFileName, sizeof(pfd->cAlternateFileName), NULL, NULL); } }
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::GetIDList(PIDLIST_ABSOLUTE *ppidl){ TRACE("(%p)->(ppidl=%p)\n", this, ppidl);
if (!m_pPidl) { *ppidl = NULL; return S_FALSE; }
*ppidl = ILClone(m_pPidl); return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetIDList(PCIDLIST_ABSOLUTE pidl){ TRACE("(%p)->(pidl=%p)\n", this, pidl); return SetTargetFromPIDLOrPath(pidl, NULL);}
HRESULT STDMETHODCALLTYPE CShellLink::GetDescription(LPSTR pszName, INT cchMaxName){ TRACE("(%p)->(%p len=%u)\n", this, pszName, cchMaxName);
if (cchMaxName) *pszName = 0;
if (m_sDescription) WideCharToMultiByte(CP_ACP, 0, m_sDescription, -1, pszName, cchMaxName, NULL, NULL);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetDescription(LPCSTR pszName){ TRACE("(%p)->(pName=%s)\n", this, pszName);
HeapFree(GetProcessHeap(), 0, m_sDescription); m_sDescription = NULL;
if (pszName) { m_sDescription = HEAP_strdupAtoW(GetProcessHeap(), 0, pszName); if (!m_sDescription) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetWorkingDirectory(LPSTR pszDir, INT cchMaxPath){ TRACE("(%p)->(%p len=%u)\n", this, pszDir, cchMaxPath);
if (cchMaxPath) *pszDir = 0;
if (m_sWorkDir) WideCharToMultiByte(CP_ACP, 0, m_sWorkDir, -1, pszDir, cchMaxPath, NULL, NULL);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetWorkingDirectory(LPCSTR pszDir){ TRACE("(%p)->(dir=%s)\n", this, pszDir);
HeapFree(GetProcessHeap(), 0, m_sWorkDir); m_sWorkDir = NULL;
if (pszDir) { m_sWorkDir = HEAP_strdupAtoW(GetProcessHeap(), 0, pszDir); if (!m_sWorkDir) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetArguments(LPSTR pszArgs, INT cchMaxPath){ TRACE("(%p)->(%p len=%u)\n", this, pszArgs, cchMaxPath);
if (cchMaxPath) *pszArgs = 0;
if (m_sArgs) WideCharToMultiByte(CP_ACP, 0, m_sArgs, -1, pszArgs, cchMaxPath, NULL, NULL);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetArguments(LPCSTR pszArgs){ TRACE("(%p)->(args=%s)\n", this, pszArgs);
HeapFree(GetProcessHeap(), 0, m_sArgs); m_sArgs = NULL;
if (pszArgs) { m_sArgs = HEAP_strdupAtoW(GetProcessHeap(), 0, pszArgs); if (!m_sArgs) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetHotkey(WORD *pwHotkey){ TRACE("(%p)->(%p)(0x%08x)\n", this, pwHotkey, m_Header.wHotKey); *pwHotkey = m_Header.wHotKey; return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetHotkey(WORD wHotkey){ TRACE("(%p)->(hotkey=%x)\n", this, wHotkey);
m_Header.wHotKey = wHotkey; m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetShowCmd(INT *piShowCmd){ TRACE("(%p)->(%p) %d\n", this, piShowCmd, m_Header.nShowCommand); *piShowCmd = m_Header.nShowCommand; return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetShowCmd(INT iShowCmd){ TRACE("(%p) %d\n", this, iShowCmd);
m_Header.nShowCommand = iShowCmd; m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetIconLocation(LPSTR pszIconPath, INT cchIconPath, INT *piIcon){ HRESULT hr; LPWSTR pszIconPathW;
TRACE("(%p)->(%p len=%u iicon=%p)\n", this, pszIconPath, cchIconPath, piIcon);
/* Allocate a temporary UNICODE buffer */ pszIconPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, cchIconPath * sizeof(WCHAR)); if (!pszIconPathW) return E_OUTOFMEMORY;
/* Call the UNICODE function */ hr = GetIconLocation(pszIconPathW, cchIconPath, piIcon);
/* Convert the file path back to ANSI */ WideCharToMultiByte(CP_ACP, 0, pszIconPathW, -1, pszIconPath, cchIconPath, NULL, NULL);
/* Free the temporary buffer */ HeapFree(GetProcessHeap(), 0, pszIconPathW);
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::GetIconLocation(UINT uFlags, PSTR pszIconFile, UINT cchMax, int *piIndex, UINT *pwFlags){ HRESULT hr; LPWSTR pszIconFileW;
TRACE("(%p)->(%u %p len=%u piIndex=%p pwFlags=%p)\n", this, uFlags, pszIconFile, cchMax, piIndex, pwFlags);
/* Allocate a temporary UNICODE buffer */ pszIconFileW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, cchMax * sizeof(WCHAR)); if (!pszIconFileW) return E_OUTOFMEMORY;
/* Call the UNICODE function */ hr = GetIconLocation(uFlags, pszIconFileW, cchMax, piIndex, pwFlags);
/* Convert the file path back to ANSI */ WideCharToMultiByte(CP_ACP, 0, pszIconFileW, -1, pszIconFile, cchMax, NULL, NULL);
/* Free the temporary buffer */ HeapFree(GetProcessHeap(), 0, pszIconFileW);
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::Extract(PCSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize){ TRACE("(%p)->(path=%s iicon=%u)\n", this, pszFile, nIconIndex);
LPWSTR str = NULL; if (pszFile) { str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile); if (!str) return E_OUTOFMEMORY; }
HRESULT hr = Extract(str, nIconIndex, phiconLarge, phiconSmall, nIconSize);
if (str) HeapFree(GetProcessHeap(), 0, str);
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SetIconLocation(LPCSTR pszIconPath, INT iIcon){ TRACE("(%p)->(path=%s iicon=%u)\n", this, pszIconPath, iIcon);
LPWSTR str = NULL; if (pszIconPath) { str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath); if (!str) return E_OUTOFMEMORY; }
HRESULT hr = SetIconLocation(str, iIcon);
if (str) HeapFree(GetProcessHeap(), 0, str);
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SetRelativePath(LPCSTR pszPathRel, DWORD dwReserved){ TRACE("(%p)->(path=%s %x)\n", this, pszPathRel, dwReserved);
HeapFree(GetProcessHeap(), 0, m_sPathRel); m_sPathRel = NULL;
if (pszPathRel) { m_sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel); m_bDirty = TRUE; }
return ShellLink_UpdatePath(m_sPathRel, m_sPath, m_sWorkDir, &m_sPath);}
static LPWSTRshelllink_get_msi_component_path(LPWSTR component){ DWORD Result, sz = 0;
Result = CommandLineFromMsiDescriptor(component, NULL, &sz); if (Result != ERROR_SUCCESS) return NULL;
sz++; LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sz * sizeof(WCHAR)); Result = CommandLineFromMsiDescriptor(component, path, &sz); if (Result != ERROR_SUCCESS) { HeapFree(GetProcessHeap(), 0, path); path = NULL; }
TRACE("returning %s\n", debugstr_w(path));
return path;}
HRESULT STDMETHODCALLTYPE CShellLink::Resolve(HWND hwnd, DWORD fFlags){ HRESULT hr = S_OK; BOOL bSuccess;
TRACE("(%p)->(hwnd=%p flags=%x)\n", this, hwnd, fFlags);
/* FIXME: use IResolveShellLink interface? */
// FIXME: See InvokeCommand().
#if (NTDDI_VERSION < NTDDI_LONGHORN) // NOTE: For Logo3 (EXP_LOGO3_ID_SIG), check also for SHRestricted(REST_NOLOGO3CHANNELNOTIFY) if (m_Header.dwFlags & SLDF_HAS_LOGO3ID) { FIXME("Logo3 links are not supported yet!\n"); return E_FAIL; }#endif
/* Resolve Darwin (MSI) target */ if (m_Header.dwFlags & SLDF_HAS_DARWINID) { LPWSTR component = NULL; hr = GetAdvertiseInfo(&component, EXP_DARWIN_ID_SIG); if (FAILED(hr)) return E_FAIL;
/* Clear the cached path */ HeapFree(GetProcessHeap(), 0, m_sPath); m_sPath = shelllink_get_msi_component_path(component); if (!m_sPath) return E_FAIL; }
if (!m_sPath && m_pPidl) { WCHAR buffer[MAX_PATH];
bSuccess = SHGetPathFromIDListW(m_pPidl, buffer); if (bSuccess && *buffer) { m_sPath = strdupW(buffer); if (!m_sPath) return E_OUTOFMEMORY;
m_bDirty = TRUE; } else { hr = S_OK; /* don't report an error occurred while just caching information */ } }
// FIXME: Strange to do that here... if (!m_sIcoPath && m_sPath) { m_sIcoPath = strdupW(m_sPath); if (!m_sIcoPath) return E_OUTOFMEMORY;
m_Header.nIconIndex = 0;
m_bDirty = TRUE; }
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SetPath(LPCSTR pszFile){ TRACE("(%p)->(path=%s)\n", this, pszFile);
if (!pszFile) return E_INVALIDARG;
LPWSTR str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile); if (!str) return E_OUTOFMEMORY;
HRESULT hr = SetPath(str); HeapFree(GetProcessHeap(), 0, str);
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::GetPath(LPWSTR pszFile, INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags){ WCHAR buffer[MAX_PATH];
TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n", this, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(m_sPath));
if (cchMaxPath) *pszFile = 0; // FIXME: What if cchMaxPath == 0 , or pszFile == NULL ??
// FIXME: What about Darwin??
/* * Retrieve the path to the target from the PIDL (if we have one). * NOTE: Do NOT use the cached path (m_sPath from link info). */ if (m_pPidl && SHGetPathFromIDListW(m_pPidl, buffer)) { if (fFlags & SLGP_SHORTPATH) GetShortPathNameW(buffer, buffer, _countof(buffer)); // FIXME: Add support for SLGP_UNCPRIORITY } else { *buffer = 0; }
/* If we have a FindData structure, initialize it */ if (pfd) { ZeroMemory(pfd, sizeof(*pfd));
/* Copy the file data if the target is a file path */ if (*buffer) { pfd->dwFileAttributes = m_Header.dwFileAttributes; pfd->ftCreationTime = m_Header.ftCreationTime; pfd->ftLastAccessTime = m_Header.ftLastAccessTime; pfd->ftLastWriteTime = m_Header.ftLastWriteTime; pfd->nFileSizeHigh = 0; pfd->nFileSizeLow = m_Header.nFileSizeLow;
/* * Build temporarily a short path in pfd->cFileName (of size MAX_PATH), * then extract and store the short file name in pfd->cAlternateFileName. */ GetShortPathNameW(buffer, pfd->cFileName, _countof(pfd->cFileName)); lstrcpynW(pfd->cAlternateFileName, PathFindFileNameW(pfd->cFileName), _countof(pfd->cAlternateFileName));
/* Now extract and store the long file name in pfd->cFileName */ lstrcpynW(pfd->cFileName, PathFindFileNameW(buffer), _countof(pfd->cFileName)); } }
/* Finally check if we have a raw path the user actually wants to retrieve */ if ((fFlags & SLGP_RAWPATH) && (m_Header.dwFlags & SLDF_HAS_EXP_SZ)) { /* Search for a target environment block */ LPEXP_SZ_LINK pInfo; pInfo = (LPEXP_SZ_LINK)SHFindDataBlock(m_pDBList, EXP_SZ_LINK_SIG); if (pInfo && (pInfo->cbSize == sizeof(*pInfo))) lstrcpynW(buffer, pInfo->szwTarget, cchMaxPath); }
/* For diagnostics purposes only... */ // NOTE: SLGP_UNCPRIORITY is unsupported fFlags &= ~(SLGP_RAWPATH | SLGP_SHORTPATH); if (fFlags) FIXME("(%p): Unsupported flags %lu\n", this, fFlags);
/* Copy the data back to the user */ if (*buffer) lstrcpynW(pszFile, buffer, cchMaxPath);
return (*buffer ? S_OK : S_FALSE);}
HRESULT STDMETHODCALLTYPE CShellLink::GetDescription(LPWSTR pszName, INT cchMaxName){ TRACE("(%p)->(%p len=%u)\n", this, pszName, cchMaxName);
*pszName = 0; if (m_sDescription) lstrcpynW(pszName, m_sDescription, cchMaxName);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetDescription(LPCWSTR pszName){ TRACE("(%p)->(desc=%s)\n", this, debugstr_w(pszName));
HeapFree(GetProcessHeap(), 0, m_sDescription); m_sDescription = NULL;
if (pszName) { m_sDescription = strdupW(pszName); if (!m_sDescription) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetWorkingDirectory(LPWSTR pszDir, INT cchMaxPath){ TRACE("(%p)->(%p len %u)\n", this, pszDir, cchMaxPath);
if (cchMaxPath) *pszDir = 0;
if (m_sWorkDir) lstrcpynW(pszDir, m_sWorkDir, cchMaxPath);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetWorkingDirectory(LPCWSTR pszDir){ TRACE("(%p)->(dir=%s)\n", this, debugstr_w(pszDir));
HeapFree(GetProcessHeap(), 0, m_sWorkDir); m_sWorkDir = NULL;
if (pszDir) { m_sWorkDir = strdupW(pszDir); if (!m_sWorkDir) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetArguments(LPWSTR pszArgs, INT cchMaxPath){ TRACE("(%p)->(%p len=%u)\n", this, pszArgs, cchMaxPath);
if (cchMaxPath) *pszArgs = 0;
if (m_sArgs) lstrcpynW(pszArgs, m_sArgs, cchMaxPath);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetArguments(LPCWSTR pszArgs){ TRACE("(%p)->(args=%s)\n", this, debugstr_w(pszArgs));
HeapFree(GetProcessHeap(), 0, m_sArgs); m_sArgs = NULL;
if (pszArgs) { m_sArgs = strdupW(pszArgs); if (!m_sArgs) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetIconLocation(LPWSTR pszIconPath, INT cchIconPath, INT *piIcon){ TRACE("(%p)->(%p len=%u iicon=%p)\n", this, pszIconPath, cchIconPath, piIcon);
if (cchIconPath) *pszIconPath = 0;
*piIcon = 0;
/* Update the original icon path location */ if (m_Header.dwFlags & SLDF_HAS_EXP_ICON_SZ) { WCHAR szPath[MAX_PATH];
/* Search for an icon environment block */ LPEXP_SZ_LINK pInfo; pInfo = (LPEXP_SZ_LINK)SHFindDataBlock(m_pDBList, EXP_SZ_ICON_SIG); if (pInfo && (pInfo->cbSize == sizeof(*pInfo))) { SHExpandEnvironmentStringsW(pInfo->szwTarget, szPath, _countof(szPath));
m_Header.dwFlags &= ~SLDF_HAS_ICONLOCATION; HeapFree(GetProcessHeap(), 0, m_sIcoPath);
m_sIcoPath = strdupW(szPath); if (!m_sIcoPath) return E_OUTOFMEMORY;
m_Header.dwFlags |= SLDF_HAS_ICONLOCATION;
m_bDirty = TRUE; } }
*piIcon = m_Header.nIconIndex;
if (m_sIcoPath) lstrcpynW(pszIconPath, m_sIcoPath, cchIconPath);
return S_OK;}
static HRESULT SHELL_PidlGetIconLocationW(PCIDLIST_ABSOLUTE pidl, UINT uFlags, PWSTR pszIconFile, UINT cchMax, int *piIndex, UINT *pwFlags){ CComPtr<IExtractIconW> pei; HRESULT hr = SHELL_GetUIObjectOfAbsoluteItem(NULL, pidl, IID_PPV_ARG(IExtractIconW, &pei)); if (FAILED_UNEXPECTEDLY(hr)) return hr; hr = pei->GetIconLocation(uFlags, pszIconFile, cchMax, piIndex, pwFlags); if (FAILED_UNEXPECTEDLY(hr)) return hr;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetIconLocation(UINT uFlags, PWSTR pszIconFile, UINT cchMax, int *piIndex, UINT *pwFlags){ HRESULT hr;
pszIconFile[0] = UNICODE_NULL;
/* * It is possible for a shell link to point to another shell link, * and in particular there is the possibility to point to itself. * Now, suppose we ask such a link to retrieve its associated icon. * This function would be called, and due to COM would be called again * recursively. To solve this issue, we forbid calling GetIconLocation() * with GIL_FORSHORTCUT set in uFlags, as done by Windows (shown by tests). */ if (uFlags & GIL_FORSHORTCUT) return E_INVALIDARG;
/* * Now, we set GIL_FORSHORTCUT so that: i) we allow the icon extractor * of the target to give us a suited icon, and ii) we protect ourselves * against recursive call. */ uFlags |= GIL_FORSHORTCUT;
if (uFlags & GIL_DEFAULTICON) return S_FALSE;
hr = GetIconLocation(pszIconFile, cchMax, piIndex); if (FAILED(hr) || pszIconFile[0] == UNICODE_NULL) { hr = SHELL_PidlGetIconLocationW(m_pPidl, uFlags, pszIconFile, cchMax, piIndex, pwFlags); } else { // TODO: If GetIconLocation succeeded, why are we setting GIL_NOTFILENAME? And are we not PERINSTANCE? *pwFlags = GIL_NOTFILENAME | GIL_PERCLASS; }
return hr;}
HRESULT STDMETHODCALLTYPECShellLink::Extract(PCWSTR pszFile, UINT nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIconSize){ HRESULT hr = NOERROR; UINT cxyLarge = LOWORD(nIconSize), cxySmall = HIWORD(nIconSize);
if (phiconLarge) { *phiconLarge = NULL; PrivateExtractIconsW(pszFile, nIconIndex, cxyLarge, cxyLarge, phiconLarge, NULL, 1, 0);
if (*phiconLarge == NULL) hr = S_FALSE; }
if (phiconSmall) { *phiconSmall = NULL; PrivateExtractIconsW(pszFile, nIconIndex, cxySmall, cxySmall, phiconSmall, NULL, 1, 0);
if (*phiconSmall == NULL) hr = S_FALSE; }
if (hr == S_FALSE) { if (phiconLarge && *phiconLarge) { DestroyIcon(*phiconLarge); *phiconLarge = NULL; } if (phiconSmall && *phiconSmall) { DestroyIcon(*phiconSmall); *phiconSmall = NULL; } }
return hr;}
#if 0/* Extends the functionality of PathUnExpandEnvStringsW */BOOL PathFullyUnExpandEnvStringsW( _In_ LPCWSTR pszPath, _Out_ LPWSTR pszBuf, _In_ UINT cchBuf){ BOOL Ret = FALSE; // Set to TRUE as soon as PathUnExpandEnvStrings starts unexpanding. BOOL res; LPCWSTR p;
// *pszBuf = L'\0'; while (*pszPath && cchBuf > 0) { /* Attempt unexpanding the path */ res = PathUnExpandEnvStringsW(pszPath, pszBuf, cchBuf); if (!res) { /* The unexpansion failed. Try to find a path delimiter. */ p = wcspbrk(pszPath, L" /\\:*?\"<>|%"); if (!p) /* None found, we will copy the remaining path */ p = pszPath + wcslen(pszPath); else /* Found one, we will copy the delimiter and skip it */ ++p; /* If we overflow, we cannot unexpand more, so return FALSE */ if (p - pszPath >= cchBuf) return FALSE; // *pszBuf = L'\0';
/* Copy the untouched portion of path up to the delimiter, included */ wcsncpy(pszBuf, pszPath, p - pszPath); pszBuf[p - pszPath] = L'\0'; // NULL-terminate
/* Advance the pointers and decrease the remaining buffer size */ cchBuf -= (p - pszPath); pszBuf += (p - pszPath); pszPath += (p - pszPath); } else { /* * The unexpansion succeeded. Skip the unexpanded part by trying * to find where the original path and the unexpanded string * become different. * NOTE: An alternative(?) would be to stop also at the last * path delimiter encountered in the loop (i.e. would be the * first path delimiter in the strings). */ LPWSTR q;
/* * The algorithm starts at the end of the strings and loops back * while the characters are equal, until it finds a discrepancy. */ p = pszPath + wcslen(pszPath); q = pszBuf + wcslen(pszBuf); // This wcslen should be < cchBuf while ((*p == *q) && (p > pszPath) && (q > pszBuf)) { --p; --q; } /* Skip discrepancy */ ++p; ++q;
/* Advance the pointers and decrease the remaining buffer size */ cchBuf -= (q - pszBuf); pszBuf = q; pszPath = p;
Ret = TRUE; } }
return Ret;}#endif
HRESULT STDMETHODCALLTYPE CShellLink::SetIconLocation(LPCWSTR pszIconPath, INT iIcon){ HRESULT hr = E_FAIL; WCHAR szIconPath[MAX_PATH];
TRACE("(%p)->(path=%s iicon=%u)\n", this, debugstr_w(pszIconPath), iIcon);
if (pszIconPath) { /* * Check whether the user-given file path contains unexpanded * environment variables. If so, create a target environment block. * Note that in this block we will store the user-given path. * It will contain the unexpanded environment variables, but * it can also contain already expanded path that the user does * not want to see them unexpanded (e.g. so that they always * refer to the same place even if the would-be corresponding * environment variable could change). */#ifdef ICON_LINK_WINDOWS_COMPAT /* Try to fully unexpand the icon path */ // if (PathFullyUnExpandEnvStringsW(pszIconPath, szIconPath, _countof(szIconPath))) BOOL bSuccess = PathUnExpandEnvStringsW(pszIconPath, szIconPath, _countof(szIconPath)); if (bSuccess && wcscmp(pszIconPath, szIconPath) != 0)#else /* * In some situations, described in http://stackoverflow.com/questions/2976489/ishelllinkseticonlocation-translates-my-icon-path-into-program-files-which-i * the result of PathUnExpandEnvStringsW() could be wrong, and instead * one would have to store the actual provided icon location path, while * creating an icon environment block ONLY if that path already contains * environment variables. This is what the present case is trying to implement. */ SHExpandEnvironmentStringsW(pszIconPath, szIconPath, _countof(szIconPath)); if (wcscmp(pszIconPath, szIconPath) != 0)#endif { /* * The user-given file path contains unexpanded environment * variables, so we need an icon environment block. */ EXP_SZ_LINK buffer; LPEXP_SZ_LINK pInfo;
#ifdef ICON_LINK_WINDOWS_COMPAT /* Make pszIconPath point to the unexpanded path */ LPCWSTR pszOrgIconPath = pszIconPath; pszIconPath = szIconPath;#endif pInfo = (LPEXP_SZ_LINK)SHFindDataBlock(m_pDBList, EXP_SZ_ICON_SIG); if (pInfo) { /* Make sure that the size of the structure is valid */ if (pInfo->cbSize != sizeof(*pInfo)) { ERR("Ooops. This structure is not as expected...\n");
/* Invalid structure, remove it altogether */ m_Header.dwFlags &= ~SLDF_HAS_EXP_ICON_SZ; RemoveDataBlock(EXP_SZ_ICON_SIG);
/* Reset the pointer and go use the static buffer */ pInfo = NULL; } } if (!pInfo) { /* Use the static buffer */ pInfo = &buffer; buffer.cbSize = sizeof(buffer); buffer.dwSignature = EXP_SZ_ICON_SIG; }
lstrcpynW(pInfo->szwTarget, pszIconPath, _countof(pInfo->szwTarget)); WideCharToMultiByte(CP_ACP, 0, pszIconPath, -1, pInfo->szTarget, _countof(pInfo->szTarget), NULL, NULL);
hr = S_OK; if (pInfo == &buffer) hr = AddDataBlock(pInfo); if (hr == S_OK) m_Header.dwFlags |= SLDF_HAS_EXP_ICON_SZ;
#ifdef ICON_LINK_WINDOWS_COMPAT /* Set pszIconPath back to the original one */ pszIconPath = pszOrgIconPath;#else /* Now, make pszIconPath point to the expanded path */ pszIconPath = szIconPath;#endif } else { /* * The user-given file path does not contain unexpanded environment * variables, so we need to remove any icon environment block. */ m_Header.dwFlags &= ~SLDF_HAS_EXP_ICON_SZ; RemoveDataBlock(EXP_SZ_ICON_SIG);
/* pszIconPath points to the user path */ } }
#ifdef ICON_LINK_WINDOWS_COMPAT /* Store the original icon path location (may contain unexpanded environment strings) */#endif if (pszIconPath) { m_Header.dwFlags &= ~SLDF_HAS_ICONLOCATION; HeapFree(GetProcessHeap(), 0, m_sIcoPath);
m_sIcoPath = strdupW(pszIconPath); if (!m_sIcoPath) return E_OUTOFMEMORY;
m_Header.dwFlags |= SLDF_HAS_ICONLOCATION; }
hr = S_OK;
m_Header.nIconIndex = iIcon; m_bDirty = TRUE;
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SetRelativePath(LPCWSTR pszPathRel, DWORD dwReserved){ TRACE("(%p)->(path=%s %x)\n", this, debugstr_w(pszPathRel), dwReserved);
HeapFree(GetProcessHeap(), 0, m_sPathRel); m_sPathRel = NULL;
if (pszPathRel) { m_sPathRel = strdupW(pszPathRel); if (!m_sPathRel) return E_OUTOFMEMORY; } m_bDirty = TRUE;
return ShellLink_UpdatePath(m_sPathRel, m_sPath, m_sWorkDir, &m_sPath);}
static LPWSTR GetAdvertisedArg(LPCWSTR str){ if (!str) return NULL;
LPCWSTR p = wcschr(str, L':'); if (!p) return NULL;
DWORD len = p - str; LPWSTR ret = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (len + 1)); if (!ret) return ret;
memcpy(ret, str, sizeof(WCHAR)*len); ret[len] = 0; return ret;}
HRESULT CShellLink::WriteAdvertiseInfo(LPCWSTR string, DWORD dwSig){ EXP_DARWIN_LINK buffer; LPEXP_DARWIN_LINK pInfo;
if ( (dwSig != EXP_DARWIN_ID_SIG)#if (NTDDI_VERSION < NTDDI_LONGHORN) && (dwSig != EXP_LOGO3_ID_SIG)#endif ) { return E_INVALIDARG; }
if (!string) return S_FALSE;
pInfo = (LPEXP_DARWIN_LINK)SHFindDataBlock(m_pDBList, dwSig); if (pInfo) { /* Make sure that the size of the structure is valid */ if (pInfo->dbh.cbSize != sizeof(*pInfo)) { ERR("Ooops. This structure is not as expected...\n");
/* Invalid structure, remove it altogether */ if (dwSig == EXP_DARWIN_ID_SIG) m_Header.dwFlags &= ~SLDF_HAS_DARWINID;#if (NTDDI_VERSION < NTDDI_LONGHORN) else if (dwSig == EXP_LOGO3_ID_SIG) m_Header.dwFlags &= ~SLDF_HAS_LOGO3ID;#endif RemoveDataBlock(dwSig);
/* Reset the pointer and go use the static buffer */ pInfo = NULL; } } if (!pInfo) { /* Use the static buffer */ pInfo = &buffer; buffer.dbh.cbSize = sizeof(buffer); buffer.dbh.dwSignature = dwSig; }
lstrcpynW(pInfo->szwDarwinID, string, _countof(pInfo->szwDarwinID)); WideCharToMultiByte(CP_ACP, 0, string, -1, pInfo->szDarwinID, _countof(pInfo->szDarwinID), NULL, NULL);
HRESULT hr = S_OK; if (pInfo == &buffer) hr = AddDataBlock(pInfo); if (hr == S_OK) { if (dwSig == EXP_DARWIN_ID_SIG) m_Header.dwFlags |= SLDF_HAS_DARWINID;#if (NTDDI_VERSION < NTDDI_LONGHORN) else if (dwSig == EXP_LOGO3_ID_SIG) m_Header.dwFlags |= SLDF_HAS_LOGO3ID;#endif }
return hr;}
HRESULT CShellLink::SetAdvertiseInfo(LPCWSTR str){ HRESULT hr; LPCWSTR szComponent = NULL, szProduct = NULL, p; INT len; GUID guid; WCHAR szGuid[38+1];
/**/sProduct = sComponent = NULL;/**/
while (str[0]) { /* each segment must start with two colons */ if (str[0] != ':' || str[1] != ':') return E_FAIL;
/* the last segment is just two colons */ if (!str[2]) break; str += 2;
/* there must be a colon straight after a guid */ p = wcschr(str, L':'); if (!p) return E_FAIL; len = p - str; if (len != 38) return E_FAIL;
/* get the guid, and check if it's validly formatted */ memcpy(szGuid, str, sizeof(WCHAR)*len); szGuid[len] = 0;
hr = CLSIDFromString(szGuid, &guid); if (hr != S_OK) return hr; str = p + 1;
/* match it up to a guid that we care about */ if (IsEqualGUID(guid, SHELL32_AdvtShortcutComponent) && !szComponent) szComponent = str; /* Darwin */ else if (IsEqualGUID(guid, SHELL32_AdvtShortcutProduct) && !szProduct) szProduct = str; /* Logo3 */ else return E_FAIL;
/* skip to the next field */ str = wcschr(str, L':'); if (!str) return E_FAIL; }
/* we have to have a component for an advertised shortcut */ if (!szComponent) return E_FAIL;
szComponent = GetAdvertisedArg(szComponent); szProduct = GetAdvertisedArg(szProduct);
hr = WriteAdvertiseInfo(szComponent, EXP_DARWIN_ID_SIG); // if (FAILED(hr)) // return hr;#if (NTDDI_VERSION < NTDDI_LONGHORN) hr = WriteAdvertiseInfo(szProduct, EXP_LOGO3_ID_SIG); // if (FAILED(hr)) // return hr;#endif
HeapFree(GetProcessHeap(), 0, (PVOID)szComponent); HeapFree(GetProcessHeap(), 0, (PVOID)szProduct);
if (TRACE_ON(shell)) { GetAdvertiseInfo(&sComponent, EXP_DARWIN_ID_SIG); TRACE("Component = %s\n", debugstr_w(sComponent));#if (NTDDI_VERSION < NTDDI_LONGHORN) GetAdvertiseInfo(&sProduct, EXP_LOGO3_ID_SIG); TRACE("Product = %s\n", debugstr_w(sProduct));#endif }
return S_OK;}
HRESULT CShellLink::SetTargetFromPIDLOrPath(LPCITEMIDLIST pidl, LPCWSTR pszFile){ HRESULT hr = S_OK; LPITEMIDLIST pidlNew = NULL; WCHAR szPath[MAX_PATH];
/* * Not both 'pidl' and 'pszFile' should be set. * But either one or both can be NULL. */ if (pidl && pszFile) return E_FAIL;
if (pidl) { /* Clone the PIDL */ pidlNew = ILClone(pidl); if (!pidlNew) return E_FAIL; } else if (pszFile) { /* Build a PIDL for this path target */ hr = SHILCreateFromPathW(pszFile, &pidlNew, NULL); if (FAILED(hr)) { /* This failed, try to resolve the path, then create a simple PIDL */
StringCchCopyW(szPath, _countof(szPath), pszFile); PathResolveW(szPath, NULL, PRF_TRYPROGRAMEXTENSIONS);
if (PathIsFileSpecW(szPath)) { hr = E_INVALIDARG; szPath[0] = 0; } else { hr = S_OK; pidlNew = SHSimpleIDListFromPathW(szPath); // NOTE: Don't make it failed here even if pidlNew was NULL. // We don't fail on purpose even if SHSimpleIDListFromPathW returns NULL. // This behaviour has been verified with tests. } } } // else if (!pidl && !pszFile) { pidlNew = NULL; hr = S_OK; }
ILFree(m_pPidl); m_pPidl = pidlNew;
if (!pszFile) { if (SHGetPathFromIDListW(pidlNew, szPath)) pszFile = szPath; }
// TODO: Fully update link info, tracker, file attribs...
// if (pszFile) if (!pszFile) { *szPath = L'\0'; pszFile = szPath; }
/* Update the cached path (for link info) */ ShellLink_GetVolumeInfo(pszFile, &volume);
if (m_sPath) HeapFree(GetProcessHeap(), 0, m_sPath);
m_sPath = strdupW(pszFile); if (!m_sPath) return E_OUTOFMEMORY;
m_bDirty = TRUE; return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::SetPath(LPCWSTR pszFile){ LPWSTR unquoted = NULL; HRESULT hr = S_OK;
TRACE("(%p)->(path=%s)\n", this, debugstr_w(pszFile));
if (!pszFile) return E_INVALIDARG;
/* * Allow upgrading Logo3 shortcuts (m_Header.dwFlags & SLDF_HAS_LOGO3ID), * but forbid upgrading Darwin ones. */ if (m_Header.dwFlags & SLDF_HAS_DARWINID) return S_FALSE;
/* quotes at the ends of the string are stripped */ SIZE_T len = wcslen(pszFile); if (pszFile[0] == L'"' && pszFile[len-1] == L'"') { unquoted = strdupW(pszFile); PathUnquoteSpacesW(unquoted); pszFile = unquoted; }
/* any other quote marks are invalid */ if (wcschr(pszFile, L'"')) { hr = S_FALSE; goto end; }
/* Clear the cached path */ HeapFree(GetProcessHeap(), 0, m_sPath); m_sPath = NULL;
/* Check for an advertised target (Logo3 or Darwin) */ if (SetAdvertiseInfo(pszFile) != S_OK) { /* This is not an advertised target, but a regular path */ WCHAR szPath[MAX_PATH];
/* * Check whether the user-given file path contains unexpanded * environment variables. If so, create a target environment block. * Note that in this block we will store the user-given path. * It will contain the unexpanded environment variables, but * it can also contain already expanded path that the user does * not want to see them unexpanded (e.g. so that they always * refer to the same place even if the would-be corresponding * environment variable could change). */ if (*pszFile) SHExpandEnvironmentStringsW(pszFile, szPath, _countof(szPath)); else *szPath = L'\0';
if (*pszFile && (wcscmp(pszFile, szPath) != 0)) { /* * The user-given file path contains unexpanded environment * variables, so we need a target environment block. */ EXP_SZ_LINK buffer; LPEXP_SZ_LINK pInfo;
pInfo = (LPEXP_SZ_LINK)SHFindDataBlock(m_pDBList, EXP_SZ_LINK_SIG); if (pInfo) { /* Make sure that the size of the structure is valid */ if (pInfo->cbSize != sizeof(*pInfo)) { ERR("Ooops. This structure is not as expected...\n");
/* Invalid structure, remove it altogether */ m_Header.dwFlags &= ~SLDF_HAS_EXP_SZ; RemoveDataBlock(EXP_SZ_LINK_SIG);
/* Reset the pointer and go use the static buffer */ pInfo = NULL; } } if (!pInfo) { /* Use the static buffer */ pInfo = &buffer; buffer.cbSize = sizeof(buffer); buffer.dwSignature = EXP_SZ_LINK_SIG; }
lstrcpynW(pInfo->szwTarget, pszFile, _countof(pInfo->szwTarget)); WideCharToMultiByte(CP_ACP, 0, pszFile, -1, pInfo->szTarget, _countof(pInfo->szTarget), NULL, NULL);
hr = S_OK; if (pInfo == &buffer) hr = AddDataBlock(pInfo); if (hr == S_OK) m_Header.dwFlags |= SLDF_HAS_EXP_SZ;
/* Now, make pszFile point to the expanded path */ pszFile = szPath; } else { /* * The user-given file path does not contain unexpanded environment * variables, so we need to remove any target environment block. */ m_Header.dwFlags &= ~SLDF_HAS_EXP_SZ; RemoveDataBlock(EXP_SZ_LINK_SIG);
/* pszFile points to the user path */ }
/* Set the target */ hr = SetTargetFromPIDLOrPath(NULL, pszFile); }
m_bDirty = TRUE;
end: HeapFree(GetProcessHeap(), 0, unquoted); return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::AddDataBlock(void* pDataBlock){ if (SHAddDataBlock(&m_pDBList, (DATABLOCK_HEADER*)pDataBlock)) { m_bDirty = TRUE; return S_OK; } return S_FALSE;}
HRESULT STDMETHODCALLTYPE CShellLink::CopyDataBlock(DWORD dwSig, void** ppDataBlock){ DATABLOCK_HEADER* pBlock; PVOID pDataBlock;
TRACE("%p %08x %p\n", this, dwSig, ppDataBlock);
*ppDataBlock = NULL;
pBlock = SHFindDataBlock(m_pDBList, dwSig); if (!pBlock) { ERR("unknown datablock %08x (not found)\n", dwSig); return E_FAIL; }
pDataBlock = LocalAlloc(LMEM_ZEROINIT, pBlock->cbSize); if (!pDataBlock) return E_OUTOFMEMORY;
CopyMemory(pDataBlock, pBlock, pBlock->cbSize);
*ppDataBlock = pDataBlock; return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::RemoveDataBlock(DWORD dwSig){ if (SHRemoveDataBlock(&m_pDBList, dwSig)) { m_bDirty = TRUE; return S_OK; } return S_FALSE;}
HRESULT STDMETHODCALLTYPE CShellLink::GetFlags(DWORD *pdwFlags){ TRACE("%p %p\n", this, pdwFlags); *pdwFlags = m_Header.dwFlags; return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::SetFlags(DWORD dwFlags){ if (m_Header.dwFlags == dwFlags) return S_FALSE; m_Header.dwFlags = dwFlags; m_bDirty = TRUE; return S_OK;}
/************************************************************************** * CShellLink implementation of IShellExtInit::Initialize() * * Loads the shelllink from the dataobject the shell is pointing to. */HRESULT STDMETHODCALLTYPE CShellLink::Initialize(PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID){ TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID);
if (!pdtobj) return E_FAIL;
FORMATETC format; format.cfFormat = CF_HDROP; format.ptd = NULL; format.dwAspect = DVASPECT_CONTENT; format.lindex = -1; format.tymed = TYMED_HGLOBAL;
STGMEDIUM stgm; HRESULT hr = pdtobj->GetData(&format, &stgm); if (FAILED(hr)) return hr;
UINT count = DragQueryFileW((HDROP)stgm.hGlobal, -1, NULL, 0); if (count == 1) { count = DragQueryFileW((HDROP)stgm.hGlobal, 0, NULL, 0); count++; LPWSTR path = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, count * sizeof(WCHAR)); if (path) { count = DragQueryFileW((HDROP)stgm.hGlobal, 0, path, count); hr = Load(path, 0); HeapFree(GetProcessHeap(), 0, path); } } ReleaseStgMedium(&stgm);
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags){ INT id = 0;
TRACE("%p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
if (!hMenu) return E_INVALIDARG;
CStringW strOpen(MAKEINTRESOURCEW(IDS_OPEN_VERB)); CStringW strOpenFileLoc(MAKEINTRESOURCEW(IDS_OPENFILELOCATION));
MENUITEMINFOW mii; ZeroMemory(&mii, sizeof(mii)); mii.cbSize = sizeof(mii); mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE; mii.dwTypeData = strOpen.GetBuffer(); mii.cch = wcslen(mii.dwTypeData); mii.wID = idCmdFirst + id++; mii.fState = MFS_DEFAULT | MFS_ENABLED; mii.fType = MFT_STRING; if (!InsertMenuItemW(hMenu, indexMenu++, TRUE, &mii)) return E_FAIL;
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE; mii.dwTypeData = strOpenFileLoc.GetBuffer(); mii.cch = wcslen(mii.dwTypeData); mii.wID = idCmdFirst + id++; mii.fState = MFS_ENABLED; mii.fType = MFT_STRING; if (!InsertMenuItemW(hMenu, indexMenu++, TRUE, &mii)) return E_FAIL;
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);}
HRESULT CShellLink::DoOpenFileLocation(){ // TODO: SHOpenFolderAndSelectItems WCHAR szParams[MAX_PATH + 64]; StringCbPrintfW(szParams, sizeof(szParams), L"/select,%s", m_sPath);
INT_PTR ret; ret = reinterpret_cast<INT_PTR>(ShellExecuteW(NULL, NULL, L"explorer.exe", szParams, NULL, m_Header.nShowCommand)); if (ret <= 32) { ERR("ret: %08lX\n", ret); return E_FAIL; }
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::InvokeCommand(LPCMINVOKECOMMANDINFO lpici){ TRACE("%p %p\n", this, lpici);
if (lpici->cbSize < sizeof(CMINVOKECOMMANDINFO)) return E_INVALIDARG;
// NOTE: We could use lpici->hwnd (certainly in case lpici->fMask doesn't contain CMIC_MASK_FLAG_NO_UI) // as the parent window handle... ? /* FIXME: get using interface set from IObjectWithSite?? */ // NOTE: We might need an extended version of Resolve that provides us with paths... HRESULT hr = Resolve(lpici->hwnd, (lpici->fMask & CMIC_MASK_FLAG_NO_UI) ? SLR_NO_UI : 0); if (FAILED(hr)) { TRACE("failed to resolve component error 0x%08x\n", hr); return hr; }
UINT idCmd = LOWORD(lpici->lpVerb); TRACE("idCmd: %d\n", idCmd);
switch (idCmd) { case IDCMD_OPEN: return DoOpen(lpici); case IDCMD_OPENFILELOCATION: return DoOpenFileLocation(); default: return E_NOTIMPL; }}
HRESULT CShellLink::DoOpen(LPCMINVOKECOMMANDINFO lpici){ LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX)lpici; const BOOL unicode = IsUnicode(*lpici);
CStringW args; if (m_sArgs) args = m_sArgs;
if (unicode) { if (!StrIsNullOrEmpty(iciex->lpParametersW)) { args += L' '; args += iciex->lpParametersW; } } else { CComHeapPtr<WCHAR> pszParams; if (!StrIsNullOrEmpty(lpici->lpParameters) && __SHCloneStrAtoW(&pszParams, lpici->lpParameters)) { args += L' '; args += pszParams; } }
WCHAR dir[MAX_PATH]; SHELLEXECUTEINFOW sei = { sizeof(sei) }; sei.fMask = SEE_MASK_HASLINKNAME | SEE_MASK_UNICODE | SEE_MASK_DOENVSUBST | (lpici->fMask & (SEE_MASK_NOASYNC | SEE_MASK_ASYNCOK | SEE_MASK_FLAG_NO_UI)); sei.lpDirectory = m_sWorkDir; if (m_pPidl) { sei.lpIDList = m_pPidl; sei.fMask |= SEE_MASK_INVOKEIDLIST; } else { sei.lpFile = m_sPath; if (!(m_Header.dwFlags & SLDF_HAS_EXP_SZ)) { sei.fMask &= ~SEE_MASK_DOENVSUBST; // The link does not want to expand lpFile if (m_sWorkDir && ExpandEnvironmentStringsW(m_sWorkDir, dir, _countof(dir)) <= _countof(dir)) sei.lpDirectory = dir; } } sei.lpParameters = args; sei.lpClass = m_sLinkPath; sei.nShow = m_Header.nShowCommand; if (lpici->nShow != SW_SHOWNORMAL && lpici->nShow != SW_SHOW) sei.nShow = lpici->nShow; // Allow invoker to override .lnk show mode
// Use the invoker specified working directory if the link did not specify one if (StrIsNullOrEmpty(sei.lpDirectory) || !PathEnvSubstIsDirectory(sei.lpDirectory)) { LPCSTR pszDirA = lpici->lpDirectory; if (unicode && !StrIsNullOrEmpty(iciex->lpDirectoryW)) sei.lpDirectory = iciex->lpDirectoryW; else if (pszDirA && SHAnsiToUnicode(pszDirA, dir, _countof(dir))) sei.lpDirectory = dir; }
sei.dwHotKey = lpici->dwHotKey; sei.fMask |= CmicFlagsToSeeFlags(lpici->fMask & CMIC_MASK_HOTKEY); if (m_Header.wHotKey) { sei.dwHotKey = m_Header.wHotKey; sei.fMask |= SEE_MASK_HOTKEY; } return (ShellExecuteExW(&sei) ? S_OK : E_FAIL);}
HRESULT STDMETHODCALLTYPE CShellLink::GetCommandString(UINT_PTR idCmd, UINT uType, UINT* pwReserved, LPSTR pszName, UINT cchMax){ FIXME("%p %lu %u %p %p %u\n", this, idCmd, uType, pwReserved, pszName, cchMax); return E_NOTIMPL;}
INT_PTR CALLBACK ExtendedShortcutProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam){ switch(uMsg) { case WM_INITDIALOG: if (lParam) { HWND hDlgCtrl = GetDlgItem(hwndDlg, IDC_SHORTEX_RUN_DIFFERENT); SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0); } return TRUE; case WM_COMMAND: { HWND hDlgCtrl = GetDlgItem(hwndDlg, IDC_SHORTEX_RUN_DIFFERENT); if (LOWORD(wParam) == IDOK) { if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED) EndDialog(hwndDlg, 1); else EndDialog(hwndDlg, 0); } else if (LOWORD(wParam) == IDCANCEL) { EndDialog(hwndDlg, -1); } else if (LOWORD(wParam) == IDC_SHORTEX_RUN_DIFFERENT) { if (SendMessage(hDlgCtrl, BM_GETCHECK, 0, 0) == BST_CHECKED) SendMessage(hDlgCtrl, BM_SETCHECK, BST_UNCHECKED, 0); else SendMessage(hDlgCtrl, BM_SETCHECK, BST_CHECKED, 0); } } } return FALSE;}
static void GetTypeDescriptionByPath(PCWSTR pszFullPath, DWORD fAttributes, PWSTR szBuf, UINT cchBuf){ if (fAttributes == INVALID_FILE_ATTRIBUTES && !PathFileExistsAndAttributesW(pszFullPath, &fAttributes)) fAttributes = 0;
SHFILEINFOW fi; if (!SHGetFileInfoW(pszFullPath, fAttributes, &fi, sizeof(fi), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES)) { ERR("SHGetFileInfoW failed for %ls (%lu)\n", pszFullPath, GetLastError()); fi.szTypeName[0] = UNICODE_NULL; }
BOOL fFolder = (fAttributes & FILE_ATTRIBUTE_DIRECTORY); LPCWSTR pwszExt = fFolder ? L"" : PathFindExtensionW(pszFullPath); if (pwszExt[0]) { if (!fi.szTypeName[0]) StringCchPrintfW(szBuf, cchBuf, L"%s", pwszExt + 1); else StringCchPrintfW(szBuf, cchBuf, L"%s (%s)", fi.szTypeName, pwszExt); } else { StringCchPrintfW(szBuf, cchBuf, L"%s", fi.szTypeName); }}
BOOL CShellLink::OnInitDialog(HWND hwndDlg, HWND hwndFocus, LPARAM lParam){ TRACE("CShellLink::OnInitDialog(hwnd %p hwndFocus %p lParam %p)\n", hwndDlg, hwndFocus, lParam);
Resolve(0, SLR_NO_UI | SLR_NOUPDATE | SLR_NOSEARCH | SLR_NOTRACK);
TRACE("m_sArgs: %S sComponent: %S m_sDescription: %S m_sIcoPath: %S m_sPath: %S m_sPathRel: %S sProduct: %S m_sWorkDir: %S\n", m_sArgs, sComponent, m_sDescription, m_sIcoPath, m_sPath, m_sPathRel, sProduct, m_sWorkDir);
m_bInInit = TRUE; UINT darwin = m_Header.dwFlags & (SLDF_HAS_DARWINID);
/* Get file information */ // FIXME! FIXME! Shouldn't we use m_sIcoPath, m_Header.nIconIndex instead??? SHFILEINFOW fi; if (!SHGetFileInfoW(m_sLinkPath, 0, &fi, sizeof(fi), SHGFI_TYPENAME | SHGFI_ICON)) { ERR("SHGetFileInfoW failed for %ls (%lu)\n", m_sLinkPath, GetLastError()); fi.szTypeName[0] = L'\0'; fi.hIcon = NULL; }
if (fi.hIcon) { if (m_hIcon) DestroyIcon(m_hIcon); m_hIcon = fi.hIcon; SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_ICON, STM_SETICON, (WPARAM)m_hIcon, 0); } else ERR("ExtractIconW failed %ls %u\n", m_sIcoPath, m_Header.nIconIndex);
if (!SHGetFileInfoW(m_sLinkPath, 0, &fi, sizeof(fi), SHGFI_DISPLAYNAME)) fi.szDisplayName[0] = UNICODE_NULL; SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_TEXT, fi.szDisplayName);
/* Target type */ if (m_sPath) { WCHAR buf[MAX_PATH]; GetTypeDescriptionByPath(m_sPath, m_Header.dwFileAttributes, buf, _countof(buf)); SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_TYPE_EDIT, buf); }
/* Target location */ if (m_sPath) { WCHAR target[MAX_PATH]; StringCchCopyW(target, _countof(target), m_sPath); PathRemoveFileSpecW(target); SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_LOCATION_EDIT, PathFindFileNameW(target)); }
/* Target path */ if (m_sPath) { WCHAR newpath[MAX_PATH * 2]; newpath[0] = UNICODE_NULL; if (wcschr(m_sPath, ' ')) StringCchPrintfExW(newpath, _countof(newpath), NULL, NULL, 0, L"\"%ls\"", m_sPath); else StringCchCopyExW(newpath, _countof(newpath), m_sPath, NULL, NULL, 0);
if (m_sArgs && m_sArgs[0]) { StringCchCatW(newpath, _countof(newpath), L" "); StringCchCatW(newpath, _countof(newpath), m_sArgs); } SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_TARGET_TEXT, newpath); }
/* Working dir */ if (m_sWorkDir) SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_START_IN_EDIT, m_sWorkDir);
/* Description */ if (m_sDescription) SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_COMMENT_EDIT, m_sDescription);
/* Hot key */ SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_KEY_HOTKEY, HKM_SETHOTKEY, m_Header.wHotKey, 0);
/* Run */ const WORD runstrings[] = { IDS_SHORTCUT_RUN_NORMAL, IDS_SHORTCUT_RUN_MIN, IDS_SHORTCUT_RUN_MAX }; const DWORD runshowcmd[] = { SW_SHOWNORMAL, SW_SHOWMINNOACTIVE, SW_SHOWMAXIMIZED }; HWND hRunCombo = GetDlgItem(hwndDlg, IDC_SHORTCUT_RUN_COMBO); for (UINT i = 0; i < _countof(runstrings); ++i) { WCHAR buf[MAX_PATH]; if (!LoadStringW(shell32_hInstance, runstrings[i], buf, _countof(buf))) break;
int index = SendMessageW(hRunCombo, CB_ADDSTRING, 0, (LPARAM)buf); if (index < 0) continue; SendMessageW(hRunCombo, CB_SETITEMDATA, index, runshowcmd[i]); if (!i || m_Header.nShowCommand == runshowcmd[i]) SendMessageW(hRunCombo, CB_SETCURSEL, index, 0); }
BOOL disablecontrols = FALSE; if (darwin) { disablecontrols = TRUE; EnableWindow(GetDlgItem(hwndDlg, IDC_SHORTCUT_FIND), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_SHORTCUT_CHANGE_ICON), FALSE); } else { WCHAR path[MAX_PATH * 2]; path[0] = UNICODE_NULL; HRESULT hr = GetPath(path, _countof(path), NULL, SLGP_RAWPATH); if (FAILED(hr)) hr = GetPath(path, _countof(path), NULL, 0);#if DBG if (GetKeyState(VK_CONTROL) < 0) // Allow inspection of PIDL parsing path { hr = S_OK; path[0] = UNICODE_NULL; }#endif if (hr != S_OK) { disablecontrols = TRUE; LPITEMIDLIST pidl; if (GetIDList(&pidl) == S_OK) { path[0] = UNICODE_NULL; SHGetNameAndFlagsW(pidl, SHGDN_FORADDRESSBAR | SHGDN_FORPARSING, path, _countof(path), NULL); SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_TYPE_EDIT, path); SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_TARGET_TEXT, path); ILRemoveLastID(pidl); path[0] = UNICODE_NULL; SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_START_IN_EDIT, path); SHGetNameAndFlagsW(pidl, SHGDN_NORMAL, path, _countof(path), NULL); SetDlgItemTextW(hwndDlg, IDC_SHORTCUT_LOCATION_EDIT, path); ILFree(pidl); } EnableWindow(GetDlgItem(hwndDlg, IDC_SHORTCUT_ADVANCED), FALSE); EnableWindow(GetDlgItem(hwndDlg, IDC_SHORTCUT_START_IN_EDIT), FALSE); } else { ASSERT(FAILED(hr) || !(path[0] == ':' && path[1] == ':' && path[2] == '{')); } }
HWND hWndTarget = GetDlgItem(hwndDlg, IDC_SHORTCUT_TARGET_TEXT); EnableWindow(hWndTarget, !disablecontrols); PostMessage(hWndTarget, EM_SETSEL, 0, -1); // Fix caret bug when first opening the tab [CORE-20016]
/* auto-completion */ SHAutoComplete(hWndTarget, SHACF_DEFAULT); SHAutoComplete(GetDlgItem(hwndDlg, IDC_SHORTCUT_START_IN_EDIT), SHACF_DEFAULT);
m_bInInit = FALSE;
return TRUE;}
void CShellLink::OnCommand(HWND hwndDlg, int id, HWND hwndCtl, UINT codeNotify){ switch (id) { case IDC_SHORTCUT_FIND: SHOpenFolderAndSelectItems(m_pPidl, 0, NULL, 0); return;
case IDC_SHORTCUT_CHANGE_ICON: { SHFILEINFOW fi; INT IconIndex = m_Header.nIconIndex; WCHAR wszPath[MAX_PATH]; *wszPath = UNICODE_NULL;
if (!StrIsNullOrEmpty(m_sIcoPath)) { PWSTR pszPath = m_sIcoPath; if (*m_sIcoPath == '.') // Extension-only icon location, we need a fake path { if (SUCCEEDED(StringCchPrintfW(wszPath, _countof(wszPath), L"x:\\x%s", m_sIcoPath)) && SHGetFileInfoW(wszPath, 0, &fi, sizeof(fi), SHGFI_ICONLOCATION | SHGFI_USEFILEATTRIBUTES)) { pszPath = fi.szDisplayName; // The path is now a generic icon based IconIndex = fi.iIcon; // on the registry info of the file extension. } }
if (FAILED(StringCchCopyW(wszPath, _countof(wszPath), pszPath))) *wszPath = UNICODE_NULL; } else if (!StrIsNullOrEmpty(m_sPath)) { FindExecutableW(m_sPath, NULL, wszPath); }
if (!*wszPath && m_pPidl) { if (SHGetFileInfoW((PWSTR)m_pPidl, 0, &fi, sizeof(fi), SHGFI_ICONLOCATION | SHGFI_PIDL) && SUCCEEDED(StringCchCopyW(wszPath, _countof(wszPath), fi.szDisplayName))) { IconIndex = fi.iIcon; } }
if (PickIconDlg(hwndDlg, wszPath, _countof(wszPath), &IconIndex)) { SetIconLocation(wszPath, IconIndex); PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
HICON hIconLarge = CreateShortcutIcon(wszPath, IconIndex); if (hIconLarge) { if (m_hIcon) DestroyIcon(m_hIcon); m_hIcon = hIconLarge; SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_ICON, STM_SETICON, (WPARAM)m_hIcon, 0); } } return; }
case IDC_SHORTCUT_ADVANCED: { INT_PTR result = DialogBoxParamW(shell32_hInstance, MAKEINTRESOURCEW(IDD_SHORTCUT_EXTENDED_PROPERTIES), hwndDlg, ExtendedShortcutProc, (LPARAM)m_bRunAs); if (result == 1 || result == 0) { if (m_bRunAs != result) { PropSheet_Changed(GetParent(hwndDlg), hwndDlg); }
m_bRunAs = result; } return; } } if (codeNotify == EN_CHANGE || codeNotify == CBN_SELCHANGE) { if (!m_bInInit) PropSheet_Changed(GetParent(hwndDlg), hwndDlg); }}
LRESULT CShellLink::OnNotify(HWND hwndDlg, int idFrom, LPNMHDR pnmhdr){ WCHAR wszBuf[MAX_PATH]; LPPSHNOTIFY lppsn = (LPPSHNOTIFY)pnmhdr;
if (lppsn->hdr.code == PSN_APPLY) { /* set working directory */ GetDlgItemTextW(hwndDlg, IDC_SHORTCUT_START_IN_EDIT, wszBuf, _countof(wszBuf)); SetWorkingDirectory(wszBuf);
/* set link destination */ HWND hWndTarget = GetDlgItem(hwndDlg, IDC_SHORTCUT_TARGET_TEXT); GetWindowTextW(hWndTarget, wszBuf, _countof(wszBuf)); // Only set the path and arguments for filesystem targets (we can't verify other targets) if (IsWindowEnabled(hWndTarget)) { LPWSTR lpszArgs = NULL; LPWSTR unquoted = wszBuf; StrTrimW(unquoted, L" ");
if (!PathFileExistsW(unquoted)) { lpszArgs = PathGetArgsW(unquoted); PathRemoveArgsW(unquoted); StrTrimW(lpszArgs, L" "); } if (unquoted[0] == '"' && unquoted[wcslen(unquoted) - 1] == '"') PathUnquoteSpacesW(unquoted);
WCHAR *pwszExt = PathFindExtensionW(unquoted); if (!_wcsicmp(pwszExt, L".lnk")) { // TODO: SLDF_ALLOW_LINK_TO_LINK (Win7+) // FIXME load localized error msg MessageBoxW(hwndDlg, L"You cannot create a link to a shortcut", NULL, MB_ICONERROR); SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE); return TRUE; }
if (!PathFileExistsW(unquoted)) { // FIXME load localized error msg MessageBoxW(hwndDlg, L"The specified file name in the target box is invalid", NULL, MB_ICONERROR); SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE); return TRUE; }
SetPath(unquoted); SetArguments(lpszArgs ? lpszArgs : L"\0"); }
m_Header.wHotKey = (WORD)SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_KEY_HOTKEY, HKM_GETHOTKEY, 0, 0);
int index = (int)SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_RUN_COMBO, CB_GETCURSEL, 0, 0); if (index != CB_ERR) { m_Header.nShowCommand = (UINT)SendDlgItemMessageW(hwndDlg, IDC_SHORTCUT_RUN_COMBO, CB_GETITEMDATA, index, 0); }
TRACE("This %p m_sLinkPath %S\n", this, m_sLinkPath); Save(m_sLinkPath, TRUE); SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATHW, m_sLinkPath, NULL); SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, PSNRET_NOERROR); return TRUE; } return FALSE;}
void CShellLink::OnDestroy(HWND hwndDlg){ if (m_hIcon) { DestroyIcon(m_hIcon); m_hIcon = NULL; }}
/************************************************************************** * SH_ShellLinkDlgProc * * dialog proc of the shortcut property dialog */
INT_PTR CALLBACKCShellLink::SH_ShellLinkDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam){ LPPROPSHEETPAGEW ppsp; CShellLink *pThis = reinterpret_cast<CShellLink *>(GetWindowLongPtr(hwndDlg, DWLP_USER));
switch (uMsg) { case WM_INITDIALOG: ppsp = (LPPROPSHEETPAGEW)lParam; if (ppsp == NULL) break;
pThis = reinterpret_cast<CShellLink *>(ppsp->lParam); SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pThis); return pThis->OnInitDialog(hwndDlg, (HWND)(wParam), lParam);
case WM_NOTIFY: return pThis->OnNotify(hwndDlg, (int)wParam, (NMHDR *)lParam);
case WM_COMMAND: pThis->OnCommand(hwndDlg, LOWORD(wParam), (HWND)lParam, HIWORD(wParam)); break;
case WM_DESTROY: pThis->OnDestroy(hwndDlg); break;
default: break; }
return FALSE;}
/************************************************************************** * ShellLink_IShellPropSheetExt interface */
HRESULT STDMETHODCALLTYPE CShellLink::AddPages(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam){ HPROPSHEETPAGE hPage = SH_CreatePropertySheetPageEx(IDD_SHORTCUT_PROPERTIES, SH_ShellLinkDlgProc, (LPARAM)this, NULL, &PropSheetPageLifetimeCallback<CShellLink>); HRESULT hr = AddPropSheetPage(hPage, pfnAddPage, lParam); if (FAILED_UNEXPECTEDLY(hr)) return hr; else AddRef(); // For PropSheetPageLifetimeCallback enum { CShellLink_PageIndex_Shortcut = 0 }; return 1 + CShellLink_PageIndex_Shortcut; // Make this page the default (one-based)}
HRESULT STDMETHODCALLTYPE CShellLink::ReplacePage(UINT uPageID, LPFNADDPROPSHEETPAGE pfnReplacePage, LPARAM lParam){ TRACE("(%p) (uPageID %u, pfnReplacePage %p lParam %p\n", this, uPageID, pfnReplacePage, lParam); return E_NOTIMPL;}
HRESULT STDMETHODCALLTYPE CShellLink::SetSite(IUnknown *punk){ TRACE("%p %p\n", this, punk);
m_site = punk;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::GetSite(REFIID iid, void ** ppvSite){ TRACE("%p %s %p\n", this, debugstr_guid(&iid), ppvSite);
if (m_site == NULL) return E_FAIL;
return m_site->QueryInterface(iid, ppvSite);}
HRESULT STDMETHODCALLTYPE CShellLink::DragEnter(IDataObject *pDataObject, DWORD dwKeyState, POINTL pt, DWORD *pdwEffect){ TRACE("(%p)->(DataObject=%p)\n", this, pDataObject);
if (*pdwEffect == DROPEFFECT_NONE) return S_OK;
HRESULT hr = SHELL_GetUIObjectOfAbsoluteItem(NULL, m_pPidl, IID_PPV_ARG(IDropTarget, &m_DropTarget)); if (SUCCEEDED(hr)) hr = m_DropTarget->DragEnter(pDataObject, dwKeyState, pt, pdwEffect); else *pdwEffect = DROPEFFECT_NONE;
return S_OK;}
HRESULT STDMETHODCALLTYPE CShellLink::DragOver(DWORD dwKeyState, POINTL pt, DWORD *pdwEffect){ TRACE("(%p)\n", this); HRESULT hr = S_OK; if (m_DropTarget) hr = m_DropTarget->DragOver(dwKeyState, pt, pdwEffect); return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::DragLeave(){ TRACE("(%p)\n", this); HRESULT hr = S_OK; if (m_DropTarget) { hr = m_DropTarget->DragLeave(); m_DropTarget.Release(); }
return hr;}
HRESULT STDMETHODCALLTYPE CShellLink::Drop(IDataObject *pDataObject, DWORD dwKeyState, POINTL pt, DWORD *pdwEffect){ TRACE("(%p)\n", this); HRESULT hr = S_OK; if (m_DropTarget) hr = m_DropTarget->Drop(pDataObject, dwKeyState, pt, pdwEffect);
return hr;}
/************************************************************************** * IShellLink_ConstructFromFile */HRESULT WINAPI IShellLink_ConstructFromPath(WCHAR *path, REFIID riid, LPVOID *ppv){ CComPtr<IPersistFile> ppf; HRESULT hr = CShellLink::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IPersistFile, &ppf)); if (FAILED(hr)) return hr;
hr = ppf->Load(path, 0); if (FAILED(hr)) return hr;
return ppf->QueryInterface(riid, ppv);}
HRESULT WINAPI IShellLink_ConstructFromFile(IShellFolder * psf, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv){ WCHAR path[MAX_PATH]; if (!ILGetDisplayNameExW(psf, pidl, path, 0)) return E_FAIL;
return IShellLink_ConstructFromPath(path, riid, ppv);}
HICON CShellLink::CreateShortcutIcon(LPCWSTR wszIconPath, INT IconIndex){ const INT cx = GetSystemMetrics(SM_CXICON), cy = GetSystemMetrics(SM_CYICON); const COLORREF crMask = GetSysColor(COLOR_3DFACE); WCHAR wszLnkIcon[MAX_PATH]; int lnk_idx; HDC hDC; HIMAGELIST himl = ImageList_Create(cx, cy, ILC_COLOR32 | ILC_MASK, 1, 1); HICON hIcon = NULL, hNewIcon = NULL, hShortcut;
if (HLM_GetIconW(IDI_SHELL_SHORTCUT - 1, wszLnkIcon, _countof(wszLnkIcon), &lnk_idx)) { ::ExtractIconExW(wszLnkIcon, lnk_idx, &hShortcut, NULL, 1); } else { hShortcut = (HICON)LoadImageW(shell32_hInstance, MAKEINTRESOURCE(IDI_SHELL_SHORTCUT), IMAGE_ICON, cx, cy, 0); }
::ExtractIconExW(wszIconPath, IconIndex, &hIcon, NULL, 1); if (!hIcon || !hShortcut || !himl) goto cleanup;
hDC = CreateCompatibleDC(NULL); if (hDC) { // create 32bpp bitmap BITMAPINFO bi; ZeroMemory(&bi, sizeof(bi)); bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bi.bmiHeader.biWidth = cx; bi.bmiHeader.biHeight = cy; bi.bmiHeader.biPlanes = 1; bi.bmiHeader.biBitCount = 32; LPVOID pvBits; HBITMAP hbm = CreateDIBSection(hDC, &bi, DIB_RGB_COLORS, &pvBits, NULL, 0); if (hbm) { // draw the icon image HGDIOBJ hbmOld = SelectObject(hDC, hbm); { HBRUSH hbr = CreateSolidBrush(crMask); RECT rc = { 0, 0, cx, cy }; FillRect(hDC, &rc, hbr); DeleteObject(hbr);
DrawIconEx(hDC, 0, 0, hIcon, cx, cy, 0, NULL, DI_NORMAL); DrawIconEx(hDC, 0, 0, hShortcut, cx, cy, 0, NULL, DI_NORMAL); } SelectObject(hDC, hbmOld);
INT iAdded = ImageList_AddMasked(himl, hbm, crMask); hNewIcon = ImageList_GetIcon(himl, iAdded, ILD_NORMAL | ILD_TRANSPARENT);
DeleteObject(hbm); } DeleteDC(hDC); }
cleanup: if (hIcon) DestroyIcon(hIcon); if (hShortcut) DestroyIcon(hShortcut); if (himl) ImageList_Destroy(himl);
return hNewIcon;}