dlls/shell32/shelllink.c

   1 /*
   2  *
   3  *      Copyright 1997  Marcus Meissner
   4  *      Copyright 1998  Juergen Schmied
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * NOTES
  21  *   Nearly complete informations about the binary formats
  22  *   of .lnk files available at http://www.wotsit.org
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <ctype.h>
  30 #include <string.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #ifdef HAVE_UNISTD_H
  34 # include <unistd.h>
  35 #endif
  36 #include <errno.h>
  37 #include <limits.h>
  38 #ifdef HAVE_SYS_WAIT_H
  39 # include <sys/wait.h>
  40 #endif
  41 #include "wine/debug.h"
  42 #include "winerror.h"
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "winnls.h"
  46 #include "winreg.h"
  47
  48 #include "winuser.h"
  49 #include "wingdi.h"
  50 #include "shlobj.h"
  51 #include "undocshell.h"
  52
  53 #include "pidl.h"
  54 #include "shell32_main.h"
  55 #include "shlguid.h"
  56 #include "shlwapi.h"
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  59
  60 /* link file formats */
  61
  62 /* flag1: lnk elements: simple link has 0x0B */
  63 #define SCF_PIDL   1
  64 #define SCF_NORMAL 2
  65 #define SCF_DESCRIPTION 4
  66 #define SCF_RELATIVE 8
  67 #define SCF_WORKDIR 0x10
  68 #define SCF_ARGS 0x20
  69 #define SCF_CUSTOMICON 0x40
  70 #define SCF_UNICODE 0x80
  71
  72 #include "pshpack1.h"
  73
  74 typedef struct _LINK_HEADER
  75 {
  76         DWORD    dwSize;        /* 0x00 size of the header - 0x4c */
  77         GUID     MagicGuid;     /* 0x04 is CLSID_ShellLink */
  78         DWORD    dwFlags;       /* 0x14 describes elements following */
  79         DWORD    dwFileAttr;    /* 0x18 attributes of the target file */
  80         FILETIME Time1;         /* 0x1c */
  81         FILETIME Time2;         /* 0x24 */
  82         FILETIME Time3;         /* 0x2c */
  83         DWORD    dwFileLength;  /* 0x34 File length */
  84         DWORD    nIcon;         /* 0x38 icon number */
  85         DWORD   fStartup;       /* 0x3c startup type */
  86         DWORD   wHotKey;        /* 0x40 hotkey */
  87         DWORD   Unknown5;       /* 0x44 */
  88         DWORD   Unknown6;       /* 0x48 */
  89 } LINK_HEADER, * PLINK_HEADER;
  90
  91 #define SHLINK_LOCAL  0
  92 #define SHLINK_REMOTE 1
  93
  94 typedef struct _LOCATION_INFO
  95 {
  96     DWORD  dwTotalSize;
  97     DWORD  dwHeaderSize;
  98     DWORD  dwFlags;
  99     DWORD  dwVolTableOfs;
 100     DWORD  dwLocalPathOfs;
 101     DWORD  dwNetworkVolTableOfs;
 102     DWORD  dwFinalPathOfs;
 103 } LOCATION_INFO;
 104
 105 typedef struct _LOCAL_VOLUME_INFO
 106 {
 107     DWORD dwSize;
 108     DWORD dwType;
 109     DWORD dwVolSerial;
 110     DWORD dwVolLabelOfs;
 111 } LOCAL_VOLUME_INFO;
 112
 113 #include "poppack.h"
 114
 115 static IShellLinkAVtbl          slvt;
 116 static IShellLinkWVtbl          slvtw;
 117 static IPersistFileVtbl pfvt;
 118 static IPersistStreamVtbl       psvt;
 119
 120 /* IShellLink Implementation */
 121
 122 typedef struct
 123 {
 124         IShellLinkAVtbl    *lpVtbl;
 125         DWORD               ref;
 126
 127         IShellLinkWVtbl    *lpvtblw;
 128         IPersistFileVtbl   *lpvtblPersistFile;
 129         IPersistStreamVtbl *lpvtblPersistStream;
 130
 131         /* data structures according to the informations in the link */
 132         LPITEMIDLIST    pPidl;
 133         WORD            wHotKey;
 134         SYSTEMTIME      time1;
 135         SYSTEMTIME      time2;
 136         SYSTEMTIME      time3;
 137
 138         DWORD         iShowCmd;
 139         LPWSTR        sIcoPath;
 140         INT           iIcoNdx;
 141         LPWSTR        sPath;
 142         LPWSTR        sArgs;
 143         LPWSTR        sWorkDir;
 144         LPWSTR        sDescription;
 145         LPWSTR        sPathRel;
 146
 147         BOOL            bDirty;
 148 } IShellLinkImpl;
 149
 150 #define _IShellLinkW_Offset ((int)(&(((IShellLinkImpl*)0)->lpvtblw)))
 151 #define _ICOM_THIS_From_IShellLinkW(class, name) class* This = (class*)(((char*)name)-_IShellLinkW_Offset)
 152
 153 #define _IPersistFile_Offset ((int)(&(((IShellLinkImpl*)0)->lpvtblPersistFile)))
 154 #define _ICOM_THIS_From_IPersistFile(class, name) class* This = (class*)(((char*)name)-_IPersistFile_Offset)
 155
 156 #define _IPersistStream_Offset ((int)(&(((IShellLinkImpl*)0)->lpvtblPersistStream)))
 157 #define _ICOM_THIS_From_IPersistStream(class, name) class* This = (class*)(((char*)name)-_IPersistStream_Offset)
 158 #define _IPersistStream_From_ICOM_THIS(class, name) class* StreamThis = (class*)(((char*)name)+_IPersistStream_Offset)
 159
 160 static HRESULT ShellLink_UpdatePath(LPWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
 161
 162 /* strdup on the process heap */
 163 inline static LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
 164 {
 165     INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 166     LPWSTR p = HeapAlloc( heap, flags, len*sizeof (WCHAR) );
 167     if( !p )
 168         return p;
 169     MultiByteToWideChar( CP_ACP, 0, str, -1, p, len );
 170     return p;
 171 }
 172
 173
 174 /**************************************************************************
 175  *  IPersistFile_QueryInterface
 176  */
 177 static HRESULT WINAPI IPersistFile_fnQueryInterface(
 178         IPersistFile* iface,
 179         REFIID riid,
 180         LPVOID *ppvObj)
 181 {
 182         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 183
 184         TRACE("(%p)\n",This);
 185
 186         return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObj);
 187 }
 188
 189 /******************************************************************************
 190  * IPersistFile_AddRef
 191  */
 192 static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
 193 {
 194         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 195
 196         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 197
 198         return IShellLinkA_AddRef((IShellLinkA*)This);
 199 }
 200 /******************************************************************************
 201  * IPersistFile_Release
 202  */
 203 static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
 204 {
 205         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 206
 207         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 208
 209         return IShellLinkA_Release((IShellLinkA*)This);
 210 }
 211
 212 static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile* iface, CLSID *pClassID)
 213 {
 214         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 215         FIXME("(%p)\n",This);
 216         return NOERROR;
 217 }
 218 static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile* iface)
 219 {
 220         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 221
 222         TRACE("(%p)\n",This);
 223
 224         if (This->bDirty)
 225             return S_OK;
 226
 227         return S_FALSE;
 228 }
 229 static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR pszFileName, DWORD dwMode)
 230 {
 231         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 232         _IPersistStream_From_ICOM_THIS(IPersistStream, This);
 233         HRESULT r;
 234         IStream *stm;
 235
 236         TRACE("(%p, %s)\n",This, debugstr_w(pszFileName));
 237
 238         r = CreateStreamOnFile(pszFileName, dwMode, &stm);
 239         if( SUCCEEDED( r ) )
 240         {
 241             r = IPersistStream_Load(StreamThis, stm);
 242             ShellLink_UpdatePath(This->sPathRel, pszFileName, This->sWorkDir, &This->sPath);
 243             IStream_Release( stm );
 244             This->bDirty = FALSE;
 245         }
 246
 247         return r;
 248 }
 249
 250 static BOOL StartLinkProcessor( LPCOLESTR szLink )
 251 {
 252     static const WCHAR szFormat[] = {'w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',
 253                               ' ','-','r',' ','"','%','s','"',0 };
 254     LONG len;
 255     LPWSTR buffer;
 256     STARTUPINFOW si;
 257     PROCESS_INFORMATION pi;
 258
 259     len = sizeof(szFormat) + lstrlenW( szLink ) * sizeof(WCHAR);
 260     buffer = HeapAlloc( GetProcessHeap(), 0, len );
 261     if( !buffer )
 262         return FALSE;
 263
 264     wsprintfW( buffer, szFormat, szLink );
 265
 266     TRACE("starting %s\n",debugstr_w(buffer));
 267
 268     memset(&si, 0, sizeof(si));
 269     si.cb = sizeof(si);
 270     if (!CreateProcessW( NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) return FALSE;
 271
 272     /* wait for a while to throttle the creation of linker processes */
 273     if( WAIT_OBJECT_0 != WaitForSingleObject( pi.hProcess, 10000 ) )
 274         WARN("Timed out waiting for shell linker\n");
 275
 276     CloseHandle( pi.hProcess );
 277     CloseHandle( pi.hThread );
 278
 279     return TRUE;
 280 }
 281
 282 static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR pszFileName, BOOL fRemember)
 283 {
 284     _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 285     _IPersistStream_From_ICOM_THIS(IPersistStream, This);
 286     HRESULT r;
 287     IStream *stm;
 288
 289     TRACE("(%p)->(%s)\n",This,debugstr_w(pszFileName));
 290
 291     if (!pszFileName || !This->sPath)
 292         return E_FAIL;
 293
 294     r = CreateStreamOnFile(pszFileName, STGM_READWRITE | STGM_CREATE, &stm);
 295     if( SUCCEEDED( r ) )
 296     {
 297         r = IPersistStream_Save(StreamThis, stm, FALSE);
 298         IStream_Release( stm );
 299
 300         if( SUCCEEDED( r ) )
 301         {
 302             StartLinkProcessor( pszFileName );
 303
 304             This->bDirty = FALSE;
 305         }
 306         else
 307         {
 308             DeleteFileW( pszFileName );
 309             WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
 310         }
 311     }
 312
 313     return r;
 314 }
 315
 316 static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR pszFileName)
 317 {
 318         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 319         FIXME("(%p)->(%s)\n",This,debugstr_w(pszFileName));
 320         return NOERROR;
 321 }
 322 static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile* iface, LPOLESTR *ppszFileName)
 323 {
 324         _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
 325         FIXME("(%p)\n",This);
 326         return NOERROR;
 327 }
 328
 329 static IPersistFileVtbl pfvt =
 330 {
 331         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 332         IPersistFile_fnQueryInterface,
 333         IPersistFile_fnAddRef,
 334         IPersistFile_fnRelease,
 335         IPersistFile_fnGetClassID,
 336         IPersistFile_fnIsDirty,
 337         IPersistFile_fnLoad,
 338         IPersistFile_fnSave,
 339         IPersistFile_fnSaveCompleted,
 340         IPersistFile_fnGetCurFile
 341 };
 342
 343 /************************************************************************
 344  * IPersistStream_QueryInterface
 345  */
 346 static HRESULT WINAPI IPersistStream_fnQueryInterface(
 347         IPersistStream* iface,
 348         REFIID     riid,
 349         VOID**     ppvoid)
 350 {
 351         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 352
 353         TRACE("(%p)\n",This);
 354
 355         return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvoid);
 356 }
 357
 358 /************************************************************************
 359  * IPersistStream_Release
 360  */
 361 static ULONG WINAPI IPersistStream_fnRelease(
 362         IPersistStream* iface)
 363 {
 364         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 365
 366         TRACE("(%p)\n",This);
 367
 368         return IShellLinkA_Release((IShellLinkA*)This);
 369 }
 370
 371 /************************************************************************
 372  * IPersistStream_AddRef
 373  */
 374 static ULONG WINAPI IPersistStream_fnAddRef(
 375         IPersistStream* iface)
 376 {
 377         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 378
 379         TRACE("(%p)\n",This);
 380
 381         return IShellLinkA_AddRef((IShellLinkA*)This);
 382 }
 383
 384 /************************************************************************
 385  * IPersistStream_GetClassID
 386  *
 387  */
 388 static HRESULT WINAPI IPersistStream_fnGetClassID(
 389         IPersistStream* iface,
 390         CLSID* pClassID)
 391 {
 392         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 393
 394         TRACE("(%p)\n", This);
 395
 396         if (pClassID==0)
 397           return E_POINTER;
 398
 399 /*      memcpy(pClassID, &CLSID_???, sizeof(CLSID_???)); */
 400
 401         return S_OK;
 402 }
 403
 404 /************************************************************************
 405  * IPersistStream_IsDirty (IPersistStream)
 406  */
 407 static HRESULT WINAPI IPersistStream_fnIsDirty(
 408         IPersistStream*  iface)
 409 {
 410         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 411
 412         TRACE("(%p)\n", This);
 413
 414         return S_OK;
 415 }
 416
 417
 418 static HRESULT Stream_LoadString( IStream* stm, BOOL unicode, LPWSTR *pstr )
 419 {
 420     DWORD count;
 421     USHORT len;
 422     LPVOID temp;
 423     LPWSTR str;
 424     HRESULT r;
 425
 426     TRACE("%p\n", stm);
 427
 428     count = 0;
 429     r = IStream_Read(stm, &len, sizeof(len), &count);
 430     if ( FAILED (r) || ( count != sizeof(len) ) )
 431         return E_FAIL;
 432
 433     if( unicode )
 434         len *= sizeof (WCHAR);
 435
 436     TRACE("reading %d\n", len);
 437     temp = HeapAlloc(GetProcessHeap(), 0, len+sizeof(WCHAR));
 438     if( !temp )
 439         return E_OUTOFMEMORY;
 440     count = 0;
 441     r = IStream_Read(stm, temp, len, &count);
 442     if( FAILED (r) || ( count != len ) )
 443     {
 444         HeapFree( GetProcessHeap(), 0, temp );
 445         return E_FAIL;
 446     }
 447
 448     TRACE("read %s\n", debugstr_an(temp,len));
 449
 450     /* convert to unicode if necessary */
 451     if( !unicode )
 452     {
 453         count = MultiByteToWideChar( CP_ACP, 0, (LPSTR) temp, len, NULL, 0 );
 454         str = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
 455         if( str )
 456             MultiByteToWideChar( CP_ACP, 0, (LPSTR) temp, len, str, count );
 457         HeapFree( GetProcessHeap(), 0, temp );
 458     }
 459     else
 460     {
 461         count /= 2;
 462         str = (LPWSTR) temp;
 463     }
 464     str[count] = 0;
 465
 466     *pstr = str;
 467
 468     return S_OK;
 469 }
 470
 471 static HRESULT Stream_LoadLocation( IStream* stm )
 472 {
 473     DWORD size;
 474     ULONG count;
 475     HRESULT r;
 476     LOCATION_INFO *loc;
 477
 478     TRACE("%p\n",stm);
 479
 480     r = IStream_Read( stm, &size, sizeof(size), &count );
 481     if( FAILED( r ) )
 482         return r;
 483     if( count != sizeof(loc->dwTotalSize) )
 484         return E_FAIL;
 485
 486     loc = HeapAlloc( GetProcessHeap(), 0, size );
 487     if( ! loc )
 488         return E_OUTOFMEMORY;
 489
 490     r = IStream_Read( stm, &loc->dwHeaderSize, size-sizeof(size), &count );
 491     if( FAILED( r ) )
 492         goto end;
 493     if( count != (size - sizeof(size)) )
 494     {
 495         r = E_FAIL;
 496         goto end;
 497     }
 498     loc->dwTotalSize = size;
 499
 500     TRACE("Read %ld bytes\n",count);
 501
 502     /* FIXME: do something useful with it */
 503     HeapFree( GetProcessHeap(), 0, loc );
 504
 505     return S_OK;
 506 end:
 507     HeapFree( GetProcessHeap(), 0, loc );
 508     return r;
 509 }
 510
 511 /************************************************************************
 512  * IPersistStream_Load (IPersistStream)
 513  */
 514 static HRESULT WINAPI IPersistStream_fnLoad(
 515         IPersistStream*  iface,
 516     IStream*         stm)
 517 {
 518     LINK_HEADER hdr;
 519     ULONG    dwBytesRead;
 520     BOOL     unicode;
 521     WCHAR    sTemp[MAX_PATH];
 522     HRESULT  r;
 523
 524     _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 525
 526     TRACE("(%p)(%p)\n", This, stm);
 527
 528     if( !stm )
 529           return STG_E_INVALIDPOINTER;
 530
 531     dwBytesRead = 0;
 532     r = IStream_Read(stm, &hdr, sizeof(hdr), &dwBytesRead);
 533     if( FAILED( r ) )
 534         return r;
 535
 536     if( dwBytesRead != sizeof(hdr))
 537         return E_FAIL;
 538     if( hdr.dwSize != sizeof(hdr))
 539         return E_FAIL;
 540     if( !IsEqualIID(&hdr.MagicGuid, &CLSID_ShellLink) )
 541         return E_FAIL;
 542
 543     /* if( hdr.dwFlags & SCF_PIDL ) */  /* FIXME: seems to always have a PIDL */
 544     {
 545         r = ILLoadFromStream( stm, &This->pPidl );
 546         if( FAILED( r ) )
 547             return r;
 548     }
 549     This->wHotKey = (WORD)hdr.wHotKey;
 550     This->iIcoNdx = hdr.nIcon;
 551     FileTimeToSystemTime (&hdr.Time1, &This->time1);
 552     FileTimeToSystemTime (&hdr.Time2, &This->time2);
 553     FileTimeToSystemTime (&hdr.Time3, &This->time3);
 554 #if 1
 555     GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&This->time1, NULL, sTemp, 256);
 556     TRACE("-- time1: %s\n", debugstr_w(sTemp) );
 557     GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&This->time2, NULL, sTemp, 256);
 558     TRACE("-- time1: %s\n", debugstr_w(sTemp) );
 559     GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&This->time3, NULL, sTemp, 256);
 560     TRACE("-- time1: %s\n", debugstr_w(sTemp) );
 561     pdump (This->pPidl);
 562 #endif
 563     if( hdr.dwFlags & SCF_NORMAL )
 564         r = Stream_LoadLocation( stm );
 565     if( FAILED( r ) )
 566         goto end;
 567     unicode = hdr.dwFlags & SCF_UNICODE;
 568     if( hdr.dwFlags & SCF_DESCRIPTION )
 569     {
 570         r = Stream_LoadString( stm, unicode, &This->sDescription );
 571         TRACE("Description  -> %s\n",debugstr_w(This->sDescription));
 572     }
 573     if( FAILED( r ) )
 574         goto end;
 575
 576     if( hdr.dwFlags & SCF_RELATIVE )
 577     {
 578         r = Stream_LoadString( stm, unicode, &This->sPathRel );
 579         TRACE("Relative Path-> %s\n",debugstr_w(This->sPathRel));
 580     }
 581     if( FAILED( r ) )
 582         goto end;
 583
 584     if( hdr.dwFlags & SCF_WORKDIR )
 585           {
 586         r = Stream_LoadString( stm, unicode, &This->sWorkDir );
 587         TRACE("Working Dir  -> %s\n",debugstr_w(This->sWorkDir));
 588     }
 589     if( FAILED( r ) )
 590         goto end;
 591
 592     if( hdr.dwFlags & SCF_ARGS )
 593     {
 594         r = Stream_LoadString( stm, unicode, &This->sArgs );
 595         TRACE("Working Dir  -> %s\n",debugstr_w(This->sArgs));
 596     }
 597     if( FAILED( r ) )
 598         goto end;
 599
 600     if( hdr.dwFlags & SCF_CUSTOMICON )
 601     {
 602         r = Stream_LoadString( stm, unicode, &This->sIcoPath );
 603         TRACE("Icon file    -> %s\n",debugstr_w(This->sIcoPath));
 604     }
 605     if( FAILED( r ) )
 606         goto end;
 607
 608     TRACE("OK\n");
 609
 610     pdump (This->pPidl);
 611
 612     return S_OK;
 613 end:
 614     return r;
 615 }
 616
 617 /************************************************************************
 618  * Stream_WriteString
 619  *
 620  * Helper function for IPersistStream_Save. Writes a unicode string
 621  *  with terminating nul byte to a stream, preceded by the its length.
 622  */
 623 static HRESULT Stream_WriteString( IStream* stm, LPCWSTR str )
 624 {
 625     USHORT len = lstrlenW( str ) + 1;
 626     DWORD count;
 627     HRESULT r;
 628
 629     r = IStream_Write( stm, &len, sizeof(len), &count );
 630     if( FAILED( r ) )
 631         return r;
 632
 633     len *= sizeof(WCHAR);
 634
 635     r = IStream_Write( stm, str, len, &count );
 636     if( FAILED( r ) )
 637         return r;
 638
 639     return S_OK;
 640 }
 641
 642 static HRESULT Stream_WriteLocationInfo( IStream* stm, LPCWSTR filename )
 643 {
 644     LOCATION_INFO loc;
 645     ULONG count;
 646
 647     FIXME("writing empty location info\n");
 648
 649     memset( &loc, 0, sizeof(loc) );
 650     loc.dwTotalSize = sizeof(loc) - sizeof(loc.dwTotalSize);
 651
 652     /* FIXME: fill this in */
 653
 654     return IStream_Write( stm, &loc, loc.dwTotalSize, &count );
 655 }
 656
 657 /************************************************************************
 658  * IPersistStream_Save (IPersistStream)
 659  *
 660  * FIXME: makes assumptions about byte order
 661  */
 662 static HRESULT WINAPI IPersistStream_fnSave(
 663         IPersistStream*  iface,
 664         IStream*         stm,
 665         BOOL             fClearDirty)
 666 {
 667     static const WCHAR wOpen[] = {'o','p','e','n',0};
 668
 669     LINK_HEADER header;
 670     WCHAR   exePath[MAX_PATH];
 671     ULONG   count;
 672     HRESULT r;
 673
 674     _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 675
 676     TRACE("(%p) %p %x\n", This, stm, fClearDirty);
 677
 678     *exePath = '\0';
 679
 680     if (This->sPath)
 681     {
 682         SHELL_FindExecutable(NULL, This->sPath, wOpen, exePath, MAX_PATH, NULL, NULL, NULL, NULL);
 683         /*
 684          * windows can create lnk files to executables that do not exist yet
 685          * so if the executable does not exist the just trust the path they
 686          * gave us
 687          */
 688         if( !*exePath ) strcpyW(exePath,This->sPath);
 689     }
 690
 691     /* if there's no PIDL, generate one */
 692     if( ! This->pPidl ) This->pPidl = ILCreateFromPathW(exePath);
 693
 694     memset(&header, 0, sizeof(header));
 695     header.dwSize = sizeof(header);
 696     memcpy(&header.MagicGuid, &CLSID_ShellLink, sizeof(header.MagicGuid) );
 697
 698     header.wHotKey = This->wHotKey;
 699     header.nIcon = This->iIcoNdx;
 700     header.dwFlags = SCF_UNICODE;   /* strings are in unicode */
 701     header.dwFlags |= SCF_NORMAL;   /* how do we determine this ? */
 702     if( This->pPidl )
 703         header.dwFlags |= SCF_PIDL;
 704     if( This->sDescription )
 705         header.dwFlags |= SCF_DESCRIPTION;
 706     if( This->sWorkDir )
 707         header.dwFlags |= SCF_WORKDIR;
 708     if( This->sArgs )
 709         header.dwFlags |= SCF_ARGS;
 710     if( This->sIcoPath )
 711         header.dwFlags |= SCF_CUSTOMICON;
 712
 713     SystemTimeToFileTime ( &This->time1, &header.Time1 );
 714     SystemTimeToFileTime ( &This->time2, &header.Time2 );
 715     SystemTimeToFileTime ( &This->time3, &header.Time3 );
 716
 717     /* write the Shortcut header */
 718     r = IStream_Write( stm, &header, sizeof(header), &count );
 719     if( FAILED( r ) )
 720     {
 721         ERR("Write failed at %d\n",__LINE__);
 722         return r;
 723     }
 724
 725     TRACE("Writing pidl \n");
 726
 727     /* write the PIDL to the shortcut */
 728     if( This->pPidl )
 729     {
 730         r = ILSaveToStream( stm, This->pPidl );
 731         if( FAILED( r ) )
 732         {
 733             ERR("Failed to write PIDL at %d\n",__LINE__);
 734             return r;
 735         }
 736     }
 737
 738     Stream_WriteLocationInfo( stm, exePath );
 739
 740     TRACE("Description = %s\n", debugstr_w(This->sDescription));
 741     if( This->sDescription )
 742         r = Stream_WriteString( stm, This->sDescription );
 743
 744     if( This->sPathRel )
 745         r = Stream_WriteString( stm, This->sPathRel );
 746
 747     if( This->sWorkDir )
 748         r = Stream_WriteString( stm, This->sWorkDir );
 749
 750     if( This->sArgs )
 751         r = Stream_WriteString( stm, This->sArgs );
 752
 753     if( This->sIcoPath )
 754         r = Stream_WriteString( stm, This->sIcoPath );
 755
 756     return S_OK;
 757 }
 758
 759 /************************************************************************
 760  * IPersistStream_GetSizeMax (IPersistStream)
 761  */
 762 static HRESULT WINAPI IPersistStream_fnGetSizeMax(
 763         IPersistStream*  iface,
 764         ULARGE_INTEGER*  pcbSize)
 765 {
 766         _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
 767
 768         TRACE("(%p)\n", This);
 769
 770         return E_NOTIMPL;
 771 }
 772
 773 static IPersistStreamVtbl psvt =
 774 {
 775         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 776         IPersistStream_fnQueryInterface,
 777         IPersistStream_fnAddRef,
 778         IPersistStream_fnRelease,
 779         IPersistStream_fnGetClassID,
 780         IPersistStream_fnIsDirty,
 781         IPersistStream_fnLoad,
 782         IPersistStream_fnSave,
 783         IPersistStream_fnGetSizeMax
 784 };
 785
 786 /**************************************************************************
 787  *        IShellLink_Constructor
 788  */
 789 HRESULT WINAPI IShellLink_Constructor (
 790         IUnknown * pUnkOuter,
 791         REFIID riid,
 792         LPVOID * ppv)
 793 {
 794         IShellLinkImpl * sl;
 795
 796         TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));
 797
 798         *ppv = NULL;
 799
 800         if(pUnkOuter) return CLASS_E_NOAGGREGATION;
 801         sl = (IShellLinkImpl *) LocalAlloc(GMEM_ZEROINIT,sizeof(IShellLinkImpl));
 802         if (!sl) return E_OUTOFMEMORY;
 803
 804         sl->ref = 1;
 805         sl->lpVtbl = &slvt;
 806         sl->lpvtblw = &slvtw;
 807         sl->lpvtblPersistFile = &pfvt;
 808         sl->lpvtblPersistStream = &psvt;
 809         sl->iShowCmd = SW_SHOWNORMAL;
 810         sl->bDirty = FALSE;
 811
 812         TRACE("(%p)->()\n",sl);
 813
 814         if (IsEqualIID(riid, &IID_IUnknown) ||
 815             IsEqualIID(riid, &IID_IShellLinkA))
 816             *ppv = sl;
 817         else if (IsEqualIID(riid, &IID_IShellLinkW))
 818             *ppv = &(sl->lpvtblw);
 819         else {
 820             LocalFree((HLOCAL)sl);
 821             ERR("E_NOINTERFACE\n");
 822             return E_NOINTERFACE;
 823         }
 824
 825         return S_OK;
 826 }
 827
 828
 829 static BOOL SHELL_ExistsFileW(LPCWSTR path)
 830 {
 831     HANDLE hfile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
 832
 833     if (hfile != INVALID_HANDLE_VALUE) {
 834         CloseHandle(hfile);
 835         return TRUE;
 836     } else
 837         return FALSE;
 838 }
 839
 840 /**************************************************************************
 841  *  ShellLink_UpdatePath
 842  *      update absolute path in sPath using relative path in sPathRel
 843  */
 844 static HRESULT ShellLink_UpdatePath(LPWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath)
 845 {
 846     if (!path || !psPath)
 847         return E_INVALIDARG;
 848
 849     if (!*psPath && sPathRel) {
 850         WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
 851         LPWSTR final = NULL;
 852
 853         /* first try if [directory of link file] + [relative path] finds an existing file */
 854
 855         GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
 856         if( !final )
 857             final = buffer;
 858         lstrcpyW(final, sPathRel);
 859
 860         *abs_path = '\0';
 861
 862         if (SHELL_ExistsFileW(buffer)) {
 863             if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
 864                 lstrcpyW(abs_path, buffer);
 865         } else {
 866             /* try if [working directory] + [relative path] finds an existing file */
 867             if (sWorkDir) {
 868                 lstrcpyW(buffer, sWorkDir);
 869                 lstrcpyW(PathAddBackslashW(buffer), sPathRel);
 870
 871                 if (SHELL_ExistsFileW(buffer))
 872                     if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
 873                         lstrcpyW(abs_path, buffer);
 874             }
 875         }
 876
 877         /* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */
 878         if (!*abs_path)
 879             lstrcpyW(abs_path, sPathRel);
 880
 881         *psPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(abs_path)+1)*sizeof(WCHAR));
 882         if (!*psPath)
 883             return E_OUTOFMEMORY;
 884
 885         lstrcpyW(*psPath, abs_path);
 886     }
 887
 888     return S_OK;
 889 }
 890
 891 /**************************************************************************
 892  *        IShellLink_ConstructFromFile
 893  */
 894 HRESULT WINAPI IShellLink_ConstructFromFile (
 895         IUnknown* pUnkOuter,
 896         REFIID riid,
 897         LPCITEMIDLIST pidl,
 898         LPVOID* ppv
 899 )
 900 {
 901     IShellLinkW* psl;
 902
 903     HRESULT hr = IShellLink_Constructor(NULL, riid, (LPVOID*)&psl);
 904
 905     if (SUCCEEDED(hr)) {
 906         IPersistFile* ppf;
 907
 908         *ppv = NULL;
 909
 910         hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);
 911
 912         if (SUCCEEDED(hr)) {
 913             WCHAR path[MAX_PATH];
 914
 915             if (SHGetPathFromIDListW(pidl, path))
 916                 hr = IPersistFile_Load(ppf, path, 0);
 917             else
 918                 hr = E_FAIL;
 919
 920             if (SUCCEEDED(hr))
 921                 *ppv = (IUnknown*) psl;
 922
 923             IPersistFile_Release(ppf);
 924         }
 925
 926         if (!*ppv)
 927             IShellLinkW_Release(psl);
 928     }
 929
 930     return hr;
 931 }
 932
 933 /**************************************************************************
 934  *  IShellLinkA_QueryInterface
 935  */
 936 static HRESULT WINAPI IShellLinkA_fnQueryInterface( IShellLinkA * iface, REFIID riid,  LPVOID *ppvObj)
 937 {
 938         ICOM_THIS(IShellLinkImpl, iface);
 939
 940         TRACE("(%p)->(\n\tIID:\t%s)\n",This,debugstr_guid(riid));
 941
 942         *ppvObj = NULL;
 943
 944         if(IsEqualIID(riid, &IID_IUnknown) ||
 945            IsEqualIID(riid, &IID_IShellLinkA))
 946         {
 947           *ppvObj = This;
 948         }
 949         else if(IsEqualIID(riid, &IID_IShellLinkW))
 950         {
 951           *ppvObj = (IShellLinkW *)&(This->lpvtblw);
 952         }
 953         else if(IsEqualIID(riid, &IID_IPersistFile))
 954         {
 955           *ppvObj = (IPersistFile *)&(This->lpvtblPersistFile);
 956         }
 957         else if(IsEqualIID(riid, &IID_IPersistStream))
 958         {
 959           *ppvObj = (IPersistStream *)&(This->lpvtblPersistStream);
 960         }
 961
 962         if(*ppvObj)
 963         {
 964           IUnknown_AddRef((IUnknown*)(*ppvObj));
 965           TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
 966           return S_OK;
 967         }
 968         TRACE("-- Interface: E_NOINTERFACE\n");
 969         return E_NOINTERFACE;
 970 }
 971 /******************************************************************************
 972  * IShellLinkA_AddRef
 973  */
 974 static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA * iface)
 975 {
 976         ICOM_THIS(IShellLinkImpl, iface);
 977
 978         TRACE("(%p)->(count=%lu)\n",This,This->ref);
 979
 980         return ++(This->ref);
 981 }
 982 /******************************************************************************
 983  *      IShellLinkA_Release
 984  */
 985 static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA * iface)
 986 {
 987     ICOM_THIS(IShellLinkImpl, iface);
 988
 989     TRACE("(%p)->(count=%lu)\n",This,This->ref);
 990
 991     if (--(This->ref))
 992         return This->ref;
 993
 994     TRACE("-- destroying IShellLink(%p)\n",This);
 995
 996     if (This->sIcoPath)
 997         HeapFree(GetProcessHeap(), 0, This->sIcoPath);
 998
 999     if (This->sArgs)
1000         HeapFree(GetProcessHeap(), 0, This->sArgs);
1001
1002     if (This->sWorkDir)
1003         HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1004
1005     if (This->sDescription)
1006         HeapFree(GetProcessHeap(), 0, This->sDescription);
1007
1008     if (This->sPath)
1009         HeapFree(GetProcessHeap(),0,This->sPath);
1010
1011     if (This->pPidl)
1012         ILFree(This->pPidl);
1013
1014     LocalFree((HANDLE)This);
1015
1016     return 0;
1017 }
1018
1019 static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA * iface, LPSTR pszFile,
1020                   INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags)
1021 {
1022     ICOM_THIS(IShellLinkImpl, iface);
1023
1024     TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%lu)(%s)\n",
1025           This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1026
1027     if( cchMaxPath )
1028         pszFile[0] = 0;
1029     if (This->sPath)
1030         WideCharToMultiByte( CP_ACP, 0, This->sPath, -1,
1031                              pszFile, cchMaxPath, NULL, NULL);
1032
1033     return NOERROR;
1034 }
1035
1036 static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA * iface, LPITEMIDLIST * ppidl)
1037 {
1038         ICOM_THIS(IShellLinkImpl, iface);
1039
1040         TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1041
1042         *ppidl = ILClone(This->pPidl);
1043
1044         return NOERROR;
1045 }
1046
1047 static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA * iface, LPCITEMIDLIST pidl)
1048 {
1049     ICOM_THIS(IShellLinkImpl, iface);
1050
1051     TRACE("(%p)->(pidl=%p)\n",This, pidl);
1052
1053     if (This->pPidl)
1054         ILFree(This->pPidl);
1055     This->pPidl = ILClone (pidl);
1056     This->bDirty = TRUE;
1057
1058     return S_OK;
1059 }
1060
1061 static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA * iface, LPSTR pszName,INT cchMaxName)
1062 {
1063     ICOM_THIS(IShellLinkImpl, iface);
1064
1065     TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1066
1067     if( cchMaxName )
1068         pszName[0] = 0;
1069     if( This->sDescription )
1070         WideCharToMultiByte( CP_ACP, 0, This->sDescription, -1,
1071             pszName, cchMaxName, NULL, NULL);
1072
1073     return S_OK;
1074 }
1075 static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA * iface, LPCSTR pszName)
1076 {
1077     ICOM_THIS(IShellLinkImpl, iface);
1078
1079     TRACE("(%p)->(pName=%s)\n", This, pszName);
1080
1081     if (This->sDescription)
1082         HeapFree(GetProcessHeap(), 0, This->sDescription);
1083     This->sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
1084     if ( !This->sDescription )
1085         return E_OUTOFMEMORY;
1086
1087     This->bDirty = TRUE;
1088
1089     return S_OK;
1090 }
1091
1092 static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA * iface, LPSTR pszDir,INT cchMaxPath)
1093 {
1094     ICOM_THIS(IShellLinkImpl, iface);
1095
1096     TRACE("(%p)->(%p len=%u)\n", This, pszDir, cchMaxPath);
1097
1098     if( cchMaxPath )
1099         pszDir[0] = 0;
1100     if( This->sWorkDir )
1101         WideCharToMultiByte( CP_ACP, 0, This->sWorkDir, -1,
1102                              pszDir, cchMaxPath, NULL, NULL);
1103
1104     return S_OK;
1105 }
1106
1107 static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA * iface, LPCSTR pszDir)
1108 {
1109     ICOM_THIS(IShellLinkImpl, iface);
1110
1111     TRACE("(%p)->(dir=%s)\n",This, pszDir);
1112
1113     if (This->sWorkDir)
1114         HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1115     This->sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
1116     if ( !This->sWorkDir )
1117         return E_OUTOFMEMORY;
1118
1119     This->bDirty = TRUE;
1120
1121     return S_OK;
1122 }
1123
1124 static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA * iface, LPSTR pszArgs,INT cchMaxPath)
1125 {
1126     ICOM_THIS(IShellLinkImpl, iface);
1127
1128     TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1129
1130     if( cchMaxPath )
1131         pszArgs[0] = 0;
1132     if( This->sArgs )
1133         WideCharToMultiByte( CP_ACP, 0, This->sArgs, -1,
1134                              pszArgs, cchMaxPath, NULL, NULL);
1135
1136     return S_OK;
1137 }
1138
1139 static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA * iface, LPCSTR pszArgs)
1140 {
1141     ICOM_THIS(IShellLinkImpl, iface);
1142
1143     TRACE("(%p)->(args=%s)\n",This, pszArgs);
1144
1145     if (This->sArgs)
1146         HeapFree(GetProcessHeap(), 0, This->sArgs);
1147     This->sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
1148     if( !This->sArgs )
1149         return E_OUTOFMEMORY;
1150
1151     This->bDirty = TRUE;
1152
1153     return S_OK;
1154 }
1155
1156 static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA * iface, WORD *pwHotkey)
1157 {
1158         ICOM_THIS(IShellLinkImpl, iface);
1159
1160         TRACE("(%p)->(%p)(0x%08x)\n",This, pwHotkey, This->wHotKey);
1161
1162         *pwHotkey = This->wHotKey;
1163
1164         return S_OK;
1165 }
1166
1167 static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA * iface, WORD wHotkey)
1168 {
1169         ICOM_THIS(IShellLinkImpl, iface);
1170
1171         TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1172
1173         This->wHotKey = wHotkey;
1174         This->bDirty = TRUE;
1175
1176         return S_OK;
1177 }
1178
1179 static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA * iface, INT *piShowCmd)
1180 {
1181     ICOM_THIS(IShellLinkImpl, iface);
1182
1183     TRACE("(%p)->(%p)\n",This, piShowCmd);
1184     *piShowCmd = This->iShowCmd;
1185     return S_OK;
1186 }
1187
1188 static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA * iface, INT iShowCmd)
1189 {
1190     ICOM_THIS(IShellLinkImpl, iface);
1191
1192     TRACE("(%p) %d\n",This, iShowCmd);
1193
1194     This->iShowCmd = iShowCmd;
1195     This->bDirty = TRUE;
1196
1197     return NOERROR;
1198 }
1199
1200 static HRESULT SHELL_PidlGeticonLocationA(IShellFolder* psf, LPITEMIDLIST pidl, LPSTR pszIconPath, int cchIconPath, int* piIcon)
1201 {
1202     LPCITEMIDLIST pidlLast;
1203
1204     HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);
1205
1206     if (SUCCEEDED(hr)) {
1207         IExtractIconA* pei;
1208
1209         hr = IShellFolder_GetUIObjectOf(psf, 0, 1, (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconA, NULL, (LPVOID*)&pei);
1210
1211         if (SUCCEEDED(hr)) {
1212             hr = IExtractIconA_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);
1213
1214             IExtractIconA_Release(pei);
1215         }
1216
1217         IShellFolder_Release(psf);
1218     }
1219
1220     return hr;
1221 }
1222
1223 static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
1224 {
1225     ICOM_THIS(IShellLinkImpl, iface);
1226
1227     TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1228
1229     if (cchIconPath)
1230         pszIconPath[0] = 0;
1231
1232     if (This->sIcoPath) {
1233         WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
1234         *piIcon = This->iIcoNdx;
1235         return S_OK;
1236     }
1237
1238     if (This->pPidl || This->sPath) {
1239         IShellFolder* pdsk;
1240
1241         HRESULT hr = SHGetDesktopFolder(&pdsk);
1242
1243         if (SUCCEEDED(hr)) {
1244             /* first look for an icon using the PIDL (if present) */
1245             if (This->pPidl)
1246                 hr = SHELL_PidlGeticonLocationA(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
1247             else
1248                 hr = E_FAIL;
1249
1250             /* if we couldn't find an icon yet, look for it using the file system path */
1251             if (FAILED(hr) && This->sPath) {
1252                 LPITEMIDLIST pidl;
1253
1254                 hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);
1255
1256                 if (SUCCEEDED(hr)) {
1257                     hr = SHELL_PidlGeticonLocationA(pdsk, pidl, pszIconPath, cchIconPath, piIcon);
1258
1259                     SHFree(pidl);
1260                 }
1261             }
1262
1263             IShellFolder_Release(pdsk);
1264         }
1265
1266         return hr;
1267     } else
1268         return E_FAIL;
1269 }
1270
1271 static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA * iface, LPCSTR pszIconPath,INT iIcon)
1272 {
1273     ICOM_THIS(IShellLinkImpl, iface);
1274
1275     TRACE("(%p)->(path=%s iicon=%u)\n",This, pszIconPath, iIcon);
1276
1277     if (This->sIcoPath)
1278         HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1279     This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
1280     if ( !This->sIcoPath )
1281         return E_OUTOFMEMORY;
1282
1283     This->iIcoNdx = iIcon;
1284     This->bDirty = TRUE;
1285
1286     return S_OK;
1287 }
1288
1289 static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA * iface, LPCSTR pszPathRel, DWORD dwReserved)
1290 {
1291     ICOM_THIS(IShellLinkImpl, iface);
1292
1293     FIXME("(%p)->(path=%s %lx)\n",This, pszPathRel, dwReserved);
1294
1295     if (This->sPathRel)
1296         HeapFree(GetProcessHeap(), 0, This->sPathRel);
1297     This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1298     This->bDirty = TRUE;
1299
1300     return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1301 }
1302
1303 static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA * iface, HWND hwnd, DWORD fFlags)
1304 {
1305         ICOM_THIS(IShellLinkImpl, iface);
1306
1307         FIXME("(%p)->(hwnd=%p flags=%lx)\n",This, hwnd, fFlags);
1308         return S_OK;
1309 }
1310
1311 static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA * iface, LPCSTR pszFile)
1312 {
1313     ICOM_THIS(IShellLinkImpl, iface);
1314
1315     TRACE("(%p)->(path=%s)\n",This, pszFile);
1316
1317     if (This->sPath)
1318         HeapFree(GetProcessHeap(), 0, This->sPath);
1319     This->sPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
1320     if( !This->sPath )
1321         return E_OUTOFMEMORY;
1322
1323     This->bDirty = TRUE;
1324
1325     return S_OK;
1326 }
1327
1328 /**************************************************************************
1329 * IShellLink Implementation
1330 */
1331
1332 static IShellLinkAVtbl slvt =
1333 {
1334         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1335         IShellLinkA_fnQueryInterface,
1336         IShellLinkA_fnAddRef,
1337         IShellLinkA_fnRelease,
1338         IShellLinkA_fnGetPath,
1339         IShellLinkA_fnGetIDList,
1340         IShellLinkA_fnSetIDList,
1341         IShellLinkA_fnGetDescription,
1342         IShellLinkA_fnSetDescription,
1343         IShellLinkA_fnGetWorkingDirectory,
1344         IShellLinkA_fnSetWorkingDirectory,
1345         IShellLinkA_fnGetArguments,
1346         IShellLinkA_fnSetArguments,
1347         IShellLinkA_fnGetHotkey,
1348         IShellLinkA_fnSetHotkey,
1349         IShellLinkA_fnGetShowCmd,
1350         IShellLinkA_fnSetShowCmd,
1351         IShellLinkA_fnGetIconLocation,
1352         IShellLinkA_fnSetIconLocation,
1353         IShellLinkA_fnSetRelativePath,
1354         IShellLinkA_fnResolve,
1355         IShellLinkA_fnSetPath
1356 };
1357
1358
1359 /**************************************************************************
1360  *  IShellLinkW_fnQueryInterface
1361  */
1362 static HRESULT WINAPI IShellLinkW_fnQueryInterface(
1363   IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
1364 {
1365         _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1366
1367         return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObj);
1368 }
1369
1370 /******************************************************************************
1371  * IShellLinkW_fnAddRef
1372  */
1373 static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
1374 {
1375         _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1376
1377         TRACE("(%p)->(count=%lu)\n",This,This->ref);
1378
1379         return IShellLinkA_AddRef((IShellLinkA*)This);
1380 }
1381 /******************************************************************************
1382  * IShellLinkW_fnRelease
1383  */
1384
1385 static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
1386 {
1387         _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1388
1389         TRACE("(%p)->(count=%lu)\n",This,This->ref);
1390
1391         return IShellLinkA_Release((IShellLinkA*)This);
1392 }
1393
1394 static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1395 {
1396     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1397
1398     FIXME("(%p)->(pfile=%p len=%u find_data=%p flags=%lu)\n",This, pszFile, cchMaxPath, pfd, fFlags);
1399     if( cchMaxPath )
1400         pszFile[0] = 0;
1401     if( This->sPath )
1402         lstrcpynW( pszFile, This->sPath, cchMaxPath );
1403
1404     return NOERROR;
1405 }
1406
1407 static HRESULT WINAPI IShellLinkW_fnGetIDList(IShellLinkW * iface, LPITEMIDLIST * ppidl)
1408 {
1409     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1410
1411     TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1412
1413     if( This->pPidl)
1414         *ppidl = ILClone( This->pPidl );
1415     else
1416         *ppidl = NULL;
1417
1418     return S_OK;
1419 }
1420
1421 static HRESULT WINAPI IShellLinkW_fnSetIDList(IShellLinkW * iface, LPCITEMIDLIST pidl)
1422 {
1423     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1424
1425     TRACE("(%p)->(pidl=%p)\n",This, pidl);
1426
1427     if( This->pPidl )
1428         ILFree( This->pPidl );
1429     This->pPidl = ILClone( pidl );
1430     if( !This->pPidl )
1431         return E_FAIL;
1432
1433     This->bDirty = TRUE;
1434
1435     return S_OK;
1436 }
1437
1438 static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1439 {
1440     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1441
1442     TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1443
1444     if( cchMaxName )
1445         pszName[0] = 0;
1446     if( This->sDescription )
1447         lstrcpynW( pszName, This->sDescription, cchMaxName );
1448
1449     return S_OK;
1450 }
1451
1452 static HRESULT WINAPI IShellLinkW_fnSetDescription(IShellLinkW * iface, LPCWSTR pszName)
1453 {
1454     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1455
1456     TRACE("(%p)->(desc=%s)\n",This, debugstr_w(pszName));
1457
1458     if (This->sDescription)
1459         HeapFree(GetProcessHeap(), 0, This->sDescription);
1460     This->sDescription = HeapAlloc( GetProcessHeap(), 0,
1461                                     (lstrlenW( pszName )+1)*sizeof(WCHAR) );
1462     if ( !This->sDescription )
1463         return E_OUTOFMEMORY;
1464
1465     lstrcpyW( This->sDescription, pszName );
1466     This->bDirty = TRUE;
1467
1468     return S_OK;
1469 }
1470
1471 static HRESULT WINAPI IShellLinkW_fnGetWorkingDirectory(IShellLinkW * iface, LPWSTR pszDir,INT cchMaxPath)
1472 {
1473     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1474
1475     TRACE("(%p)->(%p len %u)\n", This, pszDir, cchMaxPath);
1476
1477     if( cchMaxPath )
1478         pszDir[0] = 0;
1479     if( This->sWorkDir )
1480         lstrcpynW( pszDir, This->sWorkDir, cchMaxPath );
1481
1482     return S_OK;
1483 }
1484
1485 static HRESULT WINAPI IShellLinkW_fnSetWorkingDirectory(IShellLinkW * iface, LPCWSTR pszDir)
1486 {
1487     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1488
1489     TRACE("(%p)->(dir=%s)\n",This, debugstr_w(pszDir));
1490
1491     if (This->sWorkDir)
1492         HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1493     This->sWorkDir = HeapAlloc( GetProcessHeap(), 0,
1494                                 (lstrlenW( pszDir )+1)*sizeof (WCHAR) );
1495     if ( !This->sWorkDir )
1496         return E_OUTOFMEMORY;
1497     lstrcpyW( This->sWorkDir, pszDir );
1498     This->bDirty = TRUE;
1499
1500     return S_OK;
1501 }
1502
1503 static HRESULT WINAPI IShellLinkW_fnGetArguments(IShellLinkW * iface, LPWSTR pszArgs,INT cchMaxPath)
1504 {
1505     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1506
1507     TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1508
1509     if( cchMaxPath )
1510         pszArgs[0] = 0;
1511     if( This->sArgs )
1512         lstrcpynW( pszArgs, This->sArgs, cchMaxPath );
1513
1514     return NOERROR;
1515 }
1516
1517 static HRESULT WINAPI IShellLinkW_fnSetArguments(IShellLinkW * iface, LPCWSTR pszArgs)
1518 {
1519     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1520
1521     TRACE("(%p)->(args=%s)\n",This, debugstr_w(pszArgs));
1522
1523     if (This->sArgs)
1524         HeapFree(GetProcessHeap(), 0, This->sArgs);
1525     This->sArgs = HeapAlloc( GetProcessHeap(), 0,
1526                              (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
1527     if ( !This->sArgs )
1528         return E_OUTOFMEMORY;
1529     lstrcpyW( This->sArgs, pszArgs );
1530     This->bDirty = TRUE;
1531
1532     return S_OK;
1533 }
1534
1535 static HRESULT WINAPI IShellLinkW_fnGetHotkey(IShellLinkW * iface, WORD *pwHotkey)
1536 {
1537     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1538
1539     TRACE("(%p)->(%p)\n",This, pwHotkey);
1540
1541     *pwHotkey=This->wHotKey;
1542
1543     return S_OK;
1544 }
1545
1546 static HRESULT WINAPI IShellLinkW_fnSetHotkey(IShellLinkW * iface, WORD wHotkey)
1547 {
1548     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1549
1550     TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1551
1552     This->wHotKey = wHotkey;
1553     This->bDirty = TRUE;
1554
1555     return S_OK;
1556 }
1557
1558 static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1559 {
1560     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1561
1562     TRACE("(%p)->(%p)\n",This, piShowCmd);
1563
1564     *piShowCmd = This->iShowCmd;
1565
1566     return S_OK;
1567 }
1568
1569 static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1570 {
1571     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1572
1573     This->iShowCmd = iShowCmd;
1574     This->bDirty = TRUE;
1575
1576     return S_OK;
1577 }
1578
1579 static HRESULT SHELL_PidlGeticonLocationW(IShellFolder* psf, LPITEMIDLIST pidl, LPWSTR pszIconPath, int cchIconPath, int* piIcon)
1580 {
1581     LPCITEMIDLIST pidlLast;
1582
1583     HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);
1584
1585     if (SUCCEEDED(hr)) {
1586         IExtractIconW* pei;
1587
1588         hr = IShellFolder_GetUIObjectOf(psf, 0, 1, (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconW, NULL, (LPVOID*)&pei);
1589
1590         if (SUCCEEDED(hr)) {
1591             hr = IExtractIconW_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);
1592
1593             IExtractIconW_Release(pei);
1594         }
1595
1596         IShellFolder_Release(psf);
1597     }
1598
1599     return hr;
1600 }
1601
1602 static HRESULT WINAPI IShellLinkW_fnGetIconLocation(IShellLinkW * iface, LPWSTR pszIconPath,INT cchIconPath,INT *piIcon)
1603 {
1604     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1605
1606     TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1607
1608     if (cchIconPath)
1609         pszIconPath[0] = 0;
1610
1611     if (This->sIcoPath) {
1612         lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
1613         *piIcon = This->iIcoNdx;
1614         return S_OK;
1615     }
1616
1617     if (This->pPidl || This->sPath) {
1618         IShellFolder* pdsk;
1619
1620         HRESULT hr = SHGetDesktopFolder(&pdsk);
1621
1622         if (SUCCEEDED(hr)) {
1623             /* first look for an icon using the PIDL (if present) */
1624             if (This->pPidl)
1625                 hr = SHELL_PidlGeticonLocationW(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
1626             else
1627                 hr = E_FAIL;
1628
1629             /* if we couldn't find an icon yet, look for it using the file system path */
1630             if (FAILED(hr) && This->sPath) {
1631                 LPITEMIDLIST pidl;
1632
1633                 hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);
1634
1635                 if (SUCCEEDED(hr)) {
1636                     hr = SHELL_PidlGeticonLocationW(pdsk, pidl, pszIconPath, cchIconPath, piIcon);
1637
1638                     SHFree(pidl);
1639                 }
1640             }
1641
1642             IShellFolder_Release(pdsk);
1643         }
1644
1645         return hr;
1646     } else
1647         return E_FAIL;
1648 }
1649
1650 static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
1651 {
1652     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1653
1654     TRACE("(%p)->(path=%s iicon=%u)\n",This, debugstr_w(pszIconPath), iIcon);
1655
1656     if (This->sIcoPath)
1657         HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1658     This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
1659                                 (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
1660     if ( !This->sIcoPath )
1661         return E_OUTOFMEMORY;
1662     lstrcpyW( This->sIcoPath, pszIconPath );
1663
1664     This->iIcoNdx = iIcon;
1665     This->bDirty = TRUE;
1666
1667     return S_OK;
1668 }
1669
1670 static HRESULT WINAPI IShellLinkW_fnSetRelativePath(IShellLinkW * iface, LPCWSTR pszPathRel, DWORD dwReserved)
1671 {
1672     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1673
1674     TRACE("(%p)->(path=%s %lx)\n",This, debugstr_w(pszPathRel), dwReserved);
1675
1676     if (This->sPathRel)
1677         HeapFree(GetProcessHeap(), 0, This->sPathRel);
1678     This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
1679                                 (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
1680     if ( !This->sPathRel )
1681         return E_OUTOFMEMORY;
1682     lstrcpyW( This->sPathRel, pszPathRel );
1683     This->bDirty = TRUE;
1684
1685     return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1686 }
1687
1688 static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
1689 {
1690     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1691
1692     FIXME("(%p)->(hwnd=%p flags=%lx)\n",This, hwnd, fFlags);
1693
1694     return S_OK;
1695 }
1696
1697 static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
1698 {
1699     _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1700
1701     TRACE("(%p)->(path=%s)\n",This, debugstr_w(pszFile));
1702
1703     if (This->sPath)
1704         HeapFree(GetProcessHeap(), 0, This->sPath);
1705     This->sPath = HeapAlloc( GetProcessHeap(), 0,
1706                              (lstrlenW( pszFile )+1) * sizeof (WCHAR) );
1707     if ( !This->sPath )
1708         return E_OUTOFMEMORY;
1709
1710     lstrcpyW( This->sPath, pszFile );
1711     This->bDirty = TRUE;
1712
1713     return S_OK;
1714 }
1715
1716 /**************************************************************************
1717 * IShellLinkW Implementation
1718 */
1719
1720 static IShellLinkWVtbl slvtw =
1721 {
1722         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1723         IShellLinkW_fnQueryInterface,
1724         IShellLinkW_fnAddRef,
1725         IShellLinkW_fnRelease,
1726         IShellLinkW_fnGetPath,
1727         IShellLinkW_fnGetIDList,
1728         IShellLinkW_fnSetIDList,
1729         IShellLinkW_fnGetDescription,
1730         IShellLinkW_fnSetDescription,
1731         IShellLinkW_fnGetWorkingDirectory,
1732         IShellLinkW_fnSetWorkingDirectory,
1733         IShellLinkW_fnGetArguments,
1734         IShellLinkW_fnSetArguments,
1735         IShellLinkW_fnGetHotkey,
1736         IShellLinkW_fnSetHotkey,
1737         IShellLinkW_fnGetShowCmd,
1738         IShellLinkW_fnSetShowCmd,
1739         IShellLinkW_fnGetIconLocation,
1740         IShellLinkW_fnSetIconLocation,
1741         IShellLinkW_fnSetRelativePath,
1742         IShellLinkW_fnResolve,
1743         IShellLinkW_fnSetPath
1744 };