shelllink.c 71.2 KB
Newer Older
1 2
/*
 *
3 4 5
 *      Copyright 1997  Marcus Meissner
 *      Copyright 1998  Juergen Schmied
 *      Copyright 2005  Mike McCormack
6
 *
7 8 9 10 11 12 13 14 15 16 17 18
 * 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
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 21
 *
 * NOTES
22
 *   Nearly complete information about the binary formats
23
 *   of .lnk files available at http://www.wotsit.org
24
 *
25 26 27 28 29 30 31 32
 *  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.
33 34
 */

35
#define COBJMACROS
36
#define NONAMELESSUNION
37

38
#include "wine/debug.h"
39
#include "winerror.h"
40
#include "windef.h"
41 42
#include "winbase.h"
#include "winnls.h"
43
#include "winreg.h"
44

45 46
#include "winuser.h"
#include "wingdi.h"
47
#include "shlobj.h"
48
#include "undocshell.h"
49

50
#include "pidl.h"
51
#include "shell32_main.h"
52
#include "shlguid.h"
53
#include "shlwapi.h"
54
#include "msi.h"
55
#include "appmgmt.h"
56

57 58
#include "initguid.h"

59
WINE_DEFAULT_DEBUG_CHANNEL(shell);
60

61 62 63 64 65
DEFINE_GUID( SHELL32_AdvtShortcutProduct,
       0x9db1186f,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);
DEFINE_GUID( SHELL32_AdvtShortcutComponent,
       0x9db1186e,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);

66 67
/* link file formats */

68
#include "pshpack1.h"
69

70
typedef struct _LINK_HEADER
71 72 73 74 75
{
	DWORD    dwSize;	/* 0x00 size of the header - 0x4c */
	GUID     MagicGuid;	/* 0x04 is CLSID_ShellLink */
	DWORD    dwFlags;	/* 0x14 describes elements following */
	DWORD    dwFileAttr;	/* 0x18 attributes of the target file */
76 77 78
	FILETIME Time1;		/* 0x1c */
	FILETIME Time2;		/* 0x24 */
	FILETIME Time3;		/* 0x2c */
79 80
	DWORD    dwFileLength;	/* 0x34 File length */
	DWORD    nIcon;		/* 0x38 icon number */
81
	DWORD	fStartup;	/* 0x3c startup type */
82
	DWORD	wHotKey;	/* 0x40 hotkey */
83 84 85 86
	DWORD	Unknown5;	/* 0x44 */
	DWORD	Unknown6;	/* 0x48 */
} LINK_HEADER, * PLINK_HEADER;

87 88
#define SHLINK_LOCAL  0
#define SHLINK_REMOTE 1
89

90
typedef struct _LOCATION_INFO
91
{
92 93 94 95 96 97 98 99
    DWORD  dwTotalSize;
    DWORD  dwHeaderSize;
    DWORD  dwFlags;
    DWORD  dwVolTableOfs;
    DWORD  dwLocalPathOfs;
    DWORD  dwNetworkVolTableOfs;
    DWORD  dwFinalPathOfs;
} LOCATION_INFO;
100

101
typedef struct _LOCAL_VOLUME_INFO
102
{
103 104 105 106 107
    DWORD dwSize;
    DWORD dwType;
    DWORD dwVolSerial;
    DWORD dwVolLabelOfs;
} LOCAL_VOLUME_INFO;
108

109 110 111 112 113 114 115
typedef struct volume_info_t
{
    DWORD type;
    DWORD serial;
    WCHAR label[12];  /* assume 8.3 */
} volume_info;

116
#include "poppack.h"
117

118 119 120
static const IShellLinkAVtbl slvt;
static const IShellLinkWVtbl slvtw;
static const IPersistFileVtbl pfvt;
121
static const IPersistStreamVtbl psvt;
122
static const IShellLinkDataListVtbl dlvt;
123
static const IShellExtInitVtbl eivt;
124
static const IContextMenuVtbl cmvt;
125
static const IObjectWithSiteVtbl owsvt;
126 127 128

/* IShellLink Implementation */

129 130
typedef struct
{
131
        IShellLinkA IShellLinkA_iface;
132 133 134 135 136 137 138
        IShellLinkW IShellLinkW_iface;
        IPersistFile IPersistFile_iface;
        IPersistStream IPersistStream_iface;
        IShellLinkDataList IShellLinkDataList_iface;
        IShellExtInit IShellExtInit_iface;
        IContextMenu IContextMenu_iface;
        IObjectWithSite IObjectWithSite_iface;
139

Mike McCormack's avatar
Mike McCormack committed
140
	LONG            ref;
141

142
	/* data structures according to the information in the link */
143
	LPITEMIDLIST	pPidl;
144
	WORD		wHotKey;
145 146 147
	SYSTEMTIME	time1;
	SYSTEMTIME	time2;
	SYSTEMTIME	time3;
148

149 150 151 152 153 154 155 156
	DWORD         iShowCmd;
	LPWSTR        sIcoPath;
	INT           iIcoNdx;
	LPWSTR        sPath;
	LPWSTR        sArgs;
	LPWSTR        sWorkDir;
	LPWSTR        sDescription;
	LPWSTR        sPathRel;
157 158 159
 	LPWSTR        sProduct;
 	LPWSTR        sComponent;
	volume_info   volume;
160

161
	BOOL          bDirty;
162
        INT           iIdOpen;  /* id of the "Open" entry in the context menu */
163
	IUnknown      *site;
164 165

	LPOLESTR      filepath; /* file path returned by IPersistFile::GetCurFile */
166
} IShellLinkImpl;
167

168 169 170 171 172
static inline IShellLinkImpl *impl_from_IShellLinkA(IShellLinkA *iface)
{
    return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkA_iface);
}

173
static inline IShellLinkImpl *impl_from_IShellLinkW(IShellLinkW *iface)
174
{
175
    return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkW_iface);
176
}
177

178
static inline IShellLinkImpl *impl_from_IPersistFile(IPersistFile *iface)
179
{
180
    return CONTAINING_RECORD(iface, IShellLinkImpl, IPersistFile_iface);
181
}
182

183
static inline IShellLinkImpl *impl_from_IPersistStream(IPersistStream *iface)
184
{
185
    return CONTAINING_RECORD(iface, IShellLinkImpl, IPersistStream_iface);
186 187
}

188
static inline IShellLinkImpl *impl_from_IShellLinkDataList(IShellLinkDataList *iface)
189
{
190
    return CONTAINING_RECORD(iface, IShellLinkImpl, IShellLinkDataList_iface);
191
}
192

193
static inline IShellLinkImpl *impl_from_IShellExtInit(IShellExtInit *iface)
194
{
195
    return CONTAINING_RECORD(iface, IShellLinkImpl, IShellExtInit_iface);
196
}
197

198
static inline IShellLinkImpl *impl_from_IContextMenu(IContextMenu *iface)
199
{
200
    return CONTAINING_RECORD(iface, IShellLinkImpl, IContextMenu_iface);
201 202
}

203
static inline IShellLinkImpl *impl_from_IObjectWithSite(IObjectWithSite *iface)
204
{
205
    return CONTAINING_RECORD(iface, IShellLinkImpl, IObjectWithSite_iface);
206 207
}

208
static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
209 210

/* strdup on the process heap */
211
static inline LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
212
{
213 214 215 216 217
    INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
    LPWSTR p = HeapAlloc( heap, flags, len*sizeof (WCHAR) );
    if( !p )
        return p;
    MultiByteToWideChar( CP_ACP, 0, str, -1, p, len );
218 219 220
    return p;
}

221
static inline LPWSTR strdupW( LPCWSTR src )
222 223 224 225 226 227 228 229 230
{
    LPWSTR dest;
    if (!src) return NULL;
    dest = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(src)+1)*sizeof(WCHAR) );
    if (dest)
        lstrcpyW(dest, src);
    return dest;
}

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/**************************************************************************
 *  ShellLink::QueryInterface implementation
 */
static HRESULT ShellLink_QueryInterface( IShellLinkImpl *This, REFIID riid,  LPVOID *ppvObj)
{
    TRACE("(%p)->(\n\tIID:\t%s)\n",This,debugstr_guid(riid));

    *ppvObj = NULL;

    if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IShellLinkA))
    {
        *ppvObj = This;
    }
    else if(IsEqualIID(riid, &IID_IShellLinkW))
    {
246
        *ppvObj = &This->IShellLinkW_iface;
247 248 249
    }
    else if(IsEqualIID(riid, &IID_IPersistFile))
    {
250
        *ppvObj = &This->IPersistFile_iface;
251 252 253
    }
    else if(IsEqualIID(riid, &IID_IPersistStream))
    {
254
        *ppvObj = &This->IPersistStream_iface;
255 256 257
    }
    else if(IsEqualIID(riid, &IID_IShellLinkDataList))
    {
258
        *ppvObj = &This->IShellLinkDataList_iface;
259 260 261
    }
    else if(IsEqualIID(riid, &IID_IShellExtInit))
    {
262
        *ppvObj = &This->IShellExtInit_iface;
263 264 265
    }
    else if(IsEqualIID(riid, &IID_IContextMenu))
    {
266
        *ppvObj = &This->IContextMenu_iface;
267
    }
268 269
    else if(IsEqualIID(riid, &IID_IObjectWithSite))
    {
270
        *ppvObj = &This->IObjectWithSite_iface;
271
    }
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289

    if(*ppvObj)
    {
        IUnknown_AddRef((IUnknown*)(*ppvObj));
        TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
        return S_OK;
    }
    ERR("-- Interface: E_NOINTERFACE\n");
    return E_NOINTERFACE;
}

/**************************************************************************
 *  ShellLink::AddRef implementation
 */
static ULONG ShellLink_AddRef( IShellLinkImpl *This )
{
    ULONG refCount = InterlockedIncrement(&This->ref);

290
    TRACE("(%p)->(count=%u)\n", This, refCount - 1);
291 292 293 294 295 296 297 298 299 300 301

    return refCount;
}

/**************************************************************************
 *  ShellLink::Release implementation
 */
static ULONG ShellLink_Release( IShellLinkImpl *This )
{
    ULONG refCount = InterlockedDecrement(&This->ref);

302
    TRACE("(%p)->(count=%u)\n", This, refCount + 1);
303 304 305 306 307 308 309 310 311 312

    if (refCount)
        return refCount;

    TRACE("-- destroying IShellLink(%p)\n",This);

    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
    HeapFree(GetProcessHeap(), 0, This->sArgs);
    HeapFree(GetProcessHeap(), 0, This->sWorkDir);
    HeapFree(GetProcessHeap(), 0, This->sDescription);
313 314 315 316
    HeapFree(GetProcessHeap(), 0, This->sPath);
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
    HeapFree(GetProcessHeap(), 0, This->sProduct);
    HeapFree(GetProcessHeap(), 0, This->sComponent);
317
    HeapFree(GetProcessHeap(), 0, This->filepath);
318

319 320 321
    if (This->site)
        IUnknown_Release( This->site );

322 323 324
    if (This->pPidl)
        ILFree(This->pPidl);

325
    LocalFree(This);
326 327 328 329 330 331 332 333

    return 0;
}

static HRESULT ShellLink_GetClassID( IShellLinkImpl *This, CLSID *pclsid )
{
    TRACE("%p %p\n", This, pclsid);

334
    *pclsid = CLSID_ShellLink;
335 336 337
    return S_OK;
}

338 339 340
/**************************************************************************
 *  IPersistFile_QueryInterface
 */
341
static HRESULT WINAPI IPersistFile_fnQueryInterface(
342 343 344
	IPersistFile* iface,
	REFIID riid,
	LPVOID *ppvObj)
345
{
346
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
347
    return ShellLink_QueryInterface( This, riid, ppvObj );
348
}
349 350 351 352

/******************************************************************************
 * IPersistFile_AddRef
 */
353
static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
354
{
355
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
356
    return ShellLink_AddRef( This );
357
}
358

359 360 361
/******************************************************************************
 * IPersistFile_Release
 */
362
static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
363
{
364
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
365
    return IShellLinkA_Release(&This->IShellLinkA_iface);
366 367
}

Patrik Stridvall's avatar
Patrik Stridvall committed
368
static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile* iface, CLSID *pClassID)
369
{
370
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
371
    return ShellLink_GetClassID( This, pClassID );
372
}
373

Patrik Stridvall's avatar
Patrik Stridvall committed
374
static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile* iface)
375
{
376
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
377 378 379 380 381 382 383

	TRACE("(%p)\n",This);

	if (This->bDirty)
	    return S_OK;

	return S_FALSE;
384
}
385

386
static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR pszFileName, DWORD dwMode)
387
{
388
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
389
        IPersistStream *StreamThis = &This->IPersistStream_iface;
390 391
        HRESULT r;
        IStream *stm;
392

393
        TRACE("(%p, %s, %x)\n",This, debugstr_w(pszFileName), dwMode);
394

395 396 397
        if( dwMode == 0 )
 		dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
        r = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
398
        if( SUCCEEDED( r ) )
399
        {
400
            r = IPersistStream_Load(StreamThis, stm);
401
            ShellLink_UpdatePath(This->sPathRel, pszFileName, This->sWorkDir, &This->sPath);
402
            IStream_Release( stm );
403 404 405 406 407

            /* update file path */
            HeapFree(GetProcessHeap(), 0, This->filepath);
            This->filepath = strdupW(pszFileName);

408
            This->bDirty = FALSE;
409
        }
410
        TRACE("-- returning hr %08x\n", r);
411
        return r;
412 413
}

414
BOOL run_winemenubuilder( const WCHAR *args )
415
{
416
    static const WCHAR menubuilder[] = {'\\','w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',0};
417 418 419 420
    LONG len;
    LPWSTR buffer;
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
421
    BOOL ret;
422
    WCHAR app[MAX_PATH];
423
    void *redir;
424

425 426 427 428
    GetSystemDirectoryW( app, MAX_PATH - sizeof(menubuilder)/sizeof(WCHAR) );
    strcatW( app, menubuilder );

    len = (strlenW( app ) + strlenW( args ) + 1) * sizeof(WCHAR);
429 430 431
    buffer = HeapAlloc( GetProcessHeap(), 0, len );
    if( !buffer )
        return FALSE;
432

433 434
    strcpyW( buffer, app );
    strcatW( buffer, args );
435

436
    TRACE("starting %s\n",debugstr_w(buffer));
437

438 439
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
440

441
    Wow64DisableWow64FsRedirection( &redir );
442
    ret = CreateProcessW( app, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );
443
    Wow64RevertWow64FsRedirection( redir );
444 445 446 447 448 449 450 451 452 453

    HeapFree( GetProcessHeap(), 0, buffer );

    if (ret)
    {
        CloseHandle( pi.hProcess );
        CloseHandle( pi.hThread );
    }

    return ret;
454 455
}

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
static BOOL StartLinkProcessor( LPCOLESTR szLink )
{
    static const WCHAR szFormat[] = {' ','-','w',' ','"','%','s','"',0 };
    LONG len;
    LPWSTR buffer;
    BOOL ret;

    len = sizeof(szFormat) + lstrlenW( szLink ) * sizeof(WCHAR);
    buffer = HeapAlloc( GetProcessHeap(), 0, len );
    if( !buffer )
        return FALSE;

    wsprintfW( buffer, szFormat, szLink );
    ret = run_winemenubuilder( buffer );
    HeapFree( GetProcessHeap(), 0, buffer );
    return ret;
}

474
static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR pszFileName, BOOL fRemember)
475
{
476
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
477
    IPersistStream *StreamThis = &This->IPersistStream_iface;
478 479
    HRESULT r;
    IStream *stm;
480 481 482

    TRACE("(%p)->(%s)\n",This,debugstr_w(pszFileName));

483
    if (!pszFileName)
484
        return E_FAIL;
485

486
    r = SHCreateStreamOnFileW( pszFileName, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &stm );
487
    if( SUCCEEDED( r ) )
488
    {
489 490
        r = IPersistStream_Save(StreamThis, stm, FALSE);
        IStream_Release( stm );
491

492
        if( SUCCEEDED( r ) )
493
	{
494
            StartLinkProcessor( pszFileName );
495

496 497 498 499
            /* update file path */
            HeapFree(GetProcessHeap(), 0, This->filepath);
            This->filepath = strdupW(pszFileName);

500
            This->bDirty = FALSE;
501 502
        }
	else
503
        {
504 505
            DeleteFileW( pszFileName );
            WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
506 507
        }
    }
508

509
    return r;
510
}
511

512
static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR filename)
513
{
514 515 516
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
    FIXME("(%p)->(%s): stub\n", This, debugstr_w(filename));
    return S_OK;
517
}
518

519
static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile* iface, LPOLESTR *filename)
520
{
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
    IMalloc *pMalloc;

    TRACE("(%p)->(%p)\n", This, filename);

    if (!This->filepath)
    {
        *filename = NULL;
        return S_FALSE;
    }

    SHGetMalloc(&pMalloc);
    *filename = IMalloc_Alloc(pMalloc, (strlenW(This->filepath)+1)*sizeof(WCHAR));
    if (!*filename) return E_OUTOFMEMORY;

    strcpyW(*filename, This->filepath);

    return S_OK;
539
}
540

541
static const IPersistFileVtbl pfvt =
542
{
543 544 545 546 547 548 549 550 551
	IPersistFile_fnQueryInterface,
	IPersistFile_fnAddRef,
	IPersistFile_fnRelease,
	IPersistFile_fnGetClassID,
	IPersistFile_fnIsDirty,
	IPersistFile_fnLoad,
	IPersistFile_fnSave,
	IPersistFile_fnSaveCompleted,
	IPersistFile_fnGetCurFile
552
};
553

554 555
/************************************************************************
 * IPersistStream_QueryInterface
556
 */
557 558 559
static HRESULT WINAPI IPersistStream_fnQueryInterface(
	IPersistStream* iface,
	REFIID     riid,
560
	VOID**     ppvObj)
561
{
562
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
563
    return ShellLink_QueryInterface( This, riid, ppvObj );
564
}
565

566 567 568 569 570
/************************************************************************
 * IPersistStream_Release
 */
static ULONG WINAPI IPersistStream_fnRelease(
	IPersistStream* iface)
571
{
572
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
573
    return IShellLinkA_Release(&This->IShellLinkA_iface);
574
}
575 576 577

/************************************************************************
 * IPersistStream_AddRef
578
 */
579 580
static ULONG WINAPI IPersistStream_fnAddRef(
	IPersistStream* iface)
581
{
582
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
583
    return ShellLink_AddRef( This );
584
}
585

586 587 588
/************************************************************************
 * IPersistStream_GetClassID
 *
589
 */
590
static HRESULT WINAPI IPersistStream_fnGetClassID(
Patrik Stridvall's avatar
Patrik Stridvall committed
591
	IPersistStream* iface,
592
	CLSID* pClassID)
593
{
594
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
595
    return ShellLink_GetClassID( This, pClassID );
596
}
597 598 599

/************************************************************************
 * IPersistStream_IsDirty (IPersistStream)
600
 */
601 602
static HRESULT WINAPI IPersistStream_fnIsDirty(
	IPersistStream*  iface)
603
{
604
	IShellLinkImpl *This = impl_from_IPersistStream(iface);
605

606 607 608
	TRACE("(%p)\n", This);

	return S_OK;
609
}
610 611 612 613 614 615 616 617 618 619 620 621 622


static HRESULT Stream_LoadString( IStream* stm, BOOL unicode, LPWSTR *pstr )
{
    DWORD count;
    USHORT len;
    LPVOID temp;
    LPWSTR str;
    HRESULT r;

    TRACE("%p\n", stm);

    count = 0;
623 624
    r = IStream_Read(stm, &len, sizeof(len), &count);
    if ( FAILED (r) || ( count != sizeof(len) ) )
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
        return E_FAIL;

    if( unicode )
        len *= sizeof (WCHAR);

    TRACE("reading %d\n", len);
    temp = HeapAlloc(GetProcessHeap(), 0, len+sizeof(WCHAR));
    if( !temp )
        return E_OUTOFMEMORY;
    count = 0;
    r = IStream_Read(stm, temp, len, &count);
    if( FAILED (r) || ( count != len ) )
    {
        HeapFree( GetProcessHeap(), 0, temp );
        return E_FAIL;
    }

    TRACE("read %s\n", debugstr_an(temp,len));

    /* convert to unicode if necessary */
    if( !unicode )
    {
647
        count = MultiByteToWideChar( CP_ACP, 0, temp, len, NULL, 0 );
648
        str = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
649 650 651 652 653
        if( !str )
        {
            HeapFree( GetProcessHeap(), 0, temp );
            return E_OUTOFMEMORY;
        }
654
        MultiByteToWideChar( CP_ACP, 0, temp, len, str, count );
655 656 657 658 659
        HeapFree( GetProcessHeap(), 0, temp );
    }
    else
    {
        count /= 2;
660
        str = temp;
661 662 663 664 665 666 667 668
    }
    str[count] = 0;

    *pstr = str;

    return S_OK;
}

669
static HRESULT Stream_ReadChunk( IStream* stm, LPVOID *data )
670 671 672 673
{
    DWORD size;
    ULONG count;
    HRESULT r;
674 675 676 677
    struct sized_chunk {
        DWORD size;
        unsigned char data[1];
    } *chunk;
678 679 680

    TRACE("%p\n",stm);

681
    r = IStream_Read( stm, &size, sizeof(size), &count );
682
    if( FAILED( r )  || count != sizeof(size) )
683 684
        return E_FAIL;

685 686
    chunk = HeapAlloc( GetProcessHeap(), 0, size );
    if( !chunk )
687 688
        return E_OUTOFMEMORY;

689 690 691 692 693 694 695 696
    chunk->size = size;
    r = IStream_Read( stm, chunk->data, size - sizeof(size), &count );
    if( FAILED( r ) || count != (size - sizeof(size)) )
    {
        HeapFree( GetProcessHeap(), 0, chunk );
        return E_FAIL;
    }

697
    TRACE("Read %d bytes\n",chunk->size);
698

699
    *data = chunk;
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725

    return S_OK;
}

static BOOL Stream_LoadVolume( LOCAL_VOLUME_INFO *vol, volume_info *volume )
{
    const int label_sz = sizeof volume->label/sizeof volume->label[0];
    LPSTR label;
    int len;

    volume->serial = vol->dwVolSerial;
    volume->type = vol->dwType;

    if( !vol->dwVolLabelOfs )
        return FALSE;
    if( vol->dwSize <= vol->dwVolLabelOfs )
        return FALSE;
    len = vol->dwSize - vol->dwVolLabelOfs;

    label = (LPSTR) vol;
    label += vol->dwVolLabelOfs;
    MultiByteToWideChar( CP_ACP, 0, label, len, volume->label, label_sz-1);

    return TRUE;
}

726
static LPWSTR Stream_LoadPath( LPCSTR p, DWORD maxlen )
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
{
    int len = 0, wlen;
    LPWSTR path;

    while( p[len] && (len < maxlen) )
        len++;

    wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
    path = HeapAlloc(GetProcessHeap(), 0, (wlen+1)*sizeof(WCHAR));
    MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen);
    path[wlen] = 0;

    return path;
}

static HRESULT Stream_LoadLocation( IStream *stm,
                volume_info *volume, LPWSTR *path )
{
Mike McCormack's avatar
Mike McCormack committed
745
    char *p = NULL;
746 747
    LOCATION_INFO *loc;
    HRESULT r;
748
    DWORD n;
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775

    r = Stream_ReadChunk( stm, (LPVOID*) &p );
    if( FAILED(r) )
        return r;

    loc = (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 */
    n = loc->dwLocalPathOfs;
    if( n && (n < loc->dwTotalSize) )
        *path = Stream_LoadPath( &p[n], loc->dwTotalSize - n );

776
    TRACE("type %d serial %08x name %s path %s\n", volume->type,
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
          volume->serial, debugstr_w(volume->label), debugstr_w(*path));

    HeapFree( GetProcessHeap(), 0, p );
    return S_OK;
}

/*
 *  The format of the advertised shortcut info seems to be:
 *
 *  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.
 */
static HRESULT Stream_LoadAdvertiseInfo( IStream* stm, LPWSTR *str )
{
    DWORD size;
    ULONG count;
    HRESULT r;
802
    EXP_DARWIN_LINK buffer;
803 804 805
    
    TRACE("%p\n",stm);

806
    r = IStream_Read( stm, &buffer.dbh.cbSize, sizeof (DWORD), &count );
807
    if( FAILED( r ) )
808 809 810 811
        return r;

    /* make sure that we read the size of the structure even on error */
    size = sizeof buffer - sizeof (DWORD);
812
    if( buffer.dbh.cbSize != sizeof buffer )
813
    {
814
        ERR("Ooops.  This structure is not as expected...\n");
815
        return E_FAIL;
816 817
    }

818
    r = IStream_Read( stm, &buffer.dbh.dwSignature, size, &count );
819 820 821 822 823 824
    if( FAILED( r ) )
        return r;

    if( count != size )
        return E_FAIL;

825
    TRACE("magic %08x  string = %s\n", buffer.dbh.dwSignature, debugstr_w(buffer.szwDarwinID));
826

827
    if( (buffer.dbh.dwSignature&0xffff0000) != 0xa0000000 )
828
    {
829
        ERR("Unknown magic number %08x in advertised shortcut\n", buffer.dbh.dwSignature);
830 831
        return E_FAIL;
    }
832

833
    *str = HeapAlloc( GetProcessHeap(), 0, 
834 835
                     (lstrlenW(buffer.szwDarwinID)+1) * sizeof(WCHAR) );
    lstrcpyW( *str, buffer.szwDarwinID );
836 837 838 839

    return S_OK;
}

840 841
/************************************************************************
 * IPersistStream_Load (IPersistStream)
842
 */
843
static HRESULT WINAPI IPersistStream_fnLoad(
844
    IPersistStream*  iface,
845
    IStream*         stm)
846
{
847 848 849 850
    LINK_HEADER hdr;
    ULONG    dwBytesRead;
    BOOL     unicode;
    HRESULT  r;
851
    DWORD    zero;
852

853
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
854

855
    TRACE("%p %p\n", This, stm);
856

857
    if( !stm )
858
        return STG_E_INVALIDPOINTER;
859

860
    dwBytesRead = 0;
861
    r = IStream_Read(stm, &hdr, sizeof(hdr), &dwBytesRead);
862 863
    if( FAILED( r ) )
        return r;
864

865
    if( dwBytesRead != sizeof(hdr))
866
        return E_FAIL;
867
    if( hdr.dwSize != sizeof(hdr))
868 869 870
        return E_FAIL;
    if( !IsEqualIID(&hdr.MagicGuid, &CLSID_ShellLink) )
        return E_FAIL;
871

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
    /* free all the old stuff */
    ILFree(This->pPidl);
    This->pPidl = NULL;
    memset( &This->volume, 0, sizeof This->volume );
    HeapFree(GetProcessHeap(), 0, This->sPath);
    This->sPath = NULL;
    HeapFree(GetProcessHeap(), 0, This->sDescription);
    This->sDescription = NULL;
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
    This->sPathRel = NULL;
    HeapFree(GetProcessHeap(), 0, This->sWorkDir);
    This->sWorkDir = NULL;
    HeapFree(GetProcessHeap(), 0, This->sArgs);
    This->sArgs = NULL;
    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
    This->sIcoPath = NULL;
    HeapFree(GetProcessHeap(), 0, This->sProduct);
    This->sProduct = NULL;
    HeapFree(GetProcessHeap(), 0, This->sComponent);
    This->sComponent = NULL;
        
893
    This->wHotKey = (WORD)hdr.wHotKey;
894 895 896 897
    This->iIcoNdx = hdr.nIcon;
    FileTimeToSystemTime (&hdr.Time1, &This->time1);
    FileTimeToSystemTime (&hdr.Time2, &This->time2);
    FileTimeToSystemTime (&hdr.Time3, &This->time3);
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
    if (TRACE_ON(shell))
    {
        WCHAR sTemp[MAX_PATH];
        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time1,
                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
        TRACE("-- time1: %s\n", debugstr_w(sTemp) );
        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time2,
                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
        TRACE("-- time2: %s\n", debugstr_w(sTemp) );
        GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time3,
                       NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
        TRACE("-- time3: %s\n", debugstr_w(sTemp) );
    }

    /* load all the new stuff */
913
    if( hdr.dwFlags & SLDF_HAS_ID_LIST )
914 915 916 917 918 919 920 921
    {
        r = ILLoadFromStream( stm, &This->pPidl );
        if( FAILED( r ) )
            return r;
    }
    pdump(This->pPidl);

    /* load the location information */
922
    if( hdr.dwFlags & SLDF_HAS_LINK_INFO )
923
        r = Stream_LoadLocation( stm, &This->volume, &This->sPath );
924 925
    if( FAILED( r ) )
        goto end;
926

927 928
    unicode = hdr.dwFlags & SLDF_UNICODE;
    if( hdr.dwFlags & SLDF_HAS_NAME )
929 930 931 932 933 934
    {
        r = Stream_LoadString( stm, unicode, &This->sDescription );
        TRACE("Description  -> %s\n",debugstr_w(This->sDescription));
    }
    if( FAILED( r ) )
        goto end;
935

936
    if( hdr.dwFlags & SLDF_HAS_RELPATH )
937 938 939 940 941 942
    {
        r = Stream_LoadString( stm, unicode, &This->sPathRel );
        TRACE("Relative Path-> %s\n",debugstr_w(This->sPathRel));
    }
    if( FAILED( r ) )
        goto end;
943

944
    if( hdr.dwFlags & SLDF_HAS_WORKINGDIR )
945
    {
946 947 948 949 950
        r = Stream_LoadString( stm, unicode, &This->sWorkDir );
        TRACE("Working Dir  -> %s\n",debugstr_w(This->sWorkDir));
    }
    if( FAILED( r ) )
        goto end;
951

952
    if( hdr.dwFlags & SLDF_HAS_ARGS )
953 954 955 956 957 958 959
    {
        r = Stream_LoadString( stm, unicode, &This->sArgs );
        TRACE("Working Dir  -> %s\n",debugstr_w(This->sArgs));
    }
    if( FAILED( r ) )
        goto end;

960
    if( hdr.dwFlags & SLDF_HAS_ICONLOCATION )
961 962 963 964 965 966 967
    {
        r = Stream_LoadString( stm, unicode, &This->sIcoPath );
        TRACE("Icon file    -> %s\n",debugstr_w(This->sIcoPath));
    }
    if( FAILED( r ) )
        goto end;

968
    if( hdr.dwFlags & SLDF_HAS_LOGO3ID )
969 970 971 972 973 974 975
    {
        r = Stream_LoadAdvertiseInfo( stm, &This->sProduct );
        TRACE("Product      -> %s\n",debugstr_w(This->sProduct));
    }
    if( FAILED( r ) )
        goto end;

976
    if( hdr.dwFlags & SLDF_HAS_DARWINID )
977 978 979 980 981 982 983 984 985
    {
        r = Stream_LoadAdvertiseInfo( stm, &This->sComponent );
        TRACE("Component    -> %s\n",debugstr_w(This->sComponent));
    }
    if( FAILED( r ) )
        goto end;

    r = IStream_Read(stm, &zero, sizeof zero, &dwBytesRead);
    if( FAILED( r ) || zero || dwBytesRead != sizeof zero )
986 987 988 989 990 991 992 993
    {
        /* Some lnk files have extra data blocks starting with a
         * DATABLOCK_HEADER. For instance EXP_SPECIAL_FOLDER and an unknown
         * one with a 0xa0000003 signature. However these don't seem to matter
         * too much.
         */
        WARN("Last word was not zero\n");
    }
994

995 996 997
    TRACE("OK\n");

    pdump (This->pPidl);
998

999
    return S_OK;
1000
end:
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
    return r;
}

/************************************************************************
 * 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 )
{
    USHORT len = lstrlenW( str ) + 1;
    DWORD count;
    HRESULT r;

1016
    r = IStream_Write( stm, &len, sizeof(len), &count );
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
    if( FAILED( r ) )
        return r;

    len *= sizeof(WCHAR);

    r = IStream_Write( stm, str, len, &count );
    if( FAILED( r ) )
        return r;

    return S_OK;
}
1028

1029 1030 1031 1032 1033 1034 1035
/************************************************************************
 * 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.
1036
 *        Figure out how Windows deals with unicode paths here.
1037 1038 1039 1040 1041 1042 1043 1044 1045
 */
static HRESULT Stream_WriteLocationInfo( IStream* stm, LPCWSTR path,
                                         volume_info *volume )
{
    DWORD total_size, path_size, volume_info_size, label_size, final_path_size;
    LOCAL_VOLUME_INFO *vol;
    LOCATION_INFO *loc;
    LPSTR szLabel, szPath, szFinalPath;
    ULONG count = 0;
1046
    HRESULT hr;
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087

    TRACE("%p %s %p\n", stm, debugstr_w(path), volume);

    /* figure out the size of everything */
    label_size = WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
                                      NULL, 0, NULL, NULL );
    path_size = WideCharToMultiByte( CP_ACP, 0, path, -1,
                                     NULL, 0, NULL, NULL );
    volume_info_size = sizeof *vol + label_size;
    final_path_size = 1;
    total_size = sizeof *loc + volume_info_size + path_size + final_path_size;

    /* create pointers to everything */
    loc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size);
    vol = (LOCAL_VOLUME_INFO*) &loc[1];
    szLabel = (LPSTR) &vol[1];
    szPath = &szLabel[label_size];
    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] = 0;

1088 1089 1090 1091
    hr = IStream_Write( stm, loc, total_size, &count );
    HeapFree(GetProcessHeap(), 0, loc);

    return hr;
1092 1093
}

1094 1095 1096 1097 1098
static EXP_DARWIN_LINK* shelllink_build_darwinid( LPCWSTR string, DWORD magic )
{
    EXP_DARWIN_LINK *buffer;
    
    buffer = LocalAlloc( LMEM_ZEROINIT, sizeof *buffer );
1099
    buffer->dbh.cbSize = sizeof *buffer;
1100 1101 1102 1103 1104 1105 1106
    buffer->dbh.dwSignature = magic;
    lstrcpynW( buffer->szwDarwinID, string, MAX_PATH );
    WideCharToMultiByte(CP_ACP, 0, string, -1, buffer->szDarwinID, MAX_PATH, NULL, NULL );

    return buffer;
}

1107
static HRESULT Stream_WriteAdvertiseInfo( IStream* stm, LPCWSTR string, DWORD magic )
1108
{
1109
    EXP_DARWIN_LINK *buffer;
1110
    ULONG count;
1111 1112
    
    TRACE("%p\n",stm);
1113

1114
    buffer = shelllink_build_darwinid( string, magic );
1115

1116
    return IStream_Write( stm, buffer, buffer->dbh.cbSize, &count );
1117
}
1118 1119 1120

/************************************************************************
 * IPersistStream_Save (IPersistStream)
1121 1122
 *
 * FIXME: makes assumptions about byte order
1123
 */
1124 1125
static HRESULT WINAPI IPersistStream_fnSave(
	IPersistStream*  iface,
1126
	IStream*         stm,
1127
	BOOL             fClearDirty)
1128
{
1129
    LINK_HEADER header;
1130
    ULONG   count;
1131
    DWORD   zero;
1132
    HRESULT r;
1133

1134
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
1135

1136
    TRACE("%p %p %x\n", This, stm, fClearDirty);
1137

1138 1139
    memset(&header, 0, sizeof(header));
    header.dwSize = sizeof(header);
1140
    header.fStartup = This->iShowCmd;
1141
    header.MagicGuid = CLSID_ShellLink;
1142 1143 1144

    header.wHotKey = This->wHotKey;
    header.nIcon = This->iIcoNdx;
1145
    header.dwFlags = SLDF_UNICODE;   /* strings are in unicode */
1146
    if( This->pPidl )
1147
        header.dwFlags |= SLDF_HAS_ID_LIST;
1148
    if( This->sPath )
1149
        header.dwFlags |= SLDF_HAS_LINK_INFO;
1150
    if( This->sDescription )
1151
        header.dwFlags |= SLDF_HAS_NAME;
1152
    if( This->sWorkDir )
1153
        header.dwFlags |= SLDF_HAS_WORKINGDIR;
1154
    if( This->sArgs )
1155
        header.dwFlags |= SLDF_HAS_ARGS;
1156
    if( This->sIcoPath )
1157
        header.dwFlags |= SLDF_HAS_ICONLOCATION;
1158
    if( This->sProduct )
1159
        header.dwFlags |= SLDF_HAS_LOGO3ID;
1160
    if( This->sComponent )
1161
        header.dwFlags |= SLDF_HAS_DARWINID;
1162 1163 1164 1165 1166 1167

    SystemTimeToFileTime ( &This->time1, &header.Time1 );
    SystemTimeToFileTime ( &This->time2, &header.Time2 );
    SystemTimeToFileTime ( &This->time3, &header.Time3 );

    /* write the Shortcut header */
1168
    r = IStream_Write( stm, &header, sizeof(header), &count );
1169 1170 1171 1172 1173 1174
    if( FAILED( r ) )
    {
        ERR("Write failed at %d\n",__LINE__);
        return r;
    }

1175
    TRACE("Writing pidl\n");
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187

    /* write the PIDL to the shortcut */
    if( This->pPidl )
    {
        r = ILSaveToStream( stm, This->pPidl );
        if( FAILED( r ) )
        {
            ERR("Failed to write PIDL at %d\n",__LINE__);
            return r;
        }
    }

1188
    if( This->sPath )
1189
        Stream_WriteLocationInfo( stm, This->sPath, &This->volume );
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205

    if( This->sDescription )
        r = Stream_WriteString( stm, This->sDescription );

    if( This->sPathRel )
        r = Stream_WriteString( stm, This->sPathRel );

    if( This->sWorkDir )
        r = Stream_WriteString( stm, This->sWorkDir );

    if( This->sArgs )
        r = Stream_WriteString( stm, This->sArgs );

    if( This->sIcoPath )
        r = Stream_WriteString( stm, This->sIcoPath );

1206
    if( This->sProduct )
1207
        r = Stream_WriteAdvertiseInfo( stm, This->sProduct, EXP_SZ_ICON_SIG );
1208 1209

    if( This->sComponent )
1210
        r = Stream_WriteAdvertiseInfo( stm, This->sComponent, EXP_DARWIN_ID_SIG );
1211 1212 1213 1214 1215

    /* the last field is a single zero dword */
    zero = 0;
    r = IStream_Write( stm, &zero, sizeof zero, &count );

1216
    return S_OK;
1217 1218
}

1219 1220
/************************************************************************
 * IPersistStream_GetSizeMax (IPersistStream)
1221
 */
1222 1223 1224
static HRESULT WINAPI IPersistStream_fnGetSizeMax(
	IPersistStream*  iface,
	ULARGE_INTEGER*  pcbSize)
1225
{
1226
	IShellLinkImpl *This = impl_from_IPersistStream(iface);
1227

1228
	TRACE("(%p)\n", This);
1229

1230 1231
	return E_NOTIMPL;
}
1232

1233
static const IPersistStreamVtbl psvt =
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
{
	IPersistStream_fnQueryInterface,
	IPersistStream_fnAddRef,
	IPersistStream_fnRelease,
	IPersistStream_fnGetClassID,
	IPersistStream_fnIsDirty,
	IPersistStream_fnLoad,
	IPersistStream_fnSave,
	IPersistStream_fnGetSizeMax
};
1244 1245 1246 1247

/**************************************************************************
 *	  IShellLink_Constructor
 */
1248 1249
HRESULT WINAPI IShellLink_Constructor( IUnknown *pUnkOuter,
               REFIID riid, LPVOID *ppv )
1250 1251
{
	IShellLinkImpl * sl;
1252
	HRESULT r;
1253 1254 1255 1256 1257

	TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));

	*ppv = NULL;

1258 1259 1260 1261 1262
	if (pUnkOuter)
            return CLASS_E_NOAGGREGATION;
	sl = LocalAlloc(LMEM_ZEROINIT,sizeof(IShellLinkImpl));
	if (!sl)
            return E_OUTOFMEMORY;
1263 1264

	sl->ref = 1;
1265
        sl->IShellLinkA_iface.lpVtbl = &slvt;
1266 1267 1268 1269 1270 1271 1272
        sl->IShellLinkW_iface.lpVtbl = &slvtw;
        sl->IPersistFile_iface.lpVtbl = &pfvt;
        sl->IPersistStream_iface.lpVtbl = &psvt;
        sl->IShellLinkDataList_iface.lpVtbl = &dlvt;
        sl->IShellExtInit_iface.lpVtbl = &eivt;
        sl->IContextMenu_iface.lpVtbl = &cmvt;
        sl->IObjectWithSite_iface.lpVtbl = &owsvt;
1273
	sl->iShowCmd = SW_SHOWNORMAL;
1274
	sl->bDirty = FALSE;
1275
	sl->iIdOpen = -1;
1276
	sl->site = NULL;
1277
	sl->filepath = NULL;
1278

1279
	TRACE("(%p)->()\n",sl);
1280

1281 1282 1283
        r = ShellLink_QueryInterface( sl, riid, ppv );
        ShellLink_Release( sl );
        return r;
1284 1285
}

1286 1287 1288

static BOOL SHELL_ExistsFileW(LPCWSTR path)
{
1289
    if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
1290
        return FALSE;
1291
    return TRUE;
1292 1293 1294
}

/**************************************************************************
1295
 *  ShellLink_UpdatePath
1296 1297
 *	update absolute path in sPath using relative path in sPathRel
 */
1298
static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath)
1299 1300 1301 1302 1303 1304
{
    if (!path || !psPath)
	return E_INVALIDARG;

    if (!*psPath && sPathRel) {
	WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
1305
	LPWSTR final = NULL;
1306 1307 1308

	/* first try if [directory of link file] + [relative path] finds an existing file */

1309 1310 1311 1312
        GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
        if( !final )
            final = buffer;
	lstrcpyW(final, sPathRel);
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347

	*abs_path = '\0';

	if (SHELL_ExistsFileW(buffer)) {
	    if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
		lstrcpyW(abs_path, buffer);
	} else {
	    /* try if [working directory] + [relative path] finds an existing file */
	    if (sWorkDir) {
		lstrcpyW(buffer, sWorkDir);
		lstrcpyW(PathAddBackslashW(buffer), sPathRel);

		if (SHELL_ExistsFileW(buffer))
		    if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
			lstrcpyW(abs_path, buffer);
	    }
	}

	/* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */
	if (!*abs_path)
	    lstrcpyW(abs_path, sPathRel);

	*psPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(abs_path)+1)*sizeof(WCHAR));
	if (!*psPath)
	    return E_OUTOFMEMORY;

	lstrcpyW(*psPath, abs_path);
    }

    return S_OK;
}

/**************************************************************************
 *	  IShellLink_ConstructFromFile
 */
1348 1349
HRESULT WINAPI IShellLink_ConstructFromFile( IUnknown* pUnkOuter, REFIID riid,
               LPCITEMIDLIST pidl, LPVOID* ppv)
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
{
    IShellLinkW* psl;

    HRESULT hr = IShellLink_Constructor(NULL, riid, (LPVOID*)&psl);

    if (SUCCEEDED(hr)) {
	IPersistFile* ppf;

	*ppv = NULL;

	hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);

	if (SUCCEEDED(hr)) {
	    WCHAR path[MAX_PATH];

1365
	    if (SHGetPathFromIDListW(pidl, path)) 
1366
		hr = IPersistFile_Load(ppf, path, 0);
1367 1368
            else
                hr = E_FAIL;
1369

1370
	    if (SUCCEEDED(hr))
1371
                *ppv = psl;
1372

1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
	    IPersistFile_Release(ppf);
	}

	if (!*ppv)
	    IShellLinkW_Release(psl);
    }

    return hr;
}

1383
/**************************************************************************
1384
 *  IShellLinkA_QueryInterface
1385
 */
1386
static HRESULT WINAPI IShellLinkA_fnQueryInterface(IShellLinkA *iface, REFIID riid, void **ppvObj)
1387
{
1388
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1389
    return ShellLink_QueryInterface( This, riid, ppvObj );
1390
}
1391

1392
/******************************************************************************
1393
 * IShellLinkA_AddRef
1394
 */
1395
static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA *iface)
1396
{
1397
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1398
    return ShellLink_AddRef( This );
1399
}
1400

1401
/******************************************************************************
1402
 *	IShellLinkA_Release
1403
 */
1404
static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA *iface)
1405
{
1406
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1407
    return ShellLink_Release( This );
1408 1409
}

1410 1411
static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA *iface, LPSTR pszFile, INT cchMaxPath,
        WIN32_FIND_DATAA *pfd, DWORD fFlags)
1412
{
1413
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1414

1415
    TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
1416
          This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1417

1418 1419 1420 1421
    if (This->sComponent || This->sProduct)
        return S_FALSE;

    if (cchMaxPath)
1422 1423 1424 1425
        pszFile[0] = 0;
    if (This->sPath)
        WideCharToMultiByte( CP_ACP, 0, This->sPath, -1,
                             pszFile, cchMaxPath, NULL, NULL);
1426

1427 1428
    if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);

1429
    return S_OK;
1430
}
1431

1432
static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA *iface, LPITEMIDLIST *ppidl)
1433
{
1434
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1435

1436
    TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1437

1438
    return IShellLinkW_GetIDList(&This->IShellLinkW_iface, ppidl);
1439
}
1440

1441
static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA *iface, LPCITEMIDLIST pidl)
1442
{
1443
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1444

1445
    TRACE("(%p)->(pidl=%p)\n",This, pidl);
1446

1447 1448 1449 1450
    if (This->pPidl)
	ILFree(This->pPidl);
    This->pPidl = ILClone (pidl);
    This->bDirty = TRUE;
1451 1452

    return S_OK;
1453
}
1454

1455 1456
static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA *iface, LPSTR pszName,
        INT cchMaxName)
1457
{
1458
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1459

1460 1461 1462 1463 1464 1465 1466 1467 1468
    TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);

    if( cchMaxName )
        pszName[0] = 0;
    if( This->sDescription )
        WideCharToMultiByte( CP_ACP, 0, This->sDescription, -1,
            pszName, cchMaxName, NULL, NULL);

    return S_OK;
1469
}
1470

1471
static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA *iface, LPCSTR pszName)
1472
{
1473
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1474

1475
    TRACE("(%p)->(pName=%s)\n", This, debugstr_a(pszName));
1476

1477
    HeapFree(GetProcessHeap(), 0, This->sDescription);
1478 1479 1480 1481 1482 1483 1484 1485
    if (pszName)
    {
        This->sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
        if ( !This->sDescription )
            return E_OUTOFMEMORY;
    }
    else
        This->sDescription = NULL;
1486

1487 1488
    This->bDirty = TRUE;

1489
    return S_OK;
1490
}
1491

1492 1493
static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA *iface, LPSTR pszDir,
        INT cchMaxPath)
1494
{
1495
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1496

1497
    TRACE("(%p)->(%p len=%u)\n", This, pszDir, cchMaxPath);
1498

1499 1500 1501 1502 1503
    if( cchMaxPath )
        pszDir[0] = 0;
    if( This->sWorkDir )
        WideCharToMultiByte( CP_ACP, 0, This->sWorkDir, -1,
                             pszDir, cchMaxPath, NULL, NULL);
1504

1505
    return S_OK;
1506
}
1507

1508
static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA *iface, LPCSTR pszDir)
1509
{
1510
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1511

1512
    TRACE("(%p)->(dir=%s)\n",This, pszDir);
1513

1514
    HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1515 1516 1517
    This->sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
    if ( !This->sWorkDir )
        return E_OUTOFMEMORY;
1518

1519 1520
    This->bDirty = TRUE;

1521
    return S_OK;
1522
}
1523

1524
static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA *iface, LPSTR pszArgs, INT cchMaxPath)
1525
{
1526
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1527

1528
    TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1529

1530 1531 1532 1533 1534
    if( cchMaxPath )
        pszArgs[0] = 0;
    if( This->sArgs )
        WideCharToMultiByte( CP_ACP, 0, This->sArgs, -1,
                             pszArgs, cchMaxPath, NULL, NULL);
1535

1536
    return S_OK;
1537
}
1538

1539
static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA *iface, LPCSTR pszArgs)
1540
{
1541
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1542

1543
    TRACE("(%p)->(args=%s)\n",This, debugstr_a(pszArgs));
1544

1545
    HeapFree(GetProcessHeap(), 0, This->sArgs);
1546 1547 1548 1549 1550 1551 1552
    if (pszArgs)
    {
        This->sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
        if( !This->sArgs )
            return E_OUTOFMEMORY;
    }
    else This->sArgs = NULL;
1553

1554 1555
    This->bDirty = TRUE;

1556
    return S_OK;
1557
}
1558

1559
static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA *iface, WORD *pwHotkey)
1560
{
1561
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1562

1563
    TRACE("(%p)->(%p)(0x%08x)\n",This, pwHotkey, This->wHotKey);
1564

1565
    *pwHotkey = This->wHotKey;
1566

1567
    return S_OK;
1568
}
1569

1570
static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA *iface, WORD wHotkey)
1571
{
1572
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1573

1574
    TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1575

1576 1577
    This->wHotKey = wHotkey;
    This->bDirty = TRUE;
1578

1579
    return S_OK;
1580
}
1581

1582
static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA *iface, INT *piShowCmd)
1583
{
1584
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1585

1586 1587 1588
    TRACE("(%p)->(%p)\n",This, piShowCmd);
    *piShowCmd = This->iShowCmd;
    return S_OK;
1589
}
1590

1591
static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA *iface, INT iShowCmd)
1592
{
1593
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1594

1595 1596 1597
    TRACE("(%p) %d\n",This, iShowCmd);

    This->iShowCmd = iShowCmd;
1598
    This->bDirty = TRUE;
1599

1600
    return S_OK;
1601
}
1602

1603 1604
static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA *iface, LPSTR pszIconPath,
        INT cchIconPath, INT *piIcon)
1605
{
1606
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1607

1608
    TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1609

1610
    *piIcon = This->iIcoNdx;
1611

1612
    if (This->sIcoPath)
1613
        WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
1614 1615
    else
        pszIconPath[0] = 0;
1616

1617
    return S_OK;
1618
}
1619

1620 1621
static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA *iface, LPCSTR pszIconPath,
        INT iIcon)
1622
{
1623
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1624

1625
    TRACE("(%p)->(path=%s iicon=%u)\n",This, pszIconPath, iIcon);
1626

1627
    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1628 1629 1630
    This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
    if ( !This->sIcoPath )
        return E_OUTOFMEMORY;
1631

1632
    This->iIcoNdx = iIcon;
1633
    This->bDirty = TRUE;
1634

1635
    return S_OK;
1636
}
1637

1638 1639
static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA *iface, LPCSTR pszPathRel,
        DWORD dwReserved)
1640
{
1641
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1642

1643
    TRACE("(%p)->(path=%s %x)\n",This, pszPathRel, dwReserved);
1644

1645
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
1646
    This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1647
    This->bDirty = TRUE;
1648

1649
    return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1650
}
1651

1652
static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA *iface, HWND hwnd, DWORD fFlags)
1653
{
1654
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1655

1656
    TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1657

1658
    return IShellLinkW_Resolve(&This->IShellLinkW_iface, hwnd, fFlags);
1659
}
1660

1661
static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA *iface, LPCSTR pszFile)
1662
{
1663
    IShellLinkImpl *This = impl_from_IShellLinkA(iface);
1664 1665
    HRESULT r;
    LPWSTR str;
1666

1667
    TRACE("(%p)->(path=%s)\n",This, debugstr_a(pszFile));
1668

1669 1670
    if (!pszFile) return E_INVALIDARG;

1671 1672
    str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
    if( !str ) 
1673
        return E_OUTOFMEMORY;
1674

1675
    r = IShellLinkW_SetPath(&This->IShellLinkW_iface, str);
1676
    HeapFree( GetProcessHeap(), 0, str );
1677

1678
    return r;
1679 1680
}

1681 1682 1683 1684
/**************************************************************************
* IShellLink Implementation
*/

1685
static const IShellLinkAVtbl slvt =
1686
{
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
    IShellLinkA_fnQueryInterface,
    IShellLinkA_fnAddRef,
    IShellLinkA_fnRelease,
    IShellLinkA_fnGetPath,
    IShellLinkA_fnGetIDList,
    IShellLinkA_fnSetIDList,
    IShellLinkA_fnGetDescription,
    IShellLinkA_fnSetDescription,
    IShellLinkA_fnGetWorkingDirectory,
    IShellLinkA_fnSetWorkingDirectory,
    IShellLinkA_fnGetArguments,
    IShellLinkA_fnSetArguments,
    IShellLinkA_fnGetHotkey,
    IShellLinkA_fnSetHotkey,
    IShellLinkA_fnGetShowCmd,
    IShellLinkA_fnSetShowCmd,
    IShellLinkA_fnGetIconLocation,
    IShellLinkA_fnSetIconLocation,
    IShellLinkA_fnSetRelativePath,
    IShellLinkA_fnResolve,
    IShellLinkA_fnSetPath
1708 1709
};

1710 1711

/**************************************************************************
1712
 *  IShellLinkW_fnQueryInterface
1713
 */
1714 1715 1716
static HRESULT WINAPI IShellLinkW_fnQueryInterface(
  IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
{
1717
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1718
    return ShellLink_QueryInterface( This, riid, ppvObj );
1719
}
1720

1721
/******************************************************************************
1722
 * IShellLinkW_fnAddRef
1723
 */
1724 1725
static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
{
1726
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1727
    return ShellLink_AddRef( This );
1728
}
1729

1730
/******************************************************************************
1731
 * IShellLinkW_fnRelease
1732
 */
1733 1734
static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
{
1735
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1736
    return ShellLink_Release( This );
1737 1738
}

1739
static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1740
{
1741
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1742

1743
    TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%u)(%s)\n",
1744
          This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1745

1746 1747 1748 1749
    if (This->sComponent || This->sProduct)
        return S_FALSE;

    if (cchMaxPath)
1750
        pszFile[0] = 0;
1751
    if (This->sPath)
1752 1753
        lstrcpynW( pszFile, This->sPath, cchMaxPath );

1754 1755
    if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);

1756
    return S_OK;
1757
}
1758 1759 1760

static HRESULT WINAPI IShellLinkW_fnGetIDList(IShellLinkW * iface, LPITEMIDLIST * ppidl)
{
1761
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1762

1763 1764
    TRACE("(%p)->(ppidl=%p)\n",This, ppidl);

1765
    if (!This->pPidl)
1766 1767
    {
	*ppidl = NULL;
1768
        return S_FALSE;
1769
    }
1770
    *ppidl = ILClone(This->pPidl);
1771
    return S_OK;
1772
}
1773 1774 1775

static HRESULT WINAPI IShellLinkW_fnSetIDList(IShellLinkW * iface, LPCITEMIDLIST pidl)
{
1776
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1777

1778 1779 1780 1781 1782 1783 1784 1785
    TRACE("(%p)->(pidl=%p)\n",This, pidl);

    if( This->pPidl )
        ILFree( This->pPidl );
    This->pPidl = ILClone( pidl );
    if( !This->pPidl )
        return E_FAIL;

1786 1787
    This->bDirty = TRUE;

1788
    return S_OK;
1789
}
1790

1791
static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1792
{
1793
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1794

1795 1796
    TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);

1797
    pszName[0] = 0;
1798 1799 1800 1801
    if( This->sDescription )
        lstrcpynW( pszName, This->sDescription, cchMaxName );

    return S_OK;
1802
}
1803 1804 1805

static HRESULT WINAPI IShellLinkW_fnSetDescription(IShellLinkW * iface, LPCWSTR pszName)
{
1806
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1807

1808
    TRACE("(%p)->(desc=%s)\n",This, debugstr_w(pszName));
1809

1810
    HeapFree(GetProcessHeap(), 0, This->sDescription);
1811 1812 1813 1814 1815 1816
    if (pszName)
    {
        This->sDescription = HeapAlloc( GetProcessHeap(), 0,
                                        (lstrlenW( pszName )+1)*sizeof(WCHAR) );
        if ( !This->sDescription )
            return E_OUTOFMEMORY;
1817

1818 1819 1820 1821
        lstrcpyW( This->sDescription, pszName );
    }
    else
        This->sDescription = NULL;
1822
    This->bDirty = TRUE;
1823

1824
    return S_OK;
1825
}
1826

1827
static HRESULT WINAPI IShellLinkW_fnGetWorkingDirectory(IShellLinkW * iface, LPWSTR pszDir,INT cchMaxPath)
1828
{
1829
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1830

1831
    TRACE("(%p)->(%p len %u)\n", This, pszDir, cchMaxPath);
1832

1833 1834 1835 1836
    if( cchMaxPath )
        pszDir[0] = 0;
    if( This->sWorkDir )
        lstrcpynW( pszDir, This->sWorkDir, cchMaxPath );
1837

1838
    return S_OK;
1839
}
1840 1841 1842

static HRESULT WINAPI IShellLinkW_fnSetWorkingDirectory(IShellLinkW * iface, LPCWSTR pszDir)
{
1843
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1844

1845
    TRACE("(%p)->(dir=%s)\n",This, debugstr_w(pszDir));
1846

1847
    HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1848 1849 1850 1851 1852
    This->sWorkDir = HeapAlloc( GetProcessHeap(), 0,
                                (lstrlenW( pszDir )+1)*sizeof (WCHAR) );
    if ( !This->sWorkDir )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sWorkDir, pszDir );
1853
    This->bDirty = TRUE;
1854

1855
    return S_OK;
1856
}
1857

1858
static HRESULT WINAPI IShellLinkW_fnGetArguments(IShellLinkW * iface, LPWSTR pszArgs,INT cchMaxPath)
1859
{
1860
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1861

1862
    TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1863

1864 1865 1866 1867
    if( cchMaxPath )
        pszArgs[0] = 0;
    if( This->sArgs )
        lstrcpynW( pszArgs, This->sArgs, cchMaxPath );
1868

1869
    return S_OK;
1870
}
1871 1872 1873

static HRESULT WINAPI IShellLinkW_fnSetArguments(IShellLinkW * iface, LPCWSTR pszArgs)
{
1874
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1875

1876
    TRACE("(%p)->(args=%s)\n",This, debugstr_w(pszArgs));
1877

1878
    HeapFree(GetProcessHeap(), 0, This->sArgs);
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
    if (pszArgs)
    {
        This->sArgs = HeapAlloc( GetProcessHeap(), 0,
                                 (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
        if ( !This->sArgs )
            return E_OUTOFMEMORY;
        lstrcpyW( This->sArgs, pszArgs );
    }
    else This->sArgs = NULL;

1889
    This->bDirty = TRUE;
1890

1891
    return S_OK;
1892
}
1893 1894 1895

static HRESULT WINAPI IShellLinkW_fnGetHotkey(IShellLinkW * iface, WORD *pwHotkey)
{
1896
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1897

1898 1899 1900 1901 1902
    TRACE("(%p)->(%p)\n",This, pwHotkey);

    *pwHotkey=This->wHotKey;

    return S_OK;
1903
}
1904 1905 1906

static HRESULT WINAPI IShellLinkW_fnSetHotkey(IShellLinkW * iface, WORD wHotkey)
{
1907
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1908

1909 1910 1911
    TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);

    This->wHotKey = wHotkey;
1912
    This->bDirty = TRUE;
1913 1914

    return S_OK;
1915
}
1916

1917
static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1918
{
1919
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1920

1921 1922 1923 1924 1925
    TRACE("(%p)->(%p)\n",This, piShowCmd);

    *piShowCmd = This->iShowCmd;

    return S_OK;
1926
}
1927

1928
static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1929
{
1930
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1931

1932
    This->iShowCmd = iShowCmd;
1933
    This->bDirty = TRUE;
1934 1935

    return S_OK;
1936
}
1937

1938
static HRESULT WINAPI IShellLinkW_fnGetIconLocation(IShellLinkW * iface, LPWSTR pszIconPath,INT cchIconPath,INT *piIcon)
1939
{
1940
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1941

1942
    TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1943

1944
    *piIcon = This->iIcoNdx;
1945

1946
    if (This->sIcoPath)
1947
	lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
1948 1949
    else
	pszIconPath[0] = 0;
1950

1951
    return S_OK;
1952
}
1953

1954
static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
1955
{
1956
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1957

1958
    TRACE("(%p)->(path=%s iicon=%u)\n",This, debugstr_w(pszIconPath), iIcon);
1959

1960
    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1961 1962 1963 1964 1965
    This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
                                (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
    if ( !This->sIcoPath )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sIcoPath, pszIconPath );
1966

1967
    This->iIcoNdx = iIcon;
1968
    This->bDirty = TRUE;
1969 1970

    return S_OK;
1971
}
1972 1973 1974

static HRESULT WINAPI IShellLinkW_fnSetRelativePath(IShellLinkW * iface, LPCWSTR pszPathRel, DWORD dwReserved)
{
1975
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1976

1977
    TRACE("(%p)->(path=%s %x)\n",This, debugstr_w(pszPathRel), dwReserved);
1978

1979
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
1980 1981 1982 1983 1984
    This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
                                (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
    if ( !This->sPathRel )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sPathRel, pszPathRel );
1985
    This->bDirty = TRUE;
1986

1987
    return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1988
}
1989

1990
static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
1991
{
1992
    HRESULT hr = S_OK;
1993
    BOOL bSuccess;
1994

1995
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1996

1997
    TRACE("(%p)->(hwnd=%p flags=%x)\n",This, hwnd, fFlags);
1998

1999 2000 2001 2002 2003
    /*FIXME: use IResolveShellLink interface */

    if (!This->sPath && This->pPidl) {
	WCHAR buffer[MAX_PATH];

2004
	bSuccess = SHGetPathFromIDListW(This->pPidl, buffer);
2005

2006
	if (bSuccess && *buffer) {
2007
	    This->sPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(buffer)+1)*sizeof(WCHAR));
2008 2009 2010 2011 2012 2013 2014
	    if (!This->sPath)
		return E_OUTOFMEMORY;

	    lstrcpyW(This->sPath, buffer);

	    This->bDirty = TRUE;
	} else
2015
	    hr = S_OK;    /* don't report an error occurred while just caching information */
2016 2017 2018
    }

    if (!This->sIcoPath && This->sPath) {
2019
	This->sIcoPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(This->sPath)+1)*sizeof(WCHAR));
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
	if (!This->sIcoPath)
	    return E_OUTOFMEMORY;

	lstrcpyW(This->sIcoPath, This->sPath);
	This->iIcoNdx = 0;

	This->bDirty = TRUE;
    }

    return hr;
2030
}
2031

2032 2033 2034 2035 2036 2037
static LPWSTR ShellLink_GetAdvertisedArg(LPCWSTR str)
{
    LPWSTR ret;
    LPCWSTR p;
    DWORD len;

2038 2039 2040
    if( !str )
        return NULL;

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
    p = strchrW( str, ':' );
    if( !p )
        return NULL;
    len = p - str;
    ret = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
    if( !ret )
        return ret;
    memcpy( ret, str, sizeof(WCHAR)*len );
    ret[len] = 0;
    return ret;
}

static HRESULT ShellLink_SetAdvertiseInfo(IShellLinkImpl *This, LPCWSTR str)
{
    LPCWSTR szComponent = NULL, szProduct = NULL, p;
    WCHAR szGuid[39];
    HRESULT r;
    GUID guid;
    int len;

    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 = strchrW( str, ':' );
        if( !p )
            return E_FAIL;
        len = p - str;
        if( len != 38 )
            return E_FAIL;

        /* get the guid, and check it's validly formatted */
        memcpy( szGuid, str, sizeof(WCHAR)*len );
        szGuid[len] = 0;
        r = CLSIDFromString( szGuid, &guid );
        if( r != S_OK )
            return r;
        str = p + 1;

        /* match it up to a guid that we care about */
        if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutComponent ) && !szComponent )
            szComponent = str;
        else if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutProduct ) && !szProduct )
            szProduct = str;
        else
            return E_FAIL;

        /* skip to the next field */
        str = strchrW( str, ':' );
        if( !str )
            return E_FAIL;
    }

2102 2103
    /* we have to have a component for an advertised shortcut */
    if( !szComponent )
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
        return E_FAIL;

    This->sComponent = ShellLink_GetAdvertisedArg( szComponent );
    This->sProduct = ShellLink_GetAdvertisedArg( szProduct );

    TRACE("Component = %s\n", debugstr_w(This->sComponent));
    TRACE("Product = %s\n", debugstr_w(This->sProduct));

    return S_OK;
}

2115
static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, volume_info *volume)
2116 2117
{
    const int label_sz = sizeof volume->label/sizeof volume->label[0];
2118
    WCHAR drive[] = { path[0], ':', '\\', 0 };
2119 2120 2121 2122 2123
    BOOL r;

    volume->type = GetDriveTypeW(drive);
    r = GetVolumeInformationW(drive, volume->label, label_sz,
                              &volume->serial, NULL, NULL, NULL, 0);
2124
    TRACE("r = %d type %d serial %08x name %s\n", r,
2125 2126 2127 2128
          volume->type, volume->serial, debugstr_w(volume->label));
    return r;
}

2129 2130
static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
{
2131
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2132
    WCHAR buffer[MAX_PATH];
2133
    LPWSTR fname, unquoted = NULL;
2134
    HRESULT hr = S_OK;
2135
    UINT len;
2136

2137
    TRACE("(%p)->(path=%s)\n",This, debugstr_w(pszFile));
2138

2139 2140
    if (!pszFile) return E_INVALIDARG;

2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151
    /* quotes at the ends of the string are stripped */
    len = lstrlenW(pszFile);
    if (pszFile[0] == '"' && pszFile[len-1] == '"')
    {
        unquoted = strdupW(pszFile);
        PathUnquoteSpacesW(unquoted);
        pszFile = unquoted;
    }

    /* any other quote marks are invalid */
    if (strchrW(pszFile, '"'))
Huw Davies's avatar
Huw Davies committed
2152 2153
    {
        HeapFree(GetProcessHeap(), 0, unquoted);
2154
        return S_FALSE;
Huw Davies's avatar
Huw Davies committed
2155
    }
2156

2157
    HeapFree(GetProcessHeap(), 0, This->sPath);
2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
    This->sPath = NULL;

    HeapFree(GetProcessHeap(), 0, This->sComponent);
    This->sComponent = NULL;

    if (This->pPidl)
        ILFree(This->pPidl);
    This->pPidl = NULL;

    if (S_OK != ShellLink_SetAdvertiseInfo( This, pszFile ))
    {
        if (*pszFile == '\0')
            *buffer = '\0';
        else if (!GetFullPathNameW(pszFile, MAX_PATH, buffer, &fname))
	    return E_FAIL;
2173 2174 2175
        else if(!PathFileExistsW(buffer) &&
		!SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
	  hr = S_FALSE;
2176 2177 2178 2179 2180

        This->pPidl = SHSimpleIDListFromPathW(pszFile);
        ShellLink_GetVolumeInfo(buffer, &This->volume);

        This->sPath = HeapAlloc( GetProcessHeap(), 0,
2181
                             (lstrlenW( buffer )+1) * sizeof (WCHAR) );
2182
        if (!This->sPath)
Huw Davies's avatar
Huw Davies committed
2183 2184
        {
            HeapFree(GetProcessHeap(), 0, unquoted);
2185
            return E_OUTOFMEMORY;
Huw Davies's avatar
Huw Davies committed
2186
        }
2187

2188 2189
        lstrcpyW(This->sPath, buffer);
    }
2190
    This->bDirty = TRUE;
2191
    HeapFree(GetProcessHeap(), 0, unquoted);
2192

2193
    return hr;
2194 2195
}

2196 2197 2198 2199
/**************************************************************************
* IShellLinkW Implementation
*/

2200
static const IShellLinkWVtbl slvtw =
2201
{
2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
    IShellLinkW_fnQueryInterface,
    IShellLinkW_fnAddRef,
    IShellLinkW_fnRelease,
    IShellLinkW_fnGetPath,
    IShellLinkW_fnGetIDList,
    IShellLinkW_fnSetIDList,
    IShellLinkW_fnGetDescription,
    IShellLinkW_fnSetDescription,
    IShellLinkW_fnGetWorkingDirectory,
    IShellLinkW_fnSetWorkingDirectory,
    IShellLinkW_fnGetArguments,
    IShellLinkW_fnSetArguments,
    IShellLinkW_fnGetHotkey,
    IShellLinkW_fnSetHotkey,
    IShellLinkW_fnGetShowCmd,
    IShellLinkW_fnSetShowCmd,
    IShellLinkW_fnGetIconLocation,
    IShellLinkW_fnSetIconLocation,
    IShellLinkW_fnSetRelativePath,
    IShellLinkW_fnResolve,
    IShellLinkW_fnSetPath
2223
};
2224 2225 2226 2227

static HRESULT WINAPI
ShellLink_DataList_QueryInterface( IShellLinkDataList* iface, REFIID riid, void** ppvObject)
{
2228
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2229
    return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2230 2231 2232 2233 2234
}

static ULONG WINAPI
ShellLink_DataList_AddRef( IShellLinkDataList* iface )
{
2235
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2236
    return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2237 2238 2239 2240 2241
}

static ULONG WINAPI
ShellLink_DataList_Release( IShellLinkDataList* iface )
{
2242
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2243
    return ShellLink_Release( This );
2244 2245 2246 2247 2248
}

static HRESULT WINAPI
ShellLink_AddDataBlock( IShellLinkDataList* iface, void* pDataBlock )
{
2249
    FIXME("(%p)->(%p): stub\n", iface, pDataBlock);
2250 2251 2252 2253 2254 2255
    return E_NOTIMPL;
}

static HRESULT WINAPI
ShellLink_CopyDataBlock( IShellLinkDataList* iface, DWORD dwSig, void** ppDataBlock )
{
2256 2257 2258 2259
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
    LPVOID block = NULL;
    HRESULT r = E_FAIL;

2260
    TRACE("%p %08x %p\n", iface, dwSig, ppDataBlock );
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274

    switch (dwSig)
    {
    case EXP_DARWIN_ID_SIG:
        if (!This->sComponent)
            break;
        block = shelllink_build_darwinid( This->sComponent, dwSig );
        r = S_OK;
        break;
    case EXP_SZ_LINK_SIG:
    case NT_CONSOLE_PROPS_SIG:
    case NT_FE_CONSOLE_PROPS_SIG:
    case EXP_SPECIAL_FOLDER_SIG:
    case EXP_SZ_ICON_SIG:
2275
        FIXME("valid but unhandled datablock %08x\n", dwSig);
2276 2277
        break;
    default:
2278
        ERR("unknown datablock %08x\n", dwSig);
2279 2280 2281
    }
    *ppDataBlock = block;
    return r;
2282 2283 2284 2285 2286
}

static HRESULT WINAPI
ShellLink_RemoveDataBlock( IShellLinkDataList* iface, DWORD dwSig )
{
2287
    FIXME("(%p)->(%u): stub\n", iface, dwSig);
2288 2289 2290 2291 2292 2293
    return E_NOTIMPL;
}

static HRESULT WINAPI
ShellLink_GetFlags( IShellLinkDataList* iface, DWORD* pdwFlags )
{
2294 2295 2296
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
    DWORD flags = 0;

2297
    FIXME("(%p)->(%p): partially implemented\n", This, pdwFlags);
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313

    /* FIXME: add more */
    if (This->sArgs)
        flags |= SLDF_HAS_ARGS;
    if (This->sComponent)
        flags |= SLDF_HAS_DARWINID;
    if (This->sIcoPath)
        flags |= SLDF_HAS_ICONLOCATION;
    if (This->sProduct)
        flags |= SLDF_HAS_LOGO3ID;
    if (This->pPidl)
        flags |= SLDF_HAS_ID_LIST;

    *pdwFlags = flags;

    return S_OK;
2314 2315 2316 2317 2318
}

static HRESULT WINAPI
ShellLink_SetFlags( IShellLinkDataList* iface, DWORD dwFlags )
{
2319
    FIXME("(%p)->(%u): stub\n", iface, dwFlags);
2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333
    return E_NOTIMPL;
}

static const IShellLinkDataListVtbl dlvt =
{
    ShellLink_DataList_QueryInterface,
    ShellLink_DataList_AddRef,
    ShellLink_DataList_Release,
    ShellLink_AddDataBlock,
    ShellLink_CopyDataBlock,
    ShellLink_RemoveDataBlock,
    ShellLink_GetFlags,
    ShellLink_SetFlags
};
2334 2335 2336 2337

static HRESULT WINAPI
ShellLink_ExtInit_QueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
{
2338
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2339
    return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2340 2341 2342 2343 2344
}

static ULONG WINAPI
ShellLink_ExtInit_AddRef( IShellExtInit* iface )
{
2345
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2346
    return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2347 2348 2349 2350 2351
}

static ULONG WINAPI
ShellLink_ExtInit_Release( IShellExtInit* iface )
{
2352
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2353
    return ShellLink_Release( This );
2354 2355
}

2356 2357 2358 2359 2360
/**************************************************************************
 * ShellLink implementation of IShellExtInit::Initialize()
 *
 * Loads the shelllink from the dataobject the shell is pointing to.
 */
2361 2362 2363 2364
static HRESULT WINAPI
ShellLink_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
                              IDataObject *pdtobj, HKEY hkeyProgID )
{
2365
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
    FORMATETC format;
    STGMEDIUM stgm;
    UINT count;
    HRESULT r = E_FAIL;

    TRACE("%p %p %p %p\n", This, pidlFolder, pdtobj, hkeyProgID );

    if( !pdtobj )
        return r;

    format.cfFormat = CF_HDROP;
    format.ptd = NULL;
    format.dwAspect = DVASPECT_CONTENT;
    format.lindex = -1;
    format.tymed = TYMED_HGLOBAL;

    if( FAILED( IDataObject_GetData( pdtobj, &format, &stgm ) ) )
        return r;

    count = DragQueryFileW( stgm.u.hGlobal, -1, NULL, 0 );
    if( count == 1 )
    {
        LPWSTR path;

        count = DragQueryFileW( stgm.u.hGlobal, 0, NULL, 0 );
        count++;
        path = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
        if( path )
        {
2395
            IPersistFile *pf = &This->IPersistFile_iface;
2396 2397 2398 2399 2400 2401 2402 2403 2404

            count = DragQueryFileW( stgm.u.hGlobal, 0, path, count );
            r = IPersistFile_Load( pf, path, 0 );
            HeapFree( GetProcessHeap(), 0, path );
        }
    }
    ReleaseStgMedium( &stgm );

    return r;
2405 2406 2407 2408 2409 2410 2411 2412 2413
}

static const IShellExtInitVtbl eivt =
{
    ShellLink_ExtInit_QueryInterface,
    ShellLink_ExtInit_AddRef,
    ShellLink_ExtInit_Release,
    ShellLink_ExtInit_Initialize
};
2414 2415 2416 2417

static HRESULT WINAPI
ShellLink_ContextMenu_QueryInterface( IContextMenu* iface, REFIID riid, void** ppvObject )
{
2418
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2419
    return IShellLinkA_QueryInterface(&This->IShellLinkA_iface, riid, ppvObject);
2420 2421 2422 2423 2424
}

static ULONG WINAPI
ShellLink_ContextMenu_AddRef( IContextMenu* iface )
{
2425
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2426
    return IShellLinkA_AddRef(&This->IShellLinkA_iface);
2427 2428 2429 2430 2431
}

static ULONG WINAPI
ShellLink_ContextMenu_Release( IContextMenu* iface )
{
2432
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2433
    return ShellLink_Release( This );
2434 2435 2436 2437 2438 2439
}

static HRESULT WINAPI
ShellLink_QueryContextMenu( IContextMenu* iface, HMENU hmenu, UINT indexMenu,
                            UINT idCmdFirst, UINT idCmdLast, UINT uFlags )
{
2440
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2441
    static WCHAR szOpen[] = { 'O','p','e','n',0 };
2442 2443
    MENUITEMINFOW mii;
    int id = 1;
2444

2445
    TRACE("%p %p %u %u %u %u\n", This,
2446 2447
          hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );

2448 2449 2450 2451 2452 2453
    if ( !hmenu )
        return E_INVALIDARG;

    memset( &mii, 0, sizeof mii );
    mii.cbSize = sizeof mii;
    mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
2454
    mii.dwTypeData = szOpen;
2455 2456 2457 2458 2459 2460 2461 2462 2463
    mii.cch = strlenW( 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;
    This->iIdOpen = 0;

    return MAKE_HRESULT( SEVERITY_SUCCESS, 0, id );
2464 2465
}

2466 2467
static LPWSTR
shelllink_get_msi_component_path( LPWSTR component )
2468
{
2469
    LPWSTR path;
2470
    DWORD r, sz = 0;
2471

2472 2473
    r = CommandLineFromMsiDescriptor( component, NULL, &sz );
    if (r != ERROR_SUCCESS)
2474
         return NULL;
2475

2476 2477 2478 2479
    sz++;
    path = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
    r = CommandLineFromMsiDescriptor( component, path, &sz );
    if (r != ERROR_SUCCESS)
2480
    {
2481 2482
        HeapFree( GetProcessHeap(), 0, path );
        path = NULL;
2483 2484 2485 2486 2487 2488 2489
    }

    TRACE("returning %s\n", debugstr_w( path ) );

    return path;
}

2490 2491 2492
static HRESULT WINAPI
ShellLink_InvokeCommand( IContextMenu* iface, LPCMINVOKECOMMANDINFO lpici )
{
2493
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
Mike McCormack's avatar
Mike McCormack committed
2494
    static const WCHAR szOpen[] = { 'O','p','e','n',0 };
2495 2496 2497
    SHELLEXECUTEINFOW sei;
    HWND hwnd = NULL; /* FIXME: get using interface set from IObjectWithSite */
    LPWSTR args = NULL;
2498
    LPWSTR path = NULL;
2499
    HRESULT r;
2500

2501
    TRACE("%p %p\n", This, lpici );
2502

2503 2504 2505 2506 2507
    if ( lpici->cbSize < sizeof (CMINVOKECOMMANDINFO) )
        return E_INVALIDARG;

    if ( lpici->lpVerb != MAKEINTRESOURCEA(This->iIdOpen) )
    {
2508
        ERR("Unknown id %p != %d\n", lpici->lpVerb, This->iIdOpen );
2509 2510 2511
        return E_INVALIDARG;
    }

2512
    r = IShellLinkW_Resolve(&This->IShellLinkW_iface, hwnd, 0);
2513 2514 2515
    if ( FAILED( r ) )
        return r;

2516
    if ( This->sComponent )
2517
    {
2518 2519 2520
        path = shelllink_get_msi_component_path( This->sComponent );
        if (!path)
            return E_FAIL;
2521
    }
2522 2523
    else
        path = strdupW( This->sPath );
2524 2525 2526 2527 2528

    if ( lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
         ( lpici->fMask & CMIC_MASK_UNICODE ) )
    {
        LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX) lpici;
Mike McCormack's avatar
Mike McCormack committed
2529
        DWORD len = 2;
2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540

        if ( This->sArgs )
            len += lstrlenW( This->sArgs );
        if ( iciex->lpParametersW )
            len += lstrlenW( iciex->lpParametersW );

        args = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
        args[0] = 0;
        if ( This->sArgs )
            lstrcatW( args, This->sArgs );
        if ( iciex->lpParametersW )
Mike McCormack's avatar
Mike McCormack committed
2541 2542 2543
        {
            static const WCHAR space[] = { ' ', 0 };
            lstrcatW( args, space );
2544
            lstrcatW( args, iciex->lpParametersW );
Mike McCormack's avatar
Mike McCormack committed
2545
        }
2546 2547 2548 2549
    }

    memset( &sei, 0, sizeof sei );
    sei.cbSize = sizeof sei;
2550
    sei.fMask = SEE_MASK_UNICODE | (lpici->fMask & (SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
2551
    sei.lpFile = path;
2552 2553 2554 2555
    sei.nShow = This->iShowCmd;
    sei.lpIDList = This->pPidl;
    sei.lpDirectory = This->sWorkDir;
    sei.lpParameters = args;
Mike McCormack's avatar
Mike McCormack committed
2556
    sei.lpVerb = szOpen;
2557 2558 2559 2560 2561 2562 2563

    if( ShellExecuteExW( &sei ) )
        r = S_OK;
    else
        r = E_FAIL;

    HeapFree( GetProcessHeap(), 0, args );
2564
    HeapFree( GetProcessHeap(), 0, path );
2565 2566

    return r;
2567 2568 2569
}

static HRESULT WINAPI
Kevin Koltzau's avatar
Kevin Koltzau committed
2570
ShellLink_GetCommandString( IContextMenu* iface, UINT_PTR idCmd, UINT uType,
2571 2572
                            UINT* pwReserved, LPSTR pszName, UINT cchMax )
{
2573
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2574

2575
    FIXME("(%p)->(%lu %u %p %p %u): stub\n", This,
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
          idCmd, uType, pwReserved, pszName, cchMax );

    return E_NOTIMPL;
}

static const IContextMenuVtbl cmvt =
{
    ShellLink_ContextMenu_QueryInterface,
    ShellLink_ContextMenu_AddRef,
    ShellLink_ContextMenu_Release,
    ShellLink_QueryContextMenu,
    ShellLink_InvokeCommand,
    ShellLink_GetCommandString
};
2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632

static HRESULT WINAPI
ShellLink_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
{
    IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
    return ShellLink_QueryInterface( This, riid, ppvObject );
}

static ULONG WINAPI
ShellLink_ObjectWithSite_AddRef( IObjectWithSite* iface )
{
    IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
    return ShellLink_AddRef( This );
}

static ULONG WINAPI
ShellLink_ObjectWithSite_Release( IObjectWithSite* iface )
{
    IShellLinkImpl *This = impl_from_IObjectWithSite(iface);
    return ShellLink_Release( This );
}

static HRESULT WINAPI
ShellLink_GetSite( IObjectWithSite *iface, REFIID iid, void ** ppvSite )
{
    IShellLinkImpl *This = impl_from_IObjectWithSite(iface);

    TRACE("%p %s %p\n", This, debugstr_guid( iid ), ppvSite );

    if ( !This->site )
        return E_FAIL;
    return IUnknown_QueryInterface( This->site, iid, ppvSite );
}

static HRESULT WINAPI
ShellLink_SetSite( IObjectWithSite *iface, IUnknown *punk )
{
    IShellLinkImpl *This = impl_from_IObjectWithSite(iface);

    TRACE("%p %p\n", iface, punk);

    if ( punk )
        IUnknown_AddRef( punk );
2633 2634 2635 2636

    if( This->site )
        IUnknown_Release( This->site );

2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
    This->site = punk;

    return S_OK;
}

static const IObjectWithSiteVtbl owsvt =
{
    ShellLink_ObjectWithSite_QueryInterface,
    ShellLink_ObjectWithSite_AddRef,
    ShellLink_ObjectWithSite_Release,
    ShellLink_SetSite,
    ShellLink_GetSite,
};