shelllink.c 72.1 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 132 133
	const IShellLinkAVtbl *lpVtbl;
	const IShellLinkWVtbl *lpvtblw;
	const IPersistFileVtbl *lpvtblPersistFile;
134
	const IPersistStreamVtbl *lpvtblPersistStream;
135
	const IShellLinkDataListVtbl *lpvtblShellLinkDataList;
136
	const IShellExtInitVtbl *lpvtblShellExtInit;
137
	const IContextMenuVtbl *lpvtblContextMenu;
138
	const IObjectWithSiteVtbl *lpvtblObjectWithSite;
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
} IShellLinkImpl;
165

166 167 168 169
static inline IShellLinkImpl *impl_from_IShellLinkW( IShellLinkW *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblw));
}
170

171 172 173 174
static inline IShellLinkImpl *impl_from_IPersistFile( IPersistFile *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblPersistFile));
}
175

176 177 178 179 180 181 182 183 184
static inline IShellLinkImpl *impl_from_IPersistStream( IPersistStream *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblPersistStream));
}

static inline IShellLinkImpl *impl_from_IShellLinkDataList( IShellLinkDataList *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblShellLinkDataList));
}
185

186 187 188 189
static inline IShellLinkImpl *impl_from_IShellExtInit( IShellExtInit *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblShellExtInit));
}
190

191 192 193 194 195
static inline IShellLinkImpl *impl_from_IContextMenu( IContextMenu *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblContextMenu));
}

196 197 198 199 200
static inline IShellLinkImpl *impl_from_IObjectWithSite( IObjectWithSite *iface )
{
    return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblObjectWithSite));
}

201
static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
202 203

/* strdup on the process heap */
204
static inline LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
205
{
206 207 208 209 210
    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 );
211 212 213
    return p;
}

214
static inline LPWSTR strdupW( LPCWSTR src )
215 216 217 218 219 220 221 222 223
{
    LPWSTR dest;
    if (!src) return NULL;
    dest = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(src)+1)*sizeof(WCHAR) );
    if (dest)
        lstrcpyW(dest, src);
    return dest;
}

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
/**************************************************************************
 *  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))
    {
        *ppvObj = &(This->lpvtblw);
    }
    else if(IsEqualIID(riid, &IID_IPersistFile))
    {
        *ppvObj = &(This->lpvtblPersistFile);
    }
    else if(IsEqualIID(riid, &IID_IPersistStream))
    {
        *ppvObj = &(This->lpvtblPersistStream);
    }
    else if(IsEqualIID(riid, &IID_IShellLinkDataList))
    {
        *ppvObj = &(This->lpvtblShellLinkDataList);
    }
    else if(IsEqualIID(riid, &IID_IShellExtInit))
    {
        *ppvObj = &(This->lpvtblShellExtInit);
    }
    else if(IsEqualIID(riid, &IID_IContextMenu))
    {
        *ppvObj = &(This->lpvtblContextMenu);
    }
261 262 263 264
    else if(IsEqualIID(riid, &IID_IObjectWithSite))
    {
        *ppvObj = &(This->lpvtblObjectWithSite);
    }
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282

    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);

283
    TRACE("(%p)->(count=%u)\n", This, refCount - 1);
284 285 286 287 288 289 290 291 292 293 294

    return refCount;
}

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

295
    TRACE("(%p)->(count=%u)\n", This, refCount + 1);
296 297 298 299 300 301 302 303 304 305 306 307

    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);
    HeapFree(GetProcessHeap(),0,This->sPath);

308 309 310
    if (This->site)
        IUnknown_Release( This->site );

311 312 313
    if (This->pPidl)
        ILFree(This->pPidl);

314
    LocalFree(This);
315 316 317 318 319 320 321 322

    return 0;
}

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

323
    *pclsid = CLSID_ShellLink;
324 325 326
    return S_OK;
}

327 328 329
/**************************************************************************
 *  IPersistFile_QueryInterface
 */
330
static HRESULT WINAPI IPersistFile_fnQueryInterface(
331 332 333
	IPersistFile* iface,
	REFIID riid,
	LPVOID *ppvObj)
334
{
335
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
336
    return ShellLink_QueryInterface( This, riid, ppvObj );
337
}
338 339 340 341

/******************************************************************************
 * IPersistFile_AddRef
 */
342
static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
343
{
344
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
345
    return ShellLink_AddRef( This );
346
}
347

348 349 350
/******************************************************************************
 * IPersistFile_Release
 */
351
static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
352
{
353
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
354
    return IShellLinkA_Release((IShellLinkA*)This);
355 356
}

Patrik Stridvall's avatar
Patrik Stridvall committed
357
static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile* iface, CLSID *pClassID)
358
{
359
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
360
    return ShellLink_GetClassID( This, pClassID );
361
}
362

Patrik Stridvall's avatar
Patrik Stridvall committed
363
static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile* iface)
364
{
365
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
366 367 368 369 370 371 372

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

	if (This->bDirty)
	    return S_OK;

	return S_FALSE;
373
}
374

375
static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR pszFileName, DWORD dwMode)
376
{
377
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
378
	IPersistStream *StreamThis = (IPersistStream *)&This->lpvtblPersistStream;
379 380
        HRESULT r;
        IStream *stm;
381

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

384 385 386
        if( dwMode == 0 )
 		dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
        r = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
387
        if( SUCCEEDED( r ) )
388
        {
389
            r = IPersistStream_Load(StreamThis, stm);
390
            ShellLink_UpdatePath(This->sPathRel, pszFileName, This->sWorkDir, &This->sPath);
391
            IStream_Release( stm );
392
            This->bDirty = FALSE;
393
        }
394
        TRACE("-- returning hr %08x\n", r);
395
        return r;
396 397
}

398
BOOL run_winemenubuilder( const WCHAR *args )
399
{
400
    static const WCHAR menubuilder[] = {'\\','w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',0};
401 402 403 404
    LONG len;
    LPWSTR buffer;
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
405
    BOOL ret;
406
    WCHAR app[MAX_PATH];
407

408 409 410 411
    GetSystemDirectoryW( app, MAX_PATH - sizeof(menubuilder)/sizeof(WCHAR) );
    strcatW( app, menubuilder );

    len = (strlenW( app ) + strlenW( args ) + 1) * sizeof(WCHAR);
412 413 414
    buffer = HeapAlloc( GetProcessHeap(), 0, len );
    if( !buffer )
        return FALSE;
415

416 417
    strcpyW( buffer, app );
    strcatW( buffer, args );
418

419
    TRACE("starting %s\n",debugstr_w(buffer));
420

421 422
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
423

424
    ret = CreateProcessW( app, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi );
425 426 427 428 429 430 431 432 433 434

    HeapFree( GetProcessHeap(), 0, buffer );

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

    return ret;
435 436
}

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
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;
}

455
static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR pszFileName, BOOL fRemember)
456
{
457
    IShellLinkImpl *This = impl_from_IPersistFile(iface);
458
    IPersistStream *StreamThis = (IPersistStream *)&This->lpvtblPersistStream;
459 460
    HRESULT r;
    IStream *stm;
461 462 463

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

464
    if (!pszFileName)
465
        return E_FAIL;
466

467
    r = SHCreateStreamOnFileW( pszFileName, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &stm );
468
    if( SUCCEEDED( r ) )
469
    {
470 471
        r = IPersistStream_Save(StreamThis, stm, FALSE);
        IStream_Release( stm );
472

473
        if( SUCCEEDED( r ) )
474
	{
475
            StartLinkProcessor( pszFileName );
476

477
            This->bDirty = FALSE;
478 479
        }
	else
480
        {
481 482
            DeleteFileW( pszFileName );
            WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
483 484
        }
    }
485

486
    return r;
487
}
488

489
static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR pszFileName)
490
{
491
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
492
	FIXME("(%p)->(%s)\n",This,debugstr_w(pszFileName));
493
	return NOERROR;
494
}
495

Patrik Stridvall's avatar
Patrik Stridvall committed
496
static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile* iface, LPOLESTR *ppszFileName)
497
{
498
	IShellLinkImpl *This = impl_from_IPersistFile(iface);
499
	FIXME("(%p)\n",This);
500 501
	return NOERROR;
}
502

503
static const IPersistFileVtbl pfvt =
504
{
505 506 507 508 509 510 511 512 513
	IPersistFile_fnQueryInterface,
	IPersistFile_fnAddRef,
	IPersistFile_fnRelease,
	IPersistFile_fnGetClassID,
	IPersistFile_fnIsDirty,
	IPersistFile_fnLoad,
	IPersistFile_fnSave,
	IPersistFile_fnSaveCompleted,
	IPersistFile_fnGetCurFile
514
};
515

516 517
/************************************************************************
 * IPersistStream_QueryInterface
518
 */
519 520 521
static HRESULT WINAPI IPersistStream_fnQueryInterface(
	IPersistStream* iface,
	REFIID     riid,
522
	VOID**     ppvObj)
523
{
524
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
525
    return ShellLink_QueryInterface( This, riid, ppvObj );
526
}
527

528 529 530 531 532
/************************************************************************
 * IPersistStream_Release
 */
static ULONG WINAPI IPersistStream_fnRelease(
	IPersistStream* iface)
533
{
534
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
535
    return IShellLinkA_Release((IShellLinkA*)This);
536
}
537 538 539

/************************************************************************
 * IPersistStream_AddRef
540
 */
541 542
static ULONG WINAPI IPersistStream_fnAddRef(
	IPersistStream* iface)
543
{
544
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
545
    return ShellLink_AddRef( This );
546
}
547

548 549 550
/************************************************************************
 * IPersistStream_GetClassID
 *
551
 */
552
static HRESULT WINAPI IPersistStream_fnGetClassID(
Patrik Stridvall's avatar
Patrik Stridvall committed
553
	IPersistStream* iface,
554
	CLSID* pClassID)
555
{
556
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
557
    return ShellLink_GetClassID( This, pClassID );
558
}
559 560 561

/************************************************************************
 * IPersistStream_IsDirty (IPersistStream)
562
 */
563 564
static HRESULT WINAPI IPersistStream_fnIsDirty(
	IPersistStream*  iface)
565
{
566
	IShellLinkImpl *This = impl_from_IPersistStream(iface);
567

568 569 570
	TRACE("(%p)\n", This);

	return S_OK;
571
}
572 573 574 575 576 577 578 579 580 581 582 583 584


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;
585 586
    r = IStream_Read(stm, &len, sizeof(len), &count);
    if ( FAILED (r) || ( count != sizeof(len) ) )
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
        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 )
    {
609
        count = MultiByteToWideChar( CP_ACP, 0, temp, len, NULL, 0 );
610
        str = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
611 612 613 614 615
        if( !str )
        {
            HeapFree( GetProcessHeap(), 0, temp );
            return E_OUTOFMEMORY;
        }
616
        MultiByteToWideChar( CP_ACP, 0, temp, len, str, count );
617 618 619 620 621
        HeapFree( GetProcessHeap(), 0, temp );
    }
    else
    {
        count /= 2;
622
        str = temp;
623 624 625 626 627 628 629 630
    }
    str[count] = 0;

    *pstr = str;

    return S_OK;
}

631
static HRESULT Stream_ReadChunk( IStream* stm, LPVOID *data )
632 633 634 635
{
    DWORD size;
    ULONG count;
    HRESULT r;
636 637 638 639
    struct sized_chunk {
        DWORD size;
        unsigned char data[1];
    } *chunk;
640 641 642

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

643
    r = IStream_Read( stm, &size, sizeof(size), &count );
644
    if( FAILED( r )  || count != sizeof(size) )
645 646
        return E_FAIL;

647 648
    chunk = HeapAlloc( GetProcessHeap(), 0, size );
    if( !chunk )
649 650
        return E_OUTOFMEMORY;

651 652 653 654 655 656 657 658
    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;
    }

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

661
    *data = chunk;
662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687

    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;
}

688
static LPWSTR Stream_LoadPath( LPCSTR p, DWORD maxlen )
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
{
    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
707
    char *p = NULL;
708 709
    LOCATION_INFO *loc;
    HRESULT r;
710
    DWORD n;
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737

    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 );

738
    TRACE("type %d serial %08x name %s path %s\n", volume->type,
739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
          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;
764
    EXP_DARWIN_LINK buffer;
765 766 767
    
    TRACE("%p\n",stm);

768
    r = IStream_Read( stm, &buffer.dbh.cbSize, sizeof (DWORD), &count );
769
    if( FAILED( r ) )
770 771 772 773
        return r;

    /* make sure that we read the size of the structure even on error */
    size = sizeof buffer - sizeof (DWORD);
774
    if( buffer.dbh.cbSize != sizeof buffer )
775
    {
776
        ERR("Ooops.  This structure is not as expected...\n");
777
        return E_FAIL;
778 779
    }

780
    r = IStream_Read( stm, &buffer.dbh.dwSignature, size, &count );
781 782 783 784 785 786
    if( FAILED( r ) )
        return r;

    if( count != size )
        return E_FAIL;

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

789
    if( (buffer.dbh.dwSignature&0xffff0000) != 0xa0000000 )
790
    {
791
        ERR("Unknown magic number %08x in advertised shortcut\n", buffer.dbh.dwSignature);
792 793
        return E_FAIL;
    }
794

795
    *str = HeapAlloc( GetProcessHeap(), 0, 
796 797
                     (lstrlenW(buffer.szwDarwinID)+1) * sizeof(WCHAR) );
    lstrcpyW( *str, buffer.szwDarwinID );
798 799 800 801

    return S_OK;
}

802 803
/************************************************************************
 * IPersistStream_Load (IPersistStream)
804
 */
805
static HRESULT WINAPI IPersistStream_fnLoad(
806
    IPersistStream*  iface,
807
    IStream*         stm)
808
{
809 810 811 812
    LINK_HEADER hdr;
    ULONG    dwBytesRead;
    BOOL     unicode;
    HRESULT  r;
813
    DWORD    zero;
814

815
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
816

817
    TRACE("%p %p\n", This, stm);
818

819
    if( !stm )
820
        return STG_E_INVALIDPOINTER;
821

822
    dwBytesRead = 0;
823
    r = IStream_Read(stm, &hdr, sizeof(hdr), &dwBytesRead);
824 825
    if( FAILED( r ) )
        return r;
826

827
    if( dwBytesRead != sizeof(hdr))
828
        return E_FAIL;
829
    if( hdr.dwSize != sizeof(hdr))
830 831 832
        return E_FAIL;
    if( !IsEqualIID(&hdr.MagicGuid, &CLSID_ShellLink) )
        return E_FAIL;
833

834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
    /* 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;
        
855
    This->wHotKey = (WORD)hdr.wHotKey;
856 857 858 859
    This->iIcoNdx = hdr.nIcon;
    FileTimeToSystemTime (&hdr.Time1, &This->time1);
    FileTimeToSystemTime (&hdr.Time2, &This->time2);
    FileTimeToSystemTime (&hdr.Time3, &This->time3);
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874
    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 */
875
    if( hdr.dwFlags & SLDF_HAS_ID_LIST )
876 877 878 879 880 881 882 883
    {
        r = ILLoadFromStream( stm, &This->pPidl );
        if( FAILED( r ) )
            return r;
    }
    pdump(This->pPidl);

    /* load the location information */
884
    if( hdr.dwFlags & SLDF_HAS_LINK_INFO )
885
        r = Stream_LoadLocation( stm, &This->volume, &This->sPath );
886 887
    if( FAILED( r ) )
        goto end;
888

889 890
    unicode = hdr.dwFlags & SLDF_UNICODE;
    if( hdr.dwFlags & SLDF_HAS_NAME )
891 892 893 894 895 896
    {
        r = Stream_LoadString( stm, unicode, &This->sDescription );
        TRACE("Description  -> %s\n",debugstr_w(This->sDescription));
    }
    if( FAILED( r ) )
        goto end;
897

898
    if( hdr.dwFlags & SLDF_HAS_RELPATH )
899 900 901 902 903 904
    {
        r = Stream_LoadString( stm, unicode, &This->sPathRel );
        TRACE("Relative Path-> %s\n",debugstr_w(This->sPathRel));
    }
    if( FAILED( r ) )
        goto end;
905

906
    if( hdr.dwFlags & SLDF_HAS_WORKINGDIR )
907
    {
908 909 910 911 912
        r = Stream_LoadString( stm, unicode, &This->sWorkDir );
        TRACE("Working Dir  -> %s\n",debugstr_w(This->sWorkDir));
    }
    if( FAILED( r ) )
        goto end;
913

914
    if( hdr.dwFlags & SLDF_HAS_ARGS )
915 916 917 918 919 920 921
    {
        r = Stream_LoadString( stm, unicode, &This->sArgs );
        TRACE("Working Dir  -> %s\n",debugstr_w(This->sArgs));
    }
    if( FAILED( r ) )
        goto end;

922
    if( hdr.dwFlags & SLDF_HAS_ICONLOCATION )
923 924 925 926 927 928 929
    {
        r = Stream_LoadString( stm, unicode, &This->sIcoPath );
        TRACE("Icon file    -> %s\n",debugstr_w(This->sIcoPath));
    }
    if( FAILED( r ) )
        goto end;

930
    if( hdr.dwFlags & SLDF_HAS_LOGO3ID )
931 932 933 934 935 936 937
    {
        r = Stream_LoadAdvertiseInfo( stm, &This->sProduct );
        TRACE("Product      -> %s\n",debugstr_w(This->sProduct));
    }
    if( FAILED( r ) )
        goto end;

938
    if( hdr.dwFlags & SLDF_HAS_DARWINID )
939 940 941 942 943 944 945 946 947
    {
        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 )
948 949 950 951 952 953 954 955
    {
        /* 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");
    }
956

957 958 959
    TRACE("OK\n");

    pdump (This->pPidl);
960

961
    return S_OK;
962
end:
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
    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;

978
    r = IStream_Write( stm, &len, sizeof(len), &count );
979 980 981 982 983 984 985 986 987 988 989
    if( FAILED( r ) )
        return r;

    len *= sizeof(WCHAR);

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

    return S_OK;
}
990

991 992 993 994 995 996 997
/************************************************************************
 * 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.
998
 *        Figure out how Windows deals with unicode paths here.
999 1000 1001 1002 1003 1004 1005 1006 1007
 */
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;
1008
    HRESULT hr;
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049

    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;

1050 1051 1052 1053
    hr = IStream_Write( stm, loc, total_size, &count );
    HeapFree(GetProcessHeap(), 0, loc);

    return hr;
1054 1055
}

1056 1057 1058 1059 1060
static EXP_DARWIN_LINK* shelllink_build_darwinid( LPCWSTR string, DWORD magic )
{
    EXP_DARWIN_LINK *buffer;
    
    buffer = LocalAlloc( LMEM_ZEROINIT, sizeof *buffer );
1061
    buffer->dbh.cbSize = sizeof *buffer;
1062 1063 1064 1065 1066 1067 1068
    buffer->dbh.dwSignature = magic;
    lstrcpynW( buffer->szwDarwinID, string, MAX_PATH );
    WideCharToMultiByte(CP_ACP, 0, string, -1, buffer->szDarwinID, MAX_PATH, NULL, NULL );

    return buffer;
}

1069
static HRESULT Stream_WriteAdvertiseInfo( IStream* stm, LPCWSTR string, DWORD magic )
1070
{
1071
    EXP_DARWIN_LINK *buffer;
1072
    ULONG count;
1073 1074
    
    TRACE("%p\n",stm);
1075

1076
    buffer = shelllink_build_darwinid( string, magic );
1077

1078
    return IStream_Write( stm, buffer, buffer->dbh.cbSize, &count );
1079
}
1080 1081 1082

/************************************************************************
 * IPersistStream_Save (IPersistStream)
1083 1084
 *
 * FIXME: makes assumptions about byte order
1085
 */
1086 1087
static HRESULT WINAPI IPersistStream_fnSave(
	IPersistStream*  iface,
1088
	IStream*         stm,
1089
	BOOL             fClearDirty)
1090
{
1091
    LINK_HEADER header;
1092
    ULONG   count;
1093
    DWORD   zero;
1094
    HRESULT r;
1095

1096
    IShellLinkImpl *This = impl_from_IPersistStream(iface);
1097

1098
    TRACE("%p %p %x\n", This, stm, fClearDirty);
1099

1100 1101
    memset(&header, 0, sizeof(header));
    header.dwSize = sizeof(header);
1102
    header.fStartup = This->iShowCmd;
1103
    header.MagicGuid = CLSID_ShellLink;
1104 1105 1106

    header.wHotKey = This->wHotKey;
    header.nIcon = This->iIcoNdx;
1107
    header.dwFlags = SLDF_UNICODE;   /* strings are in unicode */
1108
    if( This->pPidl )
1109
        header.dwFlags |= SLDF_HAS_ID_LIST;
1110
    if( This->sPath )
1111
        header.dwFlags |= SLDF_HAS_LINK_INFO;
1112
    if( This->sDescription )
1113
        header.dwFlags |= SLDF_HAS_NAME;
1114
    if( This->sWorkDir )
1115
        header.dwFlags |= SLDF_HAS_WORKINGDIR;
1116
    if( This->sArgs )
1117
        header.dwFlags |= SLDF_HAS_ARGS;
1118
    if( This->sIcoPath )
1119
        header.dwFlags |= SLDF_HAS_ICONLOCATION;
1120
    if( This->sProduct )
1121
        header.dwFlags |= SLDF_HAS_LOGO3ID;
1122
    if( This->sComponent )
1123
        header.dwFlags |= SLDF_HAS_DARWINID;
1124 1125 1126 1127 1128 1129

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

    /* write the Shortcut header */
1130
    r = IStream_Write( stm, &header, sizeof(header), &count );
1131 1132 1133 1134 1135 1136
    if( FAILED( r ) )
    {
        ERR("Write failed at %d\n",__LINE__);
        return r;
    }

1137
    TRACE("Writing pidl\n");
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149

    /* 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;
        }
    }

1150
    if( This->sPath )
1151
        Stream_WriteLocationInfo( stm, This->sPath, &This->volume );
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167

    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 );

1168
    if( This->sProduct )
1169
        r = Stream_WriteAdvertiseInfo( stm, This->sProduct, EXP_SZ_ICON_SIG );
1170 1171

    if( This->sComponent )
1172
        r = Stream_WriteAdvertiseInfo( stm, This->sComponent, EXP_DARWIN_ID_SIG );
1173 1174 1175 1176 1177

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

1178
    return S_OK;
1179 1180
}

1181 1182
/************************************************************************
 * IPersistStream_GetSizeMax (IPersistStream)
1183
 */
1184 1185 1186
static HRESULT WINAPI IPersistStream_fnGetSizeMax(
	IPersistStream*  iface,
	ULARGE_INTEGER*  pcbSize)
1187
{
1188
	IShellLinkImpl *This = impl_from_IPersistStream(iface);
1189

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

1192 1193
	return E_NOTIMPL;
}
1194

1195
static const IPersistStreamVtbl psvt =
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
{
	IPersistStream_fnQueryInterface,
	IPersistStream_fnAddRef,
	IPersistStream_fnRelease,
	IPersistStream_fnGetClassID,
	IPersistStream_fnIsDirty,
	IPersistStream_fnLoad,
	IPersistStream_fnSave,
	IPersistStream_fnGetSizeMax
};
1206 1207 1208 1209

/**************************************************************************
 *	  IShellLink_Constructor
 */
1210 1211
HRESULT WINAPI IShellLink_Constructor( IUnknown *pUnkOuter,
               REFIID riid, LPVOID *ppv )
1212 1213
{
	IShellLinkImpl * sl;
1214
	HRESULT r;
1215 1216 1217 1218 1219

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

	*ppv = NULL;

1220 1221 1222 1223 1224
	if (pUnkOuter)
            return CLASS_E_NOAGGREGATION;
	sl = LocalAlloc(LMEM_ZEROINIT,sizeof(IShellLinkImpl));
	if (!sl)
            return E_OUTOFMEMORY;
1225 1226

	sl->ref = 1;
1227
	sl->lpVtbl = &slvt;
1228 1229 1230
	sl->lpvtblw = &slvtw;
	sl->lpvtblPersistFile = &pfvt;
	sl->lpvtblPersistStream = &psvt;
1231
	sl->lpvtblShellLinkDataList = &dlvt;
1232
	sl->lpvtblShellExtInit = &eivt;
1233
	sl->lpvtblContextMenu = &cmvt;
1234
	sl->lpvtblObjectWithSite = &owsvt;
1235
	sl->iShowCmd = SW_SHOWNORMAL;
1236
	sl->bDirty = FALSE;
1237
	sl->iIdOpen = -1;
1238
	sl->site = NULL;
1239

1240
	TRACE("(%p)->()\n",sl);
1241

1242 1243 1244
        r = ShellLink_QueryInterface( sl, riid, ppv );
        ShellLink_Release( sl );
        return r;
1245 1246
}

1247 1248 1249

static BOOL SHELL_ExistsFileW(LPCWSTR path)
{
1250
    if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
1251
        return FALSE;
1252
    return TRUE;
1253 1254 1255
}

/**************************************************************************
1256
 *  ShellLink_UpdatePath
1257 1258
 *	update absolute path in sPath using relative path in sPathRel
 */
1259
static HRESULT ShellLink_UpdatePath(LPCWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath)
1260 1261 1262 1263 1264 1265
{
    if (!path || !psPath)
	return E_INVALIDARG;

    if (!*psPath && sPathRel) {
	WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
1266
	LPWSTR final = NULL;
1267 1268 1269

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

1270 1271 1272 1273
        GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
        if( !final )
            final = buffer;
	lstrcpyW(final, sPathRel);
1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308

	*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
 */
1309 1310
HRESULT WINAPI IShellLink_ConstructFromFile( IUnknown* pUnkOuter, REFIID riid,
               LPCITEMIDLIST pidl, LPVOID* ppv)
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
{
    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];

1326
	    if (SHGetPathFromIDListW(pidl, path)) 
1327
		hr = IPersistFile_Load(ppf, path, 0);
1328 1329
            else
                hr = E_FAIL;
1330

1331
	    if (SUCCEEDED(hr))
1332
                *ppv = psl;
1333

1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
	    IPersistFile_Release(ppf);
	}

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

    return hr;
}

1344
/**************************************************************************
1345
 *  IShellLinkA_QueryInterface
1346
 */
1347
static HRESULT WINAPI IShellLinkA_fnQueryInterface( IShellLinkA * iface, REFIID riid,  LPVOID *ppvObj)
1348
{
1349 1350
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
    return ShellLink_QueryInterface( This, riid, ppvObj );
1351
}
1352

1353
/******************************************************************************
1354
 * IShellLinkA_AddRef
1355
 */
1356
static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA * iface)
1357
{
1358 1359
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
    return ShellLink_AddRef( This );
1360
}
1361

1362
/******************************************************************************
1363
 *	IShellLinkA_Release
1364
 */
1365
static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA * iface)
1366
{
1367
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1368
    return ShellLink_Release( This );
1369 1370
}

1371 1372
static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA * iface, LPSTR pszFile,
                  INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags)
1373
{
1374
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1375

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

1379 1380 1381 1382
    if (This->sComponent || This->sProduct)
        return S_FALSE;

    if (cchMaxPath)
1383 1384 1385 1386
        pszFile[0] = 0;
    if (This->sPath)
        WideCharToMultiByte( CP_ACP, 0, This->sPath, -1,
                             pszFile, cchMaxPath, NULL, NULL);
1387

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

1390
    return S_OK;
1391
}
1392

1393
static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA * iface, LPITEMIDLIST * ppidl)
1394
{
1395
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1396

1397
    TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1398

1399
    return IShellLinkW_GetIDList((IShellLinkW*)&(This->lpvtblw), ppidl);
1400
}
1401

1402
static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA * iface, LPCITEMIDLIST pidl)
1403
{
1404
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1405

1406
    TRACE("(%p)->(pidl=%p)\n",This, pidl);
1407

1408 1409 1410 1411
    if (This->pPidl)
	ILFree(This->pPidl);
    This->pPidl = ILClone (pidl);
    This->bDirty = TRUE;
1412 1413

    return S_OK;
1414
}
1415

1416
static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA * iface, LPSTR pszName,INT cchMaxName)
1417
{
1418
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1419

1420 1421 1422 1423 1424 1425 1426 1427 1428
    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;
1429
}
1430

1431
static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA * iface, LPCSTR pszName)
1432
{
1433
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1434

1435
    TRACE("(%p)->(pName=%s)\n", This, pszName);
1436

1437
    HeapFree(GetProcessHeap(), 0, This->sDescription);
1438 1439 1440
    This->sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
    if ( !This->sDescription )
        return E_OUTOFMEMORY;
1441

1442 1443
    This->bDirty = TRUE;

1444
    return S_OK;
1445
}
1446

1447
static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA * iface, LPSTR pszDir,INT cchMaxPath)
1448
{
1449
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1450

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

1453 1454 1455 1456 1457
    if( cchMaxPath )
        pszDir[0] = 0;
    if( This->sWorkDir )
        WideCharToMultiByte( CP_ACP, 0, This->sWorkDir, -1,
                             pszDir, cchMaxPath, NULL, NULL);
1458

1459
    return S_OK;
1460
}
1461

1462
static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA * iface, LPCSTR pszDir)
1463
{
1464
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1465

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

1468
    HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1469 1470 1471
    This->sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
    if ( !This->sWorkDir )
        return E_OUTOFMEMORY;
1472

1473 1474
    This->bDirty = TRUE;

1475
    return S_OK;
1476
}
1477

1478
static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA * iface, LPSTR pszArgs,INT cchMaxPath)
1479
{
1480
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1481

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

1484 1485 1486 1487 1488
    if( cchMaxPath )
        pszArgs[0] = 0;
    if( This->sArgs )
        WideCharToMultiByte( CP_ACP, 0, This->sArgs, -1,
                             pszArgs, cchMaxPath, NULL, NULL);
1489

1490
    return S_OK;
1491
}
1492

1493
static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA * iface, LPCSTR pszArgs)
1494
{
1495
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1496

1497
    TRACE("(%p)->(args=%s)\n",This, pszArgs);
1498

1499
    HeapFree(GetProcessHeap(), 0, This->sArgs);
1500 1501 1502
    This->sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
    if( !This->sArgs )
        return E_OUTOFMEMORY;
1503

1504 1505
    This->bDirty = TRUE;

1506
    return S_OK;
1507
}
1508

1509
static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA * iface, WORD *pwHotkey)
1510
{
1511
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1512

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

1515
    *pwHotkey = This->wHotKey;
1516

1517
    return S_OK;
1518
}
1519

1520
static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA * iface, WORD wHotkey)
1521
{
1522
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1523

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

1526 1527
    This->wHotKey = wHotkey;
    This->bDirty = TRUE;
1528

1529
    return S_OK;
1530
}
1531

1532
static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA * iface, INT *piShowCmd)
1533
{
1534
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1535

1536 1537 1538
    TRACE("(%p)->(%p)\n",This, piShowCmd);
    *piShowCmd = This->iShowCmd;
    return S_OK;
1539
}
1540

1541
static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA * iface, INT iShowCmd)
1542
{
1543
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1544

1545 1546 1547
    TRACE("(%p) %d\n",This, iShowCmd);

    This->iShowCmd = iShowCmd;
1548
    This->bDirty = TRUE;
1549 1550

    return NOERROR;
1551
}
1552

1553 1554
static HRESULT SHELL_PidlGeticonLocationA(IShellFolder* psf, LPCITEMIDLIST pidl,
                                          LPSTR pszIconPath, int cchIconPath, int* piIcon)
1555 1556 1557 1558 1559 1560 1561 1562
{
    LPCITEMIDLIST pidlLast;

    HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);

    if (SUCCEEDED(hr)) {
	IExtractIconA* pei;

1563
	hr = IShellFolder_GetUIObjectOf(psf, 0, 1, &pidlLast, &IID_IExtractIconA, NULL, (LPVOID*)&pei);
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

	if (SUCCEEDED(hr)) {
	    hr = IExtractIconA_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);

	    IExtractIconA_Release(pei);
	}

	IShellFolder_Release(psf);
    }

    return hr;
}

1577
static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
1578
{
1579
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1580

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

1583 1584
    pszIconPath[0] = 0;
    *piIcon = This->iIcoNdx;
1585

1586 1587
    if (This->sIcoPath)
    {
1588 1589 1590 1591
        WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
	return S_OK;
    }

1592 1593
    if (This->pPidl || This->sPath)
    {
1594 1595 1596 1597
	IShellFolder* pdsk;

	HRESULT hr = SHGetDesktopFolder(&pdsk);

1598 1599
	if (SUCCEEDED(hr))
        {
1600 1601 1602 1603 1604 1605 1606
	    /* first look for an icon using the PIDL (if present) */
	    if (This->pPidl)
		hr = SHELL_PidlGeticonLocationA(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
	    else
		hr = E_FAIL;

	    /* if we couldn't find an icon yet, look for it using the file system path */
1607 1608
	    if (FAILED(hr) && This->sPath)
            {
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
		LPITEMIDLIST pidl;

		hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);

		if (SUCCEEDED(hr)) {
		    hr = SHELL_PidlGeticonLocationA(pdsk, pidl, pszIconPath, cchIconPath, piIcon);

		    SHFree(pidl);
		}
	    }

	    IShellFolder_Release(pdsk);
	}

	return hr;
1624 1625
    }
    return S_OK;
1626
}
1627

1628
static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA * iface, LPCSTR pszIconPath,INT iIcon)
1629
{
1630
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1631

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

1634
    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1635 1636 1637
    This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
    if ( !This->sIcoPath )
        return E_OUTOFMEMORY;
1638

1639
    This->iIcoNdx = iIcon;
1640
    This->bDirty = TRUE;
1641

1642
    return S_OK;
1643
}
1644

1645
static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA * iface, LPCSTR pszPathRel, DWORD dwReserved)
1646
{
1647
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1648

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

1651
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
1652
    This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1653
    This->bDirty = TRUE;
1654

1655
    return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1656
}
1657

1658
static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA * iface, HWND hwnd, DWORD fFlags)
1659
{
1660 1661
    IShellLinkImpl *This = (IShellLinkImpl *)iface;

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

1664
    return IShellLinkW_Resolve( (IShellLinkW*)&(This->lpvtblw), hwnd, fFlags );
1665
}
1666

1667
static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA * iface, LPCSTR pszFile)
1668
{
1669 1670
    HRESULT r;
    LPWSTR str;
1671
    IShellLinkImpl *This = (IShellLinkImpl *)iface;
1672

1673
    TRACE("(%p)->(path=%s)\n",This, pszFile);
1674

1675 1676
    if (!pszFile) return E_INVALIDARG;

1677 1678
    str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
    if( !str ) 
1679
        return E_OUTOFMEMORY;
1680

1681 1682
    r = IShellLinkW_SetPath((IShellLinkW*)&(This->lpvtblw), str);
    HeapFree( GetProcessHeap(), 0, str );
1683

1684
    return r;
1685 1686
}

1687 1688 1689 1690
/**************************************************************************
* IShellLink Implementation
*/

1691
static const IShellLinkAVtbl slvt =
1692
{
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
    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
1714 1715
};

1716 1717

/**************************************************************************
1718
 *  IShellLinkW_fnQueryInterface
1719
 */
1720 1721 1722
static HRESULT WINAPI IShellLinkW_fnQueryInterface(
  IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
{
1723
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1724
    return ShellLink_QueryInterface( This, riid, ppvObj );
1725
}
1726

1727
/******************************************************************************
1728
 * IShellLinkW_fnAddRef
1729
 */
1730 1731
static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
{
1732
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1733
    return ShellLink_AddRef( This );
1734
}
1735

1736
/******************************************************************************
1737
 * IShellLinkW_fnRelease
1738
 */
1739 1740
static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
{
1741
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1742
    return ShellLink_Release( This );
1743 1744
}

1745
static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1746
{
1747
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1748

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

1752 1753 1754 1755
    if (This->sComponent || This->sProduct)
        return S_FALSE;

    if (cchMaxPath)
1756
        pszFile[0] = 0;
1757
    if (This->sPath)
1758 1759
        lstrcpynW( pszFile, This->sPath, cchMaxPath );

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

1762
    return S_OK;
1763
}
1764 1765 1766

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

1769 1770
    TRACE("(%p)->(ppidl=%p)\n",This, ppidl);

1771
    if (!This->pPidl)
1772 1773
    {
	*ppidl = NULL;
1774
        return S_FALSE;
1775
    }
1776
    *ppidl = ILClone(This->pPidl);
1777
    return S_OK;
1778
}
1779 1780 1781

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

1784 1785 1786 1787 1788 1789 1790 1791
    TRACE("(%p)->(pidl=%p)\n",This, pidl);

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

1792 1793
    This->bDirty = TRUE;

1794
    return S_OK;
1795
}
1796

1797
static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1798
{
1799
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1800

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

1803
    pszName[0] = 0;
1804 1805 1806 1807
    if( This->sDescription )
        lstrcpynW( pszName, This->sDescription, cchMaxName );

    return S_OK;
1808
}
1809 1810 1811

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

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

1816
    HeapFree(GetProcessHeap(), 0, This->sDescription);
1817 1818 1819 1820
    This->sDescription = HeapAlloc( GetProcessHeap(), 0,
                                    (lstrlenW( pszName )+1)*sizeof(WCHAR) );
    if ( !This->sDescription )
        return E_OUTOFMEMORY;
1821

1822
    lstrcpyW( This->sDescription, pszName );
1823
    This->bDirty = TRUE;
1824

1825
    return S_OK;
1826
}
1827

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

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

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

1839
    return S_OK;
1840
}
1841 1842 1843

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

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

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

1856
    return S_OK;
1857
}
1858

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

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

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

1870
    return NOERROR;
1871
}
1872 1873 1874

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

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

1879
    HeapFree(GetProcessHeap(), 0, This->sArgs);
1880 1881 1882 1883 1884
    This->sArgs = HeapAlloc( GetProcessHeap(), 0,
                             (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
    if ( !This->sArgs )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sArgs, pszArgs );
1885
    This->bDirty = TRUE;
1886

1887
    return S_OK;
1888
}
1889 1890 1891

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

1894 1895 1896 1897 1898
    TRACE("(%p)->(%p)\n",This, pwHotkey);

    *pwHotkey=This->wHotKey;

    return S_OK;
1899
}
1900 1901 1902

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

1905 1906 1907
    TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);

    This->wHotKey = wHotkey;
1908
    This->bDirty = TRUE;
1909 1910

    return S_OK;
1911
}
1912

1913
static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1914
{
1915
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1916

1917 1918 1919 1920 1921
    TRACE("(%p)->(%p)\n",This, piShowCmd);

    *piShowCmd = This->iShowCmd;

    return S_OK;
1922
}
1923

1924
static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1925
{
1926
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1927

1928
    This->iShowCmd = iShowCmd;
1929
    This->bDirty = TRUE;
1930 1931

    return S_OK;
1932
}
1933

1934 1935
static HRESULT SHELL_PidlGeticonLocationW(IShellFolder* psf, LPCITEMIDLIST pidl,
                                          LPWSTR pszIconPath, int cchIconPath, int* piIcon)
1936 1937 1938 1939 1940 1941 1942 1943
{
    LPCITEMIDLIST pidlLast;

    HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);

    if (SUCCEEDED(hr)) {
	IExtractIconW* pei;

1944
	hr = IShellFolder_GetUIObjectOf(psf, 0, 1, &pidlLast, &IID_IExtractIconW, NULL, (LPVOID*)&pei);
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957

	if (SUCCEEDED(hr)) {
	    hr = IExtractIconW_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);

	    IExtractIconW_Release(pei);
	}

	IShellFolder_Release(psf);
    }

    return hr;
}

1958
static HRESULT WINAPI IShellLinkW_fnGetIconLocation(IShellLinkW * iface, LPWSTR pszIconPath,INT cchIconPath,INT *piIcon)
1959
{
1960
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
1961

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

1964 1965
    pszIconPath[0] = 0;
    *piIcon = This->iIcoNdx;
1966

1967 1968
    if (This->sIcoPath)
    {
1969 1970 1971 1972
	lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
	return S_OK;
    }

1973 1974
    if (This->pPidl || This->sPath)
    {
1975 1976 1977 1978
	IShellFolder* pdsk;

	HRESULT hr = SHGetDesktopFolder(&pdsk);

1979 1980
	if (SUCCEEDED(hr))
        {
1981 1982 1983 1984 1985 1986 1987
	    /* first look for an icon using the PIDL (if present) */
	    if (This->pPidl)
		hr = SHELL_PidlGeticonLocationW(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
	    else
		hr = E_FAIL;

	    /* if we couldn't find an icon yet, look for it using the file system path */
1988 1989
	    if (FAILED(hr) && This->sPath)
            {
1990 1991 1992 1993
		LPITEMIDLIST pidl;

		hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);

1994 1995
		if (SUCCEEDED(hr))
                {
1996 1997 1998 1999 2000 2001 2002 2003 2004
		    hr = SHELL_PidlGeticonLocationW(pdsk, pidl, pszIconPath, cchIconPath, piIcon);

		    SHFree(pidl);
		}
	    }

	    IShellFolder_Release(pdsk);
	}
	return hr;
2005 2006
    }
    return S_OK;
2007
}
2008

2009
static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
2010
{
2011
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2012

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

2015
    HeapFree(GetProcessHeap(), 0, This->sIcoPath);
2016 2017 2018 2019 2020
    This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
                                (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
    if ( !This->sIcoPath )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sIcoPath, pszIconPath );
2021

2022
    This->iIcoNdx = iIcon;
2023
    This->bDirty = TRUE;
2024 2025

    return S_OK;
2026
}
2027 2028 2029

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

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

2034
    HeapFree(GetProcessHeap(), 0, This->sPathRel);
2035 2036 2037 2038 2039
    This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
                                (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
    if ( !This->sPathRel )
        return E_OUTOFMEMORY;
    lstrcpyW( This->sPathRel, pszPathRel );
2040
    This->bDirty = TRUE;
2041

2042
    return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
2043
}
2044

2045
static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
2046
{
2047
    HRESULT hr = S_OK;
2048
    BOOL bSuccess;
2049

2050
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2051

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

2054 2055 2056 2057 2058
    /*FIXME: use IResolveShellLink interface */

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

2059
	bSuccess = SHGetPathFromIDListW(This->pPidl, buffer);
2060

2061
	if (bSuccess && *buffer) {
2062
	    This->sPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(buffer)+1)*sizeof(WCHAR));
2063 2064 2065 2066 2067 2068 2069
	    if (!This->sPath)
		return E_OUTOFMEMORY;

	    lstrcpyW(This->sPath, buffer);

	    This->bDirty = TRUE;
	} else
2070
	    hr = S_OK;    /* don't report an error occurred while just caching information */
2071 2072 2073
    }

    if (!This->sIcoPath && This->sPath) {
2074
	This->sIcoPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(This->sPath)+1)*sizeof(WCHAR));
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
	if (!This->sIcoPath)
	    return E_OUTOFMEMORY;

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

	This->bDirty = TRUE;
    }

    return hr;
2085
}
2086

2087 2088 2089 2090 2091 2092
static LPWSTR ShellLink_GetAdvertisedArg(LPCWSTR str)
{
    LPWSTR ret;
    LPCWSTR p;
    DWORD len;

2093 2094 2095
    if( !str )
        return NULL;

2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
    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;
    }

2157 2158
    /* we have to have a component for an advertised shortcut */
    if( !szComponent )
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
        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;
}

2170
static BOOL ShellLink_GetVolumeInfo(LPCWSTR path, volume_info *volume)
2171 2172 2173 2174 2175 2176 2177 2178
{
    const int label_sz = sizeof volume->label/sizeof volume->label[0];
    WCHAR drive[4] = { path[0], ':', '\\', 0 };
    BOOL r;

    volume->type = GetDriveTypeW(drive);
    r = GetVolumeInformationW(drive, volume->label, label_sz,
                              &volume->serial, NULL, NULL, NULL, 0);
2179
    TRACE("r = %d type %d serial %08x name %s\n", r,
2180 2181 2182 2183
          volume->type, volume->serial, debugstr_w(volume->label));
    return r;
}

2184 2185
static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
{
2186
    IShellLinkImpl *This = impl_from_IShellLinkW(iface);
2187
    WCHAR buffer[MAX_PATH];
2188
    LPWSTR fname, unquoted = NULL;
2189
    HRESULT hr = S_OK;
2190
    UINT len;
2191

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

2194 2195
    if (!pszFile) return E_INVALIDARG;

2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
    /* 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, '"'))
        return S_FALSE;

2209
    HeapFree(GetProcessHeap(), 0, This->sPath);
2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
    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;
2225 2226 2227
        else if(!PathFileExistsW(buffer) &&
		!SearchPathW(NULL, pszFile, NULL, MAX_PATH, buffer, NULL))
	  hr = S_FALSE;
2228 2229 2230 2231 2232

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

        This->sPath = HeapAlloc( GetProcessHeap(), 0,
2233
                             (lstrlenW( buffer )+1) * sizeof (WCHAR) );
2234 2235
        if (!This->sPath)
            return E_OUTOFMEMORY;
2236

2237 2238
        lstrcpyW(This->sPath, buffer);
    }
2239
    This->bDirty = TRUE;
2240
    HeapFree(GetProcessHeap(), 0, unquoted);
2241

2242
    return hr;
2243 2244
}

2245 2246 2247 2248
/**************************************************************************
* IShellLinkW Implementation
*/

2249
static const IShellLinkWVtbl slvtw =
2250
{
2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271
    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
2272
};
2273 2274 2275 2276

static HRESULT WINAPI
ShellLink_DataList_QueryInterface( IShellLinkDataList* iface, REFIID riid, void** ppvObject)
{
2277
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2278 2279 2280 2281 2282 2283
    return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
}

static ULONG WINAPI
ShellLink_DataList_AddRef( IShellLinkDataList* iface )
{
2284
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2285 2286 2287 2288 2289 2290
    return IShellLinkA_AddRef((IShellLinkA*)This);
}

static ULONG WINAPI
ShellLink_DataList_Release( IShellLinkDataList* iface )
{
2291
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
2292
    return ShellLink_Release( This );
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
}

static HRESULT WINAPI
ShellLink_AddDataBlock( IShellLinkDataList* iface, void* pDataBlock )
{
    FIXME("\n");
    return E_NOTIMPL;
}

static HRESULT WINAPI
ShellLink_CopyDataBlock( IShellLinkDataList* iface, DWORD dwSig, void** ppDataBlock )
{
2305 2306 2307 2308
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
    LPVOID block = NULL;
    HRESULT r = E_FAIL;

2309
    TRACE("%p %08x %p\n", iface, dwSig, ppDataBlock );
2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323

    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:
2324
        FIXME("valid but unhandled datablock %08x\n", dwSig);
2325 2326
        break;
    default:
2327
        ERR("unknown datablock %08x\n", dwSig);
2328 2329 2330
    }
    *ppDataBlock = block;
    return r;
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
}

static HRESULT WINAPI
ShellLink_RemoveDataBlock( IShellLinkDataList* iface, DWORD dwSig )
{
    FIXME("\n");
    return E_NOTIMPL;
}

static HRESULT WINAPI
ShellLink_GetFlags( IShellLinkDataList* iface, DWORD* pdwFlags )
{
2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
    IShellLinkImpl *This = impl_from_IShellLinkDataList(iface);
    DWORD flags = 0;

    FIXME("%p %p\n", This, pdwFlags );

    /* 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;
2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
}

static HRESULT WINAPI
ShellLink_SetFlags( IShellLinkDataList* iface, DWORD dwFlags )
{
    FIXME("\n");
    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
};
2383 2384 2385 2386

static HRESULT WINAPI
ShellLink_ExtInit_QueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
{
2387
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2388 2389 2390 2391 2392 2393
    return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
}

static ULONG WINAPI
ShellLink_ExtInit_AddRef( IShellExtInit* iface )
{
2394
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2395 2396 2397 2398 2399 2400
    return IShellLinkA_AddRef((IShellLinkA*)This);
}

static ULONG WINAPI
ShellLink_ExtInit_Release( IShellExtInit* iface )
{
2401
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2402
    return ShellLink_Release( This );
2403 2404
}

2405 2406 2407 2408 2409
/**************************************************************************
 * ShellLink implementation of IShellExtInit::Initialize()
 *
 * Loads the shelllink from the dataobject the shell is pointing to.
 */
2410 2411 2412 2413
static HRESULT WINAPI
ShellLink_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
                              IDataObject *pdtobj, HKEY hkeyProgID )
{
2414
    IShellLinkImpl *This = impl_from_IShellExtInit(iface);
2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453
    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 )
        {
            IPersistFile *pf = (IPersistFile*) &This->lpvtblPersistFile;

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

    return r;
2454 2455 2456 2457 2458 2459 2460 2461 2462
}

static const IShellExtInitVtbl eivt =
{
    ShellLink_ExtInit_QueryInterface,
    ShellLink_ExtInit_AddRef,
    ShellLink_ExtInit_Release,
    ShellLink_ExtInit_Initialize
};
2463 2464 2465 2466

static HRESULT WINAPI
ShellLink_ContextMenu_QueryInterface( IContextMenu* iface, REFIID riid, void** ppvObject )
{
2467
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2468 2469 2470 2471 2472 2473
    return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
}

static ULONG WINAPI
ShellLink_ContextMenu_AddRef( IContextMenu* iface )
{
2474
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2475 2476 2477 2478 2479 2480
    return IShellLinkA_AddRef((IShellLinkA*)This);
}

static ULONG WINAPI
ShellLink_ContextMenu_Release( IContextMenu* iface )
{
2481
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2482
    return ShellLink_Release( This );
2483 2484 2485 2486 2487 2488
}

static HRESULT WINAPI
ShellLink_QueryContextMenu( IContextMenu* iface, HMENU hmenu, UINT indexMenu,
                            UINT idCmdFirst, UINT idCmdLast, UINT uFlags )
{
2489
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2490
    static WCHAR szOpen[] = { 'O','p','e','n',0 };
2491 2492
    MENUITEMINFOW mii;
    int id = 1;
2493

2494
    TRACE("%p %p %u %u %u %u\n", This,
2495 2496
          hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );

2497 2498 2499 2500 2501 2502
    if ( !hmenu )
        return E_INVALIDARG;

    memset( &mii, 0, sizeof mii );
    mii.cbSize = sizeof mii;
    mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
2503
    mii.dwTypeData = szOpen;
2504 2505 2506 2507 2508 2509 2510 2511 2512
    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 );
2513 2514
}

2515 2516
static LPWSTR
shelllink_get_msi_component_path( LPWSTR component )
2517
{
2518
    LPWSTR path;
2519
    DWORD r, sz = 0;
2520

2521 2522
    r = CommandLineFromMsiDescriptor( component, NULL, &sz );
    if (r != ERROR_SUCCESS)
2523
         return NULL;
2524

2525 2526 2527 2528
    sz++;
    path = HeapAlloc( GetProcessHeap(), 0, sz*sizeof(WCHAR) );
    r = CommandLineFromMsiDescriptor( component, path, &sz );
    if (r != ERROR_SUCCESS)
2529
    {
2530 2531
        HeapFree( GetProcessHeap(), 0, path );
        path = NULL;
2532 2533 2534 2535 2536 2537 2538
    }

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

    return path;
}

2539 2540 2541
static HRESULT WINAPI
ShellLink_InvokeCommand( IContextMenu* iface, LPCMINVOKECOMMANDINFO lpici )
{
2542
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
Mike McCormack's avatar
Mike McCormack committed
2543
    static const WCHAR szOpen[] = { 'O','p','e','n',0 };
2544 2545 2546
    SHELLEXECUTEINFOW sei;
    HWND hwnd = NULL; /* FIXME: get using interface set from IObjectWithSite */
    LPWSTR args = NULL;
2547
    LPWSTR path = NULL;
2548
    HRESULT r;
2549

2550
    TRACE("%p %p\n", This, lpici );
2551

2552 2553 2554 2555 2556
    if ( lpici->cbSize < sizeof (CMINVOKECOMMANDINFO) )
        return E_INVALIDARG;

    if ( lpici->lpVerb != MAKEINTRESOURCEA(This->iIdOpen) )
    {
2557
        ERR("Unknown id %p != %d\n", lpici->lpVerb, This->iIdOpen );
2558 2559 2560 2561 2562 2563 2564
        return E_INVALIDARG;
    }

    r = IShellLinkW_Resolve( (IShellLinkW*)&(This->lpvtblw), hwnd, 0 );
    if ( FAILED( r ) )
        return r;

2565
    if ( This->sComponent )
2566
    {
2567 2568 2569
        path = shelllink_get_msi_component_path( This->sComponent );
        if (!path)
            return E_FAIL;
2570
    }
2571 2572
    else
        path = strdupW( This->sPath );
2573 2574 2575 2576 2577

    if ( lpici->cbSize == sizeof (CMINVOKECOMMANDINFOEX) &&
         ( lpici->fMask & CMIC_MASK_UNICODE ) )
    {
        LPCMINVOKECOMMANDINFOEX iciex = (LPCMINVOKECOMMANDINFOEX) lpici;
Mike McCormack's avatar
Mike McCormack committed
2578
        DWORD len = 2;
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589

        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
2590 2591 2592
        {
            static const WCHAR space[] = { ' ', 0 };
            lstrcatW( args, space );
2593
            lstrcatW( args, iciex->lpParametersW );
Mike McCormack's avatar
Mike McCormack committed
2594
        }
2595 2596 2597 2598
    }

    memset( &sei, 0, sizeof sei );
    sei.cbSize = sizeof sei;
2599
    sei.fMask = SEE_MASK_UNICODE | (lpici->fMask & (SEE_MASK_NOASYNC|SEE_MASK_ASYNCOK|SEE_MASK_FLAG_NO_UI));
2600
    sei.lpFile = path;
2601 2602 2603 2604
    sei.nShow = This->iShowCmd;
    sei.lpIDList = This->pPidl;
    sei.lpDirectory = This->sWorkDir;
    sei.lpParameters = args;
Mike McCormack's avatar
Mike McCormack committed
2605
    sei.lpVerb = szOpen;
2606 2607 2608 2609 2610 2611 2612

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

    HeapFree( GetProcessHeap(), 0, args );
2613
    HeapFree( GetProcessHeap(), 0, path );
2614 2615

    return r;
2616 2617 2618
}

static HRESULT WINAPI
Kevin Koltzau's avatar
Kevin Koltzau committed
2619
ShellLink_GetCommandString( IContextMenu* iface, UINT_PTR idCmd, UINT uType,
2620 2621
                            UINT* pwReserved, LPSTR pszName, UINT cchMax )
{
2622
    IShellLinkImpl *This = impl_from_IContextMenu(iface);
2623

2624
    FIXME("%p %lu %u %p %p %u\n", This,
2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638
          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
};
2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694

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 );
    This->site = punk;

    return S_OK;
}

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