51350b914c6fba6d16e759d49fc478ca7a98a53f
[reactos.git] / reactos / lib / shell32 / shelllink.c
1 /*
2 *
3 * Copyright 1997 Marcus Meissner
4 * Copyright 1998 Juergen Schmied
5 * Copyright 2005 Mike McCormack
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * NOTES
22 * Nearly complete informations about the binary formats
23 * of .lnk files available at http://www.wotsit.org
24 *
25 * You can use winedump to examine the contents of a link file:
26 * winedump lnk sc.lnk
27 *
28 * MSI advertised shortcuts are totally undocumented. They provide an
29 * icon for a program that is not yet installed, and invoke MSI to
30 * install the program when the shortcut is clicked on. They are
31 * created by passing a special string to SetPath, and the information
32 * 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 #include "winbase.h"
42 #include "winnls.h"
43 #include "winreg.h"
44
45 #include "winuser.h"
46 #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
55 #include "initguid.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(shell);
58
59 DEFINE_GUID( SHELL32_AdvtShortcutProduct,
60 0x9db1186f,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);
61 DEFINE_GUID( SHELL32_AdvtShortcutComponent,
62 0x9db1186e,0x40df,0x11d1,0xaa,0x8c,0x00,0xc0,0x4f,0xb6,0x78,0x63);
63
64 /* link file formats */
65
66 #include "pshpack1.h"
67
68 typedef struct _LINK_HEADER
69 {
70 DWORD dwSize; /* 0x00 size of the header - 0x4c */
71 GUID MagicGuid; /* 0x04 is CLSID_ShellLink */
72 DWORD dwFlags; /* 0x14 describes elements following */
73 DWORD dwFileAttr; /* 0x18 attributes of the target file */
74 FILETIME Time1; /* 0x1c */
75 FILETIME Time2; /* 0x24 */
76 FILETIME Time3; /* 0x2c */
77 DWORD dwFileLength; /* 0x34 File length */
78 DWORD nIcon; /* 0x38 icon number */
79 DWORD fStartup; /* 0x3c startup type */
80 DWORD wHotKey; /* 0x40 hotkey */
81 DWORD Unknown5; /* 0x44 */
82 DWORD Unknown6; /* 0x48 */
83 } LINK_HEADER, * PLINK_HEADER;
84
85 #define SHLINK_LOCAL 0
86 #define SHLINK_REMOTE 1
87
88 typedef struct _LOCATION_INFO
89 {
90 DWORD dwTotalSize;
91 DWORD dwHeaderSize;
92 DWORD dwFlags;
93 DWORD dwVolTableOfs;
94 DWORD dwLocalPathOfs;
95 DWORD dwNetworkVolTableOfs;
96 DWORD dwFinalPathOfs;
97 } LOCATION_INFO;
98
99 typedef struct _LOCAL_VOLUME_INFO
100 {
101 DWORD dwSize;
102 DWORD dwType;
103 DWORD dwVolSerial;
104 DWORD dwVolLabelOfs;
105 } LOCAL_VOLUME_INFO;
106
107 typedef struct volume_info_t
108 {
109 DWORD type;
110 DWORD serial;
111 WCHAR label[12]; /* assume 8.3 */
112 } volume_info;
113
114 #include "poppack.h"
115
116 static const IShellLinkAVtbl slvt;
117 static const IShellLinkWVtbl slvtw;
118 static const IPersistFileVtbl pfvt;
119 static const IPersistStreamVtbl psvt;
120 static const IShellLinkDataListVtbl dlvt;
121 static const IShellExtInitVtbl eivt;
122 static const IContextMenuVtbl cmvt;
123
124 /* IShellLink Implementation */
125
126 typedef struct
127 {
128 const IShellLinkAVtbl *lpVtbl;
129 const IShellLinkWVtbl *lpvtblw;
130 const IPersistFileVtbl *lpvtblPersistFile;
131 const IPersistStreamVtbl *lpvtblPersistStream;
132 const IShellLinkDataListVtbl *lpvtblShellLinkDataList;
133 const IShellExtInitVtbl *lpvtblShellExtInit;
134 const IContextMenuVtbl *lpvtblContextMenu;
135
136 LONG ref;
137
138 /* data structures according to the informations in the link */
139 LPITEMIDLIST pPidl;
140 WORD wHotKey;
141 SYSTEMTIME time1;
142 SYSTEMTIME time2;
143 SYSTEMTIME time3;
144
145 DWORD iShowCmd;
146 LPWSTR sIcoPath;
147 INT iIcoNdx;
148 LPWSTR sPath;
149 LPWSTR sArgs;
150 LPWSTR sWorkDir;
151 LPWSTR sDescription;
152 LPWSTR sPathRel;
153 LPWSTR sProduct;
154 LPWSTR sComponent;
155 volume_info volume;
156
157 BOOL bDirty;
158 } IShellLinkImpl;
159
160 static inline IShellLinkImpl *impl_from_IShellLinkW( IShellLinkW *iface )
161 {
162 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblw));
163 }
164 #define _ICOM_THIS_From_IShellLinkW(class, iface) \
165 class* This = impl_from_IShellLinkW( iface )
166
167 static inline IShellLinkImpl *impl_from_IPersistFile( IPersistFile *iface )
168 {
169 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblPersistFile));
170 }
171 #define _ICOM_THIS_From_IPersistFile(class, iface) \
172 class* This = impl_from_IPersistFile( iface )
173
174 static inline IShellLinkImpl *impl_from_IPersistStream( IPersistStream *iface )
175 {
176 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblPersistStream));
177 }
178 #define _ICOM_THIS_From_IPersistStream(class, iface) \
179 class* This = impl_from_IPersistStream( iface )
180
181 static inline IShellLinkImpl *impl_from_IShellLinkDataList( IShellLinkDataList *iface )
182 {
183 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblShellLinkDataList));
184 }
185 #define _ICOM_THIS_From_IShellLinkDataList(class, iface) \
186 class* This = impl_from_IShellLinkDataList( iface )
187
188 static inline IShellLinkImpl *impl_from_IShellExtInit( IShellExtInit *iface )
189 {
190 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblShellExtInit));
191 }
192 #define _ICOM_THIS_From_IShellExtInit(class, iface) \
193 class* This = impl_from_IShellExtInit( iface )
194
195 static inline IShellLinkImpl *impl_from_IContextMenu( IContextMenu *iface )
196 {
197 return (IShellLinkImpl *)((char*)iface - FIELD_OFFSET(IShellLinkImpl, lpvtblContextMenu));
198 }
199 #define _ICOM_THIS_From_IContextMenu(class, iface) \
200 class* This = impl_from_IContextMenu( iface )
201
202 static HRESULT ShellLink_UpdatePath(LPWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath);
203
204 /* strdup on the process heap */
205 inline static LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str)
206 {
207 INT len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
208 LPWSTR p = HeapAlloc( heap, flags, len*sizeof (WCHAR) );
209 if( !p )
210 return p;
211 MultiByteToWideChar( CP_ACP, 0, str, -1, p, len );
212 return p;
213 }
214
215 /**************************************************************************
216 * ShellLink::QueryInterface implementation
217 */
218 static HRESULT ShellLink_QueryInterface( IShellLinkImpl *This, REFIID riid, LPVOID *ppvObj)
219 {
220 TRACE("(%p)->(\n\tIID:\t%s)\n",This,debugstr_guid(riid));
221
222 *ppvObj = NULL;
223
224 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IShellLinkA))
225 {
226 *ppvObj = This;
227 }
228 else if(IsEqualIID(riid, &IID_IShellLinkW))
229 {
230 *ppvObj = &(This->lpvtblw);
231 }
232 else if(IsEqualIID(riid, &IID_IPersistFile))
233 {
234 *ppvObj = &(This->lpvtblPersistFile);
235 }
236 else if(IsEqualIID(riid, &IID_IPersistStream))
237 {
238 *ppvObj = &(This->lpvtblPersistStream);
239 }
240 else if(IsEqualIID(riid, &IID_IShellLinkDataList))
241 {
242 *ppvObj = &(This->lpvtblShellLinkDataList);
243 }
244 else if(IsEqualIID(riid, &IID_IShellExtInit))
245 {
246 *ppvObj = &(This->lpvtblShellExtInit);
247 }
248 else if(IsEqualIID(riid, &IID_IContextMenu))
249 {
250 *ppvObj = &(This->lpvtblContextMenu);
251 }
252
253 if(*ppvObj)
254 {
255 IUnknown_AddRef((IUnknown*)(*ppvObj));
256 TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
257 return S_OK;
258 }
259 ERR("-- Interface: E_NOINTERFACE\n");
260 return E_NOINTERFACE;
261 }
262
263 /**************************************************************************
264 * ShellLink::AddRef implementation
265 */
266 static ULONG ShellLink_AddRef( IShellLinkImpl *This )
267 {
268 ULONG refCount = InterlockedIncrement(&This->ref);
269
270 TRACE("(%p)->(count=%lu)\n", This, refCount - 1);
271
272 return refCount;
273 }
274
275 /**************************************************************************
276 * ShellLink::Release implementation
277 */
278 static ULONG ShellLink_Release( IShellLinkImpl *This )
279 {
280 ULONG refCount = InterlockedDecrement(&This->ref);
281
282 TRACE("(%p)->(count=%lu)\n", This, refCount + 1);
283
284 if (refCount)
285 return refCount;
286
287 TRACE("-- destroying IShellLink(%p)\n",This);
288
289 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
290 HeapFree(GetProcessHeap(), 0, This->sArgs);
291 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
292 HeapFree(GetProcessHeap(), 0, This->sDescription);
293 HeapFree(GetProcessHeap(),0,This->sPath);
294
295 if (This->pPidl)
296 ILFree(This->pPidl);
297
298 LocalFree((HANDLE)This);
299
300 return 0;
301 }
302
303 static HRESULT ShellLink_GetClassID( IShellLinkImpl *This, CLSID *pclsid )
304 {
305 TRACE("%p %p\n", This, pclsid);
306
307 memcpy( pclsid, &CLSID_ShellLink, sizeof (CLSID) );
308 return S_OK;
309 }
310
311 /**************************************************************************
312 * IPersistFile_QueryInterface
313 */
314 static HRESULT WINAPI IPersistFile_fnQueryInterface(
315 IPersistFile* iface,
316 REFIID riid,
317 LPVOID *ppvObj)
318 {
319 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
320 return ShellLink_QueryInterface( This, riid, ppvObj );
321 }
322
323 /******************************************************************************
324 * IPersistFile_AddRef
325 */
326 static ULONG WINAPI IPersistFile_fnAddRef(IPersistFile* iface)
327 {
328 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
329 return ShellLink_AddRef( This );
330 }
331
332 /******************************************************************************
333 * IPersistFile_Release
334 */
335 static ULONG WINAPI IPersistFile_fnRelease(IPersistFile* iface)
336 {
337 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
338 return IShellLinkA_Release((IShellLinkA*)This);
339 }
340
341 static HRESULT WINAPI IPersistFile_fnGetClassID(IPersistFile* iface, CLSID *pClassID)
342 {
343 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
344 return ShellLink_GetClassID( This, pClassID );
345 }
346
347 static HRESULT WINAPI IPersistFile_fnIsDirty(IPersistFile* iface)
348 {
349 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
350
351 TRACE("(%p)\n",This);
352
353 if (This->bDirty)
354 return S_OK;
355
356 return S_FALSE;
357 }
358
359 static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile* iface, LPCOLESTR pszFileName, DWORD dwMode)
360 {
361 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
362 IPersistStream *StreamThis = (IPersistStream *)&This->lpvtblPersistStream;
363 HRESULT r;
364 IStream *stm;
365
366 TRACE("(%p, %s, %lx)\n",This, debugstr_w(pszFileName), dwMode);
367
368 if( dwMode == 0 )
369 dwMode = STGM_READ | STGM_SHARE_DENY_WRITE;
370 r = SHCreateStreamOnFileW(pszFileName, dwMode, &stm);
371 if( SUCCEEDED( r ) )
372 {
373 r = IPersistStream_Load(StreamThis, stm);
374 ShellLink_UpdatePath(This->sPathRel, pszFileName, This->sWorkDir, &This->sPath);
375 IStream_Release( stm );
376 This->bDirty = FALSE;
377 }
378 TRACE("-- returning hr %08lx\n", r);
379 return r;
380 }
381
382 static BOOL StartLinkProcessor( LPCOLESTR szLink )
383 {
384 static const WCHAR szFormat[] = {
385 'w','i','n','e','m','e','n','u','b','u','i','l','d','e','r','.','e','x','e',
386 ' ','-','r',' ','"','%','s','"',0 };
387 LONG len;
388 LPWSTR buffer;
389 STARTUPINFOW si;
390 PROCESS_INFORMATION pi;
391
392 len = sizeof(szFormat) + lstrlenW( szLink ) * sizeof(WCHAR);
393 buffer = HeapAlloc( GetProcessHeap(), 0, len );
394 if( !buffer )
395 return FALSE;
396
397 wsprintfW( buffer, szFormat, szLink );
398
399 TRACE("starting %s\n",debugstr_w(buffer));
400
401 memset(&si, 0, sizeof(si));
402 si.cb = sizeof(si);
403 if (!CreateProcessW( NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) return FALSE;
404
405 /* wait for a while to throttle the creation of linker processes */
406 if( WAIT_OBJECT_0 != WaitForSingleObject( pi.hProcess, 10000 ) )
407 WARN("Timed out waiting for shell linker\n");
408
409 CloseHandle( pi.hProcess );
410 CloseHandle( pi.hThread );
411
412 return TRUE;
413 }
414
415 static HRESULT WINAPI IPersistFile_fnSave(IPersistFile* iface, LPCOLESTR pszFileName, BOOL fRemember)
416 {
417 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
418 IPersistStream *StreamThis = (IPersistStream *)&This->lpvtblPersistStream;
419 HRESULT r;
420 IStream *stm;
421
422 TRACE("(%p)->(%s)\n",This,debugstr_w(pszFileName));
423
424 if (!pszFileName)
425 return E_FAIL;
426
427 r = SHCreateStreamOnFileW( pszFileName, STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE, &stm );
428 if( SUCCEEDED( r ) )
429 {
430 r = IPersistStream_Save(StreamThis, stm, FALSE);
431 IStream_Release( stm );
432
433 if( SUCCEEDED( r ) )
434 {
435 StartLinkProcessor( pszFileName );
436
437 This->bDirty = FALSE;
438 }
439 else
440 {
441 DeleteFileW( pszFileName );
442 WARN("Failed to create shortcut %s\n", debugstr_w(pszFileName) );
443 }
444 }
445
446 return r;
447 }
448
449 static HRESULT WINAPI IPersistFile_fnSaveCompleted(IPersistFile* iface, LPCOLESTR pszFileName)
450 {
451 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
452 FIXME("(%p)->(%s)\n",This,debugstr_w(pszFileName));
453 return NOERROR;
454 }
455
456 static HRESULT WINAPI IPersistFile_fnGetCurFile(IPersistFile* iface, LPOLESTR *ppszFileName)
457 {
458 _ICOM_THIS_From_IPersistFile(IShellLinkImpl, iface);
459 FIXME("(%p)\n",This);
460 return NOERROR;
461 }
462
463 static const IPersistFileVtbl pfvt =
464 {
465 IPersistFile_fnQueryInterface,
466 IPersistFile_fnAddRef,
467 IPersistFile_fnRelease,
468 IPersistFile_fnGetClassID,
469 IPersistFile_fnIsDirty,
470 IPersistFile_fnLoad,
471 IPersistFile_fnSave,
472 IPersistFile_fnSaveCompleted,
473 IPersistFile_fnGetCurFile
474 };
475
476 /************************************************************************
477 * IPersistStream_QueryInterface
478 */
479 static HRESULT WINAPI IPersistStream_fnQueryInterface(
480 IPersistStream* iface,
481 REFIID riid,
482 VOID** ppvObj)
483 {
484 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
485 return ShellLink_QueryInterface( This, riid, ppvObj );
486 }
487
488 /************************************************************************
489 * IPersistStream_Release
490 */
491 static ULONG WINAPI IPersistStream_fnRelease(
492 IPersistStream* iface)
493 {
494 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
495 return IShellLinkA_Release((IShellLinkA*)This);
496 }
497
498 /************************************************************************
499 * IPersistStream_AddRef
500 */
501 static ULONG WINAPI IPersistStream_fnAddRef(
502 IPersistStream* iface)
503 {
504 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
505 return ShellLink_AddRef( This );
506 }
507
508 /************************************************************************
509 * IPersistStream_GetClassID
510 *
511 */
512 static HRESULT WINAPI IPersistStream_fnGetClassID(
513 IPersistStream* iface,
514 CLSID* pClassID)
515 {
516 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
517 return ShellLink_GetClassID( This, pClassID );
518 }
519
520 /************************************************************************
521 * IPersistStream_IsDirty (IPersistStream)
522 */
523 static HRESULT WINAPI IPersistStream_fnIsDirty(
524 IPersistStream* iface)
525 {
526 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
527
528 TRACE("(%p)\n", This);
529
530 return S_OK;
531 }
532
533
534 static HRESULT Stream_LoadString( IStream* stm, BOOL unicode, LPWSTR *pstr )
535 {
536 DWORD count;
537 USHORT len;
538 LPVOID temp;
539 LPWSTR str;
540 HRESULT r;
541
542 TRACE("%p\n", stm);
543
544 count = 0;
545 r = IStream_Read(stm, &len, sizeof(len), &count);
546 if ( FAILED (r) || ( count != sizeof(len) ) )
547 return E_FAIL;
548
549 if( unicode )
550 len *= sizeof (WCHAR);
551
552 TRACE("reading %d\n", len);
553 temp = HeapAlloc(GetProcessHeap(), 0, len+sizeof(WCHAR));
554 if( !temp )
555 return E_OUTOFMEMORY;
556 count = 0;
557 r = IStream_Read(stm, temp, len, &count);
558 if( FAILED (r) || ( count != len ) )
559 {
560 HeapFree( GetProcessHeap(), 0, temp );
561 return E_FAIL;
562 }
563
564 TRACE("read %s\n", debugstr_an(temp,len));
565
566 /* convert to unicode if necessary */
567 if( !unicode )
568 {
569 count = MultiByteToWideChar( CP_ACP, 0, (LPSTR) temp, len, NULL, 0 );
570 str = HeapAlloc( GetProcessHeap(), 0, (count+1)*sizeof (WCHAR) );
571 if( str )
572 MultiByteToWideChar( CP_ACP, 0, (LPSTR) temp, len, str, count );
573 HeapFree( GetProcessHeap(), 0, temp );
574 }
575 else
576 {
577 count /= 2;
578 str = (LPWSTR) temp;
579 }
580 str[count] = 0;
581
582 *pstr = str;
583
584 return S_OK;
585 }
586
587 static HRESULT Stream_ReadChunk( IStream* stm, LPVOID *data )
588 {
589 DWORD size;
590 ULONG count;
591 HRESULT r;
592 struct sized_chunk {
593 DWORD size;
594 unsigned char data[1];
595 } *chunk;
596
597 TRACE("%p\n",stm);
598
599 r = IStream_Read( stm, &size, sizeof(size), &count );
600 if( FAILED( r ) || count != sizeof(size) )
601 return E_FAIL;
602
603 chunk = HeapAlloc( GetProcessHeap(), 0, size );
604 if( !chunk )
605 return E_OUTOFMEMORY;
606
607 chunk->size = size;
608 r = IStream_Read( stm, chunk->data, size - sizeof(size), &count );
609 if( FAILED( r ) || count != (size - sizeof(size)) )
610 {
611 HeapFree( GetProcessHeap(), 0, chunk );
612 return E_FAIL;
613 }
614
615 TRACE("Read %ld bytes\n",chunk->size);
616
617 *data = (LPVOID) chunk;
618
619 return S_OK;
620 }
621
622 static BOOL Stream_LoadVolume( LOCAL_VOLUME_INFO *vol, volume_info *volume )
623 {
624 const int label_sz = sizeof volume->label/sizeof volume->label[0];
625 LPSTR label;
626 int len;
627
628 volume->serial = vol->dwVolSerial;
629 volume->type = vol->dwType;
630
631 if( !vol->dwVolLabelOfs )
632 return FALSE;
633 if( vol->dwSize <= vol->dwVolLabelOfs )
634 return FALSE;
635 len = vol->dwSize - vol->dwVolLabelOfs;
636
637 label = (LPSTR) vol;
638 label += vol->dwVolLabelOfs;
639 MultiByteToWideChar( CP_ACP, 0, label, len, volume->label, label_sz-1);
640
641 return TRUE;
642 }
643
644 static LPWSTR Stream_LoadPath( LPSTR p, DWORD maxlen )
645 {
646 int len = 0, wlen;
647 LPWSTR path;
648
649 while( p[len] && (len < maxlen) )
650 len++;
651
652 wlen = MultiByteToWideChar(CP_ACP, 0, p, len, NULL, 0);
653 path = HeapAlloc(GetProcessHeap(), 0, (wlen+1)*sizeof(WCHAR));
654 MultiByteToWideChar(CP_ACP, 0, p, len, path, wlen);
655 path[wlen] = 0;
656
657 return path;
658 }
659
660 static HRESULT Stream_LoadLocation( IStream *stm,
661 volume_info *volume, LPWSTR *path )
662 {
663 char *p = NULL;
664 LOCATION_INFO *loc;
665 HRESULT r;
666 int n;
667
668 r = Stream_ReadChunk( stm, (LPVOID*) &p );
669 if( FAILED(r) )
670 return r;
671
672 loc = (LOCATION_INFO*) p;
673 if (loc->dwTotalSize < sizeof(LOCATION_INFO) - sizeof(DWORD))
674 {
675 HeapFree( GetProcessHeap(), 0, p );
676 return E_FAIL;
677 }
678
679 /* if there's valid local volume information, load it */
680 if( loc->dwVolTableOfs &&
681 ((loc->dwVolTableOfs + sizeof(LOCAL_VOLUME_INFO)) <= loc->dwTotalSize) )
682 {
683 LOCAL_VOLUME_INFO *volume_info;
684
685 volume_info = (LOCAL_VOLUME_INFO*) &p[loc->dwVolTableOfs];
686 Stream_LoadVolume( volume_info, volume );
687 }
688
689 /* if there's a local path, load it */
690 n = loc->dwLocalPathOfs;
691 if( n && (n < loc->dwTotalSize) )
692 *path = Stream_LoadPath( &p[n], loc->dwTotalSize - n );
693
694 TRACE("type %ld serial %08lx name %s path %s\n", volume->type,
695 volume->serial, debugstr_w(volume->label), debugstr_w(*path));
696
697 HeapFree( GetProcessHeap(), 0, p );
698 return S_OK;
699 }
700
701 /*
702 * The format of the advertised shortcut info seems to be:
703 *
704 * Offset Description
705 * ------ -----------
706 *
707 * 0 Length of the block (4 bytes, usually 0x314)
708 * 4 tag (dword)
709 * 8 string data in ASCII
710 * 8+0x104 string data in UNICODE
711 *
712 * In the original Win32 implementation the buffers are not initialized
713 * to zero, so data trailing the string is random garbage.
714 */
715 static HRESULT Stream_LoadAdvertiseInfo( IStream* stm, LPWSTR *str )
716 {
717 DWORD size;
718 ULONG count;
719 HRESULT r;
720 EXP_DARWIN_LINK buffer;
721
722 TRACE("%p\n",stm);
723
724 r = IStream_Read( stm, &buffer.dbh.cbSize, sizeof (DWORD), &count );
725 if( FAILED( r ) )
726 return r;
727
728 /* make sure that we read the size of the structure even on error */
729 size = sizeof buffer - sizeof (DWORD);
730 if( buffer.dbh.cbSize != sizeof buffer )
731 {
732 ERR("Ooops. This structure is not as expected...\n");
733 return E_FAIL;
734 }
735
736 r = IStream_Read( stm, &buffer.dbh.dwSignature, size, &count );
737 if( FAILED( r ) )
738 return r;
739
740 if( count != size )
741 return E_FAIL;
742
743 TRACE("magic %08lx string = %s\n", buffer.dbh.dwSignature, debugstr_w(buffer.szwDarwinID));
744
745 if( (buffer.dbh.dwSignature&0xffff0000) != 0xa0000000 )
746 {
747 ERR("Unknown magic number %08lx in advertised shortcut\n", buffer.dbh.dwSignature);
748 return E_FAIL;
749 }
750
751 *str = HeapAlloc( GetProcessHeap(), 0,
752 (lstrlenW(buffer.szwDarwinID)+1) * sizeof(WCHAR) );
753 lstrcpyW( *str, buffer.szwDarwinID );
754
755 return S_OK;
756 }
757
758 /************************************************************************
759 * IPersistStream_Load (IPersistStream)
760 */
761 static HRESULT WINAPI IPersistStream_fnLoad(
762 IPersistStream* iface,
763 IStream* stm)
764 {
765 LINK_HEADER hdr;
766 ULONG dwBytesRead;
767 BOOL unicode;
768 HRESULT r;
769 DWORD zero;
770
771 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
772
773 TRACE("%p %p\n", This, stm);
774
775 if( !stm )
776 return STG_E_INVALIDPOINTER;
777
778 dwBytesRead = 0;
779 r = IStream_Read(stm, &hdr, sizeof(hdr), &dwBytesRead);
780 if( FAILED( r ) )
781 return r;
782
783 if( dwBytesRead != sizeof(hdr))
784 return E_FAIL;
785 if( hdr.dwSize != sizeof(hdr))
786 return E_FAIL;
787 if( !IsEqualIID(&hdr.MagicGuid, &CLSID_ShellLink) )
788 return E_FAIL;
789
790 /* free all the old stuff */
791 ILFree(This->pPidl);
792 This->pPidl = NULL;
793 memset( &This->volume, 0, sizeof This->volume );
794 HeapFree(GetProcessHeap(), 0, This->sPath);
795 This->sPath = NULL;
796 HeapFree(GetProcessHeap(), 0, This->sDescription);
797 This->sDescription = NULL;
798 HeapFree(GetProcessHeap(), 0, This->sPathRel);
799 This->sPathRel = NULL;
800 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
801 This->sWorkDir = NULL;
802 HeapFree(GetProcessHeap(), 0, This->sArgs);
803 This->sArgs = NULL;
804 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
805 This->sIcoPath = NULL;
806 HeapFree(GetProcessHeap(), 0, This->sProduct);
807 This->sProduct = NULL;
808 HeapFree(GetProcessHeap(), 0, This->sComponent);
809 This->sComponent = NULL;
810
811 This->wHotKey = (WORD)hdr.wHotKey;
812 This->iIcoNdx = hdr.nIcon;
813 FileTimeToSystemTime (&hdr.Time1, &This->time1);
814 FileTimeToSystemTime (&hdr.Time2, &This->time2);
815 FileTimeToSystemTime (&hdr.Time3, &This->time3);
816 if (TRACE_ON(shell))
817 {
818 WCHAR sTemp[MAX_PATH];
819 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time1,
820 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
821 TRACE("-- time1: %s\n", debugstr_w(sTemp) );
822 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time2,
823 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
824 TRACE("-- time2: %s\n", debugstr_w(sTemp) );
825 GetDateFormatW(LOCALE_USER_DEFAULT,DATE_SHORTDATE, &This->time3,
826 NULL, sTemp, sizeof(sTemp)/sizeof(*sTemp));
827 TRACE("-- time3: %s\n", debugstr_w(sTemp) );
828 }
829
830 /* load all the new stuff */
831 if( hdr.dwFlags & SLDF_HAS_ID_LIST )
832 {
833 r = ILLoadFromStream( stm, &This->pPidl );
834 if( FAILED( r ) )
835 return r;
836 }
837 pdump(This->pPidl);
838
839 /* load the location information */
840 if( hdr.dwFlags & SLDF_HAS_LINK_INFO )
841 r = Stream_LoadLocation( stm, &This->volume, &This->sPath );
842 if( FAILED( r ) )
843 goto end;
844
845 unicode = hdr.dwFlags & SLDF_UNICODE;
846 if( hdr.dwFlags & SLDF_HAS_NAME )
847 {
848 r = Stream_LoadString( stm, unicode, &This->sDescription );
849 TRACE("Description -> %s\n",debugstr_w(This->sDescription));
850 }
851 if( FAILED( r ) )
852 goto end;
853
854 if( hdr.dwFlags & SLDF_HAS_RELPATH )
855 {
856 r = Stream_LoadString( stm, unicode, &This->sPathRel );
857 TRACE("Relative Path-> %s\n",debugstr_w(This->sPathRel));
858 }
859 if( FAILED( r ) )
860 goto end;
861
862 if( hdr.dwFlags & SLDF_HAS_WORKINGDIR )
863 {
864 r = Stream_LoadString( stm, unicode, &This->sWorkDir );
865 TRACE("Working Dir -> %s\n",debugstr_w(This->sWorkDir));
866 }
867 if( FAILED( r ) )
868 goto end;
869
870 if( hdr.dwFlags & SLDF_HAS_ARGS )
871 {
872 r = Stream_LoadString( stm, unicode, &This->sArgs );
873 TRACE("Working Dir -> %s\n",debugstr_w(This->sArgs));
874 }
875 if( FAILED( r ) )
876 goto end;
877
878 if( hdr.dwFlags & SLDF_HAS_ICONLOCATION )
879 {
880 r = Stream_LoadString( stm, unicode, &This->sIcoPath );
881 TRACE("Icon file -> %s\n",debugstr_w(This->sIcoPath));
882 }
883 if( FAILED( r ) )
884 goto end;
885
886 if( hdr.dwFlags & SLDF_HAS_LOGO3ID )
887 {
888 r = Stream_LoadAdvertiseInfo( stm, &This->sProduct );
889 TRACE("Product -> %s\n",debugstr_w(This->sProduct));
890 }
891 if( FAILED( r ) )
892 goto end;
893
894 if( hdr.dwFlags & SLDF_HAS_DARWINID )
895 {
896 r = Stream_LoadAdvertiseInfo( stm, &This->sComponent );
897 TRACE("Component -> %s\n",debugstr_w(This->sComponent));
898 }
899 if( FAILED( r ) )
900 goto end;
901
902 r = IStream_Read(stm, &zero, sizeof zero, &dwBytesRead);
903 if( FAILED( r ) || zero || dwBytesRead != sizeof zero )
904 ERR("Last word was not zero\n");
905
906 TRACE("OK\n");
907
908 pdump (This->pPidl);
909
910 return S_OK;
911 end:
912 return r;
913 }
914
915 /************************************************************************
916 * Stream_WriteString
917 *
918 * Helper function for IPersistStream_Save. Writes a unicode string
919 * with terminating nul byte to a stream, preceded by the its length.
920 */
921 static HRESULT Stream_WriteString( IStream* stm, LPCWSTR str )
922 {
923 USHORT len = lstrlenW( str ) + 1;
924 DWORD count;
925 HRESULT r;
926
927 r = IStream_Write( stm, &len, sizeof(len), &count );
928 if( FAILED( r ) )
929 return r;
930
931 len *= sizeof(WCHAR);
932
933 r = IStream_Write( stm, str, len, &count );
934 if( FAILED( r ) )
935 return r;
936
937 return S_OK;
938 }
939
940 /************************************************************************
941 * Stream_WriteLocationInfo
942 *
943 * Writes the location info to a stream
944 *
945 * FIXME: One day we might want to write the network volume information
946 * and the final path.
947 * Figure out how Windows deals with unicode paths here.
948 */
949 static HRESULT Stream_WriteLocationInfo( IStream* stm, LPCWSTR path,
950 volume_info *volume )
951 {
952 DWORD total_size, path_size, volume_info_size, label_size, final_path_size;
953 LOCAL_VOLUME_INFO *vol;
954 LOCATION_INFO *loc;
955 LPSTR szLabel, szPath, szFinalPath;
956 ULONG count = 0;
957
958 TRACE("%p %s %p\n", stm, debugstr_w(path), volume);
959
960 /* figure out the size of everything */
961 label_size = WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
962 NULL, 0, NULL, NULL );
963 path_size = WideCharToMultiByte( CP_ACP, 0, path, -1,
964 NULL, 0, NULL, NULL );
965 volume_info_size = sizeof *vol + label_size;
966 final_path_size = 1;
967 total_size = sizeof *loc + volume_info_size + path_size + final_path_size;
968
969 /* create pointers to everything */
970 loc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, total_size);
971 vol = (LOCAL_VOLUME_INFO*) &loc[1];
972 szLabel = (LPSTR) &vol[1];
973 szPath = &szLabel[label_size];
974 szFinalPath = &szPath[path_size];
975
976 /* fill in the location information header */
977 loc->dwTotalSize = total_size;
978 loc->dwHeaderSize = sizeof (*loc);
979 loc->dwFlags = 1;
980 loc->dwVolTableOfs = sizeof (*loc);
981 loc->dwLocalPathOfs = sizeof (*loc) + volume_info_size;
982 loc->dwNetworkVolTableOfs = 0;
983 loc->dwFinalPathOfs = sizeof (*loc) + volume_info_size + path_size;
984
985 /* fill in the volume information */
986 vol->dwSize = volume_info_size;
987 vol->dwType = volume->type;
988 vol->dwVolSerial = volume->serial;
989 vol->dwVolLabelOfs = sizeof (*vol);
990
991 /* copy in the strings */
992 WideCharToMultiByte( CP_ACP, 0, volume->label, -1,
993 szLabel, label_size, NULL, NULL );
994 WideCharToMultiByte( CP_ACP, 0, path, -1,
995 szPath, path_size, NULL, NULL );
996 szFinalPath[0] = 0;
997
998 return IStream_Write( stm, loc, total_size, &count );
999 }
1000
1001 static HRESULT Stream_WriteAdvertiseInfo( IStream* stm, LPCWSTR string, DWORD magic )
1002 {
1003 ULONG count;
1004 EXP_DARWIN_LINK buffer;
1005
1006 TRACE("%p\n",stm);
1007
1008 memset( &buffer, 0, sizeof buffer );
1009 buffer.dbh.cbSize = sizeof buffer;
1010 buffer.dbh.dwSignature = magic;
1011 lstrcpynW( buffer.szwDarwinID, string, MAX_PATH );
1012 WideCharToMultiByte(CP_ACP, 0, string, -1, buffer.szDarwinID, MAX_PATH, NULL, NULL );
1013
1014 return IStream_Write( stm, &buffer, buffer.dbh.cbSize, &count );
1015 }
1016
1017 /************************************************************************
1018 * IPersistStream_Save (IPersistStream)
1019 *
1020 * FIXME: makes assumptions about byte order
1021 */
1022 static HRESULT WINAPI IPersistStream_fnSave(
1023 IPersistStream* iface,
1024 IStream* stm,
1025 BOOL fClearDirty)
1026 {
1027 static const WCHAR wOpen[] = {'o','p','e','n',0};
1028
1029 LINK_HEADER header;
1030 WCHAR exePath[MAX_PATH];
1031 ULONG count;
1032 DWORD zero;
1033 HRESULT r;
1034
1035 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
1036
1037 TRACE("%p %p %x\n", This, stm, fClearDirty);
1038
1039 *exePath = '\0';
1040
1041 if (This->sPath)
1042 {
1043 SHELL_FindExecutable(NULL, This->sPath, wOpen, exePath, MAX_PATH,
1044 NULL, NULL, NULL, NULL);
1045 /*
1046 * windows can create lnk files to executables that do not exist yet
1047 * so if the executable does not exist the just trust the path they
1048 * gave us
1049 */
1050 if (!*exePath) lstrcpyW(exePath,This->sPath);
1051 }
1052
1053 memset(&header, 0, sizeof(header));
1054 header.dwSize = sizeof(header);
1055 header.fStartup = This->iShowCmd;
1056 memcpy(&header.MagicGuid, &CLSID_ShellLink, sizeof(header.MagicGuid) );
1057
1058 header.wHotKey = This->wHotKey;
1059 header.nIcon = This->iIcoNdx;
1060 header.dwFlags = SLDF_UNICODE; /* strings are in unicode */
1061 if( This->pPidl )
1062 header.dwFlags |= SLDF_HAS_ID_LIST;
1063 if( This->sPath )
1064 header.dwFlags |= SLDF_HAS_LINK_INFO;
1065 if( This->sDescription )
1066 header.dwFlags |= SLDF_HAS_NAME;
1067 if( This->sWorkDir )
1068 header.dwFlags |= SLDF_HAS_WORKINGDIR;
1069 if( This->sArgs )
1070 header.dwFlags |= SLDF_HAS_ARGS;
1071 if( This->sIcoPath )
1072 header.dwFlags |= SLDF_HAS_ICONLOCATION;
1073 if( This->sProduct )
1074 header.dwFlags |= SLDF_HAS_LOGO3ID;
1075 if( This->sComponent )
1076 header.dwFlags |= SLDF_HAS_DARWINID;
1077
1078 SystemTimeToFileTime ( &This->time1, &header.Time1 );
1079 SystemTimeToFileTime ( &This->time2, &header.Time2 );
1080 SystemTimeToFileTime ( &This->time3, &header.Time3 );
1081
1082 /* write the Shortcut header */
1083 r = IStream_Write( stm, &header, sizeof(header), &count );
1084 if( FAILED( r ) )
1085 {
1086 ERR("Write failed at %d\n",__LINE__);
1087 return r;
1088 }
1089
1090 TRACE("Writing pidl \n");
1091
1092 /* write the PIDL to the shortcut */
1093 if( This->pPidl )
1094 {
1095 r = ILSaveToStream( stm, This->pPidl );
1096 if( FAILED( r ) )
1097 {
1098 ERR("Failed to write PIDL at %d\n",__LINE__);
1099 return r;
1100 }
1101 }
1102
1103 if( This->sPath )
1104 Stream_WriteLocationInfo( stm, exePath, &This->volume );
1105
1106 if( This->sDescription )
1107 r = Stream_WriteString( stm, This->sDescription );
1108
1109 if( This->sPathRel )
1110 r = Stream_WriteString( stm, This->sPathRel );
1111
1112 if( This->sWorkDir )
1113 r = Stream_WriteString( stm, This->sWorkDir );
1114
1115 if( This->sArgs )
1116 r = Stream_WriteString( stm, This->sArgs );
1117
1118 if( This->sIcoPath )
1119 r = Stream_WriteString( stm, This->sIcoPath );
1120
1121 if( This->sProduct )
1122 r = Stream_WriteAdvertiseInfo( stm, This->sProduct, EXP_SZ_ICON_SIG );
1123
1124 if( This->sComponent )
1125 r = Stream_WriteAdvertiseInfo( stm, This->sComponent, EXP_DARWIN_ID_SIG );
1126
1127 /* the last field is a single zero dword */
1128 zero = 0;
1129 r = IStream_Write( stm, &zero, sizeof zero, &count );
1130
1131 return S_OK;
1132 }
1133
1134 /************************************************************************
1135 * IPersistStream_GetSizeMax (IPersistStream)
1136 */
1137 static HRESULT WINAPI IPersistStream_fnGetSizeMax(
1138 IPersistStream* iface,
1139 ULARGE_INTEGER* pcbSize)
1140 {
1141 _ICOM_THIS_From_IPersistStream(IShellLinkImpl, iface);
1142
1143 TRACE("(%p)\n", This);
1144
1145 return E_NOTIMPL;
1146 }
1147
1148 static const IPersistStreamVtbl psvt =
1149 {
1150 IPersistStream_fnQueryInterface,
1151 IPersistStream_fnAddRef,
1152 IPersistStream_fnRelease,
1153 IPersistStream_fnGetClassID,
1154 IPersistStream_fnIsDirty,
1155 IPersistStream_fnLoad,
1156 IPersistStream_fnSave,
1157 IPersistStream_fnGetSizeMax
1158 };
1159
1160 /**************************************************************************
1161 * IShellLink_Constructor
1162 */
1163 HRESULT WINAPI IShellLink_Constructor( IUnknown *pUnkOuter,
1164 REFIID riid, LPVOID *ppv )
1165 {
1166 IShellLinkImpl * sl;
1167
1168 TRACE("unkOut=%p riid=%s\n",pUnkOuter, debugstr_guid(riid));
1169
1170 *ppv = NULL;
1171
1172 if (pUnkOuter)
1173 return CLASS_E_NOAGGREGATION;
1174 sl = LocalAlloc(LMEM_ZEROINIT,sizeof(IShellLinkImpl));
1175 if (!sl)
1176 return E_OUTOFMEMORY;
1177
1178 sl->ref = 1;
1179 sl->lpVtbl = &slvt;
1180 sl->lpvtblw = &slvtw;
1181 sl->lpvtblPersistFile = &pfvt;
1182 sl->lpvtblPersistStream = &psvt;
1183 sl->lpvtblShellLinkDataList = &dlvt;
1184 sl->lpvtblShellExtInit = &eivt;
1185 sl->lpvtblContextMenu = &cmvt;
1186 sl->iShowCmd = SW_SHOWNORMAL;
1187 sl->bDirty = FALSE;
1188
1189 TRACE("(%p)->()\n",sl);
1190
1191 if (IsEqualIID(riid, &IID_IUnknown) ||
1192 IsEqualIID(riid, &IID_IShellLinkA))
1193 *ppv = sl;
1194 else if (IsEqualIID(riid, &IID_IShellLinkW))
1195 *ppv = &(sl->lpvtblw);
1196 else {
1197 LocalFree((HLOCAL)sl);
1198 ERR("E_NOINTERFACE\n");
1199 return E_NOINTERFACE;
1200 }
1201
1202 return S_OK;
1203 }
1204
1205
1206 static BOOL SHELL_ExistsFileW(LPCWSTR path)
1207 {
1208 if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(path))
1209 return FALSE;
1210 return TRUE;
1211 }
1212
1213 /**************************************************************************
1214 * ShellLink_UpdatePath
1215 * update absolute path in sPath using relative path in sPathRel
1216 */
1217 static HRESULT ShellLink_UpdatePath(LPWSTR sPathRel, LPCWSTR path, LPCWSTR sWorkDir, LPWSTR* psPath)
1218 {
1219 if (!path || !psPath)
1220 return E_INVALIDARG;
1221
1222 if (!*psPath && sPathRel) {
1223 WCHAR buffer[2*MAX_PATH], abs_path[2*MAX_PATH];
1224 LPWSTR final = NULL;
1225
1226 /* first try if [directory of link file] + [relative path] finds an existing file */
1227
1228 GetFullPathNameW( path, MAX_PATH*2, buffer, &final );
1229 if( !final )
1230 final = buffer;
1231 lstrcpyW(final, sPathRel);
1232
1233 *abs_path = '\0';
1234
1235 if (SHELL_ExistsFileW(buffer)) {
1236 if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
1237 lstrcpyW(abs_path, buffer);
1238 } else {
1239 /* try if [working directory] + [relative path] finds an existing file */
1240 if (sWorkDir) {
1241 lstrcpyW(buffer, sWorkDir);
1242 lstrcpyW(PathAddBackslashW(buffer), sPathRel);
1243
1244 if (SHELL_ExistsFileW(buffer))
1245 if (!GetFullPathNameW(buffer, MAX_PATH, abs_path, &final))
1246 lstrcpyW(abs_path, buffer);
1247 }
1248 }
1249
1250 /* FIXME: This is even not enough - not all shell links can be resolved using this algorithm. */
1251 if (!*abs_path)
1252 lstrcpyW(abs_path, sPathRel);
1253
1254 *psPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(abs_path)+1)*sizeof(WCHAR));
1255 if (!*psPath)
1256 return E_OUTOFMEMORY;
1257
1258 lstrcpyW(*psPath, abs_path);
1259 }
1260
1261 return S_OK;
1262 }
1263
1264 /**************************************************************************
1265 * IShellLink_ConstructFromFile
1266 */
1267 HRESULT WINAPI IShellLink_ConstructFromFile( IUnknown* pUnkOuter, REFIID riid,
1268 LPCITEMIDLIST pidl, LPVOID* ppv)
1269 {
1270 IShellLinkW* psl;
1271
1272 HRESULT hr = IShellLink_Constructor(NULL, riid, (LPVOID*)&psl);
1273
1274 if (SUCCEEDED(hr)) {
1275 IPersistFile* ppf;
1276
1277 *ppv = NULL;
1278
1279 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);
1280
1281 if (SUCCEEDED(hr)) {
1282 WCHAR path[MAX_PATH];
1283
1284 if (SHGetPathFromIDListW(pidl, path))
1285 hr = IPersistFile_Load(ppf, path, 0);
1286 else
1287 hr = E_FAIL;
1288
1289 if (SUCCEEDED(hr))
1290 *ppv = (IUnknown*) psl;
1291
1292 IPersistFile_Release(ppf);
1293 }
1294
1295 if (!*ppv)
1296 IShellLinkW_Release(psl);
1297 }
1298
1299 return hr;
1300 }
1301
1302 /**************************************************************************
1303 * IShellLinkA_QueryInterface
1304 */
1305 static HRESULT WINAPI IShellLinkA_fnQueryInterface( IShellLinkA * iface, REFIID riid, LPVOID *ppvObj)
1306 {
1307 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1308 return ShellLink_QueryInterface( This, riid, ppvObj );
1309 }
1310
1311 /******************************************************************************
1312 * IShellLinkA_AddRef
1313 */
1314 static ULONG WINAPI IShellLinkA_fnAddRef(IShellLinkA * iface)
1315 {
1316 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1317 return ShellLink_AddRef( This );
1318 }
1319
1320 /******************************************************************************
1321 * IShellLinkA_Release
1322 */
1323 static ULONG WINAPI IShellLinkA_fnRelease(IShellLinkA * iface)
1324 {
1325 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1326 return ShellLink_Release( This );
1327 }
1328
1329 static HRESULT WINAPI IShellLinkA_fnGetPath(IShellLinkA * iface, LPSTR pszFile,
1330 INT cchMaxPath, WIN32_FIND_DATAA *pfd, DWORD fFlags)
1331 {
1332 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1333
1334 TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%lu)(%s)\n",
1335 This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1336
1337 if (This->sComponent || This->sProduct)
1338 return S_FALSE;
1339
1340 if (cchMaxPath)
1341 pszFile[0] = 0;
1342 if (This->sPath)
1343 WideCharToMultiByte( CP_ACP, 0, This->sPath, -1,
1344 pszFile, cchMaxPath, NULL, NULL);
1345
1346 if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);
1347
1348 return S_OK;
1349 }
1350
1351 static HRESULT WINAPI IShellLinkA_fnGetIDList(IShellLinkA * iface, LPITEMIDLIST * ppidl)
1352 {
1353 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1354
1355 TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1356
1357 return IShellLinkW_GetIDList((IShellLinkW*)&(This->lpvtblw), ppidl);
1358 }
1359
1360 static HRESULT WINAPI IShellLinkA_fnSetIDList(IShellLinkA * iface, LPCITEMIDLIST pidl)
1361 {
1362 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1363
1364 TRACE("(%p)->(pidl=%p)\n",This, pidl);
1365
1366 if (This->pPidl)
1367 ILFree(This->pPidl);
1368 This->pPidl = ILClone (pidl);
1369 This->bDirty = TRUE;
1370
1371 return S_OK;
1372 }
1373
1374 static HRESULT WINAPI IShellLinkA_fnGetDescription(IShellLinkA * iface, LPSTR pszName,INT cchMaxName)
1375 {
1376 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1377
1378 TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1379
1380 if( cchMaxName )
1381 pszName[0] = 0;
1382 if( This->sDescription )
1383 WideCharToMultiByte( CP_ACP, 0, This->sDescription, -1,
1384 pszName, cchMaxName, NULL, NULL);
1385
1386 return S_OK;
1387 }
1388
1389 static HRESULT WINAPI IShellLinkA_fnSetDescription(IShellLinkA * iface, LPCSTR pszName)
1390 {
1391 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1392
1393 TRACE("(%p)->(pName=%s)\n", This, pszName);
1394
1395 HeapFree(GetProcessHeap(), 0, This->sDescription);
1396 This->sDescription = HEAP_strdupAtoW( GetProcessHeap(), 0, pszName);
1397 if ( !This->sDescription )
1398 return E_OUTOFMEMORY;
1399
1400 This->bDirty = TRUE;
1401
1402 return S_OK;
1403 }
1404
1405 static HRESULT WINAPI IShellLinkA_fnGetWorkingDirectory(IShellLinkA * iface, LPSTR pszDir,INT cchMaxPath)
1406 {
1407 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1408
1409 TRACE("(%p)->(%p len=%u)\n", This, pszDir, cchMaxPath);
1410
1411 if( cchMaxPath )
1412 pszDir[0] = 0;
1413 if( This->sWorkDir )
1414 WideCharToMultiByte( CP_ACP, 0, This->sWorkDir, -1,
1415 pszDir, cchMaxPath, NULL, NULL);
1416
1417 return S_OK;
1418 }
1419
1420 static HRESULT WINAPI IShellLinkA_fnSetWorkingDirectory(IShellLinkA * iface, LPCSTR pszDir)
1421 {
1422 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1423
1424 TRACE("(%p)->(dir=%s)\n",This, pszDir);
1425
1426 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1427 This->sWorkDir = HEAP_strdupAtoW( GetProcessHeap(), 0, pszDir);
1428 if ( !This->sWorkDir )
1429 return E_OUTOFMEMORY;
1430
1431 This->bDirty = TRUE;
1432
1433 return S_OK;
1434 }
1435
1436 static HRESULT WINAPI IShellLinkA_fnGetArguments(IShellLinkA * iface, LPSTR pszArgs,INT cchMaxPath)
1437 {
1438 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1439
1440 TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1441
1442 if( cchMaxPath )
1443 pszArgs[0] = 0;
1444 if( This->sArgs )
1445 WideCharToMultiByte( CP_ACP, 0, This->sArgs, -1,
1446 pszArgs, cchMaxPath, NULL, NULL);
1447
1448 return S_OK;
1449 }
1450
1451 static HRESULT WINAPI IShellLinkA_fnSetArguments(IShellLinkA * iface, LPCSTR pszArgs)
1452 {
1453 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1454
1455 TRACE("(%p)->(args=%s)\n",This, pszArgs);
1456
1457 HeapFree(GetProcessHeap(), 0, This->sArgs);
1458 This->sArgs = HEAP_strdupAtoW( GetProcessHeap(), 0, pszArgs);
1459 if( !This->sArgs )
1460 return E_OUTOFMEMORY;
1461
1462 This->bDirty = TRUE;
1463
1464 return S_OK;
1465 }
1466
1467 static HRESULT WINAPI IShellLinkA_fnGetHotkey(IShellLinkA * iface, WORD *pwHotkey)
1468 {
1469 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1470
1471 TRACE("(%p)->(%p)(0x%08x)\n",This, pwHotkey, This->wHotKey);
1472
1473 *pwHotkey = This->wHotKey;
1474
1475 return S_OK;
1476 }
1477
1478 static HRESULT WINAPI IShellLinkA_fnSetHotkey(IShellLinkA * iface, WORD wHotkey)
1479 {
1480 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1481
1482 TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1483
1484 This->wHotKey = wHotkey;
1485 This->bDirty = TRUE;
1486
1487 return S_OK;
1488 }
1489
1490 static HRESULT WINAPI IShellLinkA_fnGetShowCmd(IShellLinkA * iface, INT *piShowCmd)
1491 {
1492 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1493
1494 TRACE("(%p)->(%p)\n",This, piShowCmd);
1495 *piShowCmd = This->iShowCmd;
1496 return S_OK;
1497 }
1498
1499 static HRESULT WINAPI IShellLinkA_fnSetShowCmd(IShellLinkA * iface, INT iShowCmd)
1500 {
1501 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1502
1503 TRACE("(%p) %d\n",This, iShowCmd);
1504
1505 This->iShowCmd = iShowCmd;
1506 This->bDirty = TRUE;
1507
1508 return NOERROR;
1509 }
1510
1511 static HRESULT SHELL_PidlGeticonLocationA(IShellFolder* psf, LPITEMIDLIST pidl, LPSTR pszIconPath, int cchIconPath, int* piIcon)
1512 {
1513 LPCITEMIDLIST pidlLast;
1514
1515 HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);
1516
1517 if (SUCCEEDED(hr)) {
1518 IExtractIconA* pei;
1519
1520 hr = IShellFolder_GetUIObjectOf(psf, 0, 1, (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconA, NULL, (LPVOID*)&pei);
1521
1522 if (SUCCEEDED(hr)) {
1523 hr = IExtractIconA_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);
1524
1525 IExtractIconA_Release(pei);
1526 }
1527
1528 IShellFolder_Release(psf);
1529 }
1530
1531 return hr;
1532 }
1533
1534 static HRESULT WINAPI IShellLinkA_fnGetIconLocation(IShellLinkA * iface, LPSTR pszIconPath,INT cchIconPath,INT *piIcon)
1535 {
1536 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1537
1538 TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1539
1540 pszIconPath[0] = 0;
1541 *piIcon = This->iIcoNdx;
1542
1543 if (This->sIcoPath)
1544 {
1545 WideCharToMultiByte(CP_ACP, 0, This->sIcoPath, -1, pszIconPath, cchIconPath, NULL, NULL);
1546 return S_OK;
1547 }
1548
1549 if (This->pPidl || This->sPath)
1550 {
1551 IShellFolder* pdsk;
1552
1553 HRESULT hr = SHGetDesktopFolder(&pdsk);
1554
1555 if (SUCCEEDED(hr))
1556 {
1557 /* first look for an icon using the PIDL (if present) */
1558 if (This->pPidl)
1559 hr = SHELL_PidlGeticonLocationA(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
1560 else
1561 hr = E_FAIL;
1562
1563 /* if we couldn't find an icon yet, look for it using the file system path */
1564 if (FAILED(hr) && This->sPath)
1565 {
1566 LPITEMIDLIST pidl;
1567
1568 hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);
1569
1570 if (SUCCEEDED(hr)) {
1571 hr = SHELL_PidlGeticonLocationA(pdsk, pidl, pszIconPath, cchIconPath, piIcon);
1572
1573 SHFree(pidl);
1574 }
1575 }
1576
1577 IShellFolder_Release(pdsk);
1578 }
1579
1580 return hr;
1581 }
1582 return S_OK;
1583 }
1584
1585 static HRESULT WINAPI IShellLinkA_fnSetIconLocation(IShellLinkA * iface, LPCSTR pszIconPath,INT iIcon)
1586 {
1587 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1588
1589 TRACE("(%p)->(path=%s iicon=%u)\n",This, pszIconPath, iIcon);
1590
1591 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1592 This->sIcoPath = HEAP_strdupAtoW(GetProcessHeap(), 0, pszIconPath);
1593 if ( !This->sIcoPath )
1594 return E_OUTOFMEMORY;
1595
1596 This->iIcoNdx = iIcon;
1597 This->bDirty = TRUE;
1598
1599 return S_OK;
1600 }
1601
1602 static HRESULT WINAPI IShellLinkA_fnSetRelativePath(IShellLinkA * iface, LPCSTR pszPathRel, DWORD dwReserved)
1603 {
1604 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1605
1606 TRACE("(%p)->(path=%s %lx)\n",This, pszPathRel, dwReserved);
1607
1608 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1609 This->sPathRel = HEAP_strdupAtoW(GetProcessHeap(), 0, pszPathRel);
1610 This->bDirty = TRUE;
1611
1612 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1613 }
1614
1615 static HRESULT WINAPI IShellLinkA_fnResolve(IShellLinkA * iface, HWND hwnd, DWORD fFlags)
1616 {
1617 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1618
1619 TRACE("(%p)->(hwnd=%p flags=%lx)\n",This, hwnd, fFlags);
1620
1621 return IShellLinkW_Resolve( (IShellLinkW*)&(This->lpvtblw), hwnd, fFlags );
1622 }
1623
1624 static HRESULT WINAPI IShellLinkA_fnSetPath(IShellLinkA * iface, LPCSTR pszFile)
1625 {
1626 HRESULT r;
1627 LPWSTR str;
1628 IShellLinkImpl *This = (IShellLinkImpl *)iface;
1629
1630 TRACE("(%p)->(path=%s)\n",This, pszFile);
1631
1632 str = HEAP_strdupAtoW(GetProcessHeap(), 0, pszFile);
1633 if( !str )
1634 return E_OUTOFMEMORY;
1635
1636 r = IShellLinkW_SetPath((IShellLinkW*)&(This->lpvtblw), str);
1637 HeapFree( GetProcessHeap(), 0, str );
1638
1639 return r;
1640 }
1641
1642 /**************************************************************************
1643 * IShellLink Implementation
1644 */
1645
1646 static const IShellLinkAVtbl slvt =
1647 {
1648 IShellLinkA_fnQueryInterface,
1649 IShellLinkA_fnAddRef,
1650 IShellLinkA_fnRelease,
1651 IShellLinkA_fnGetPath,
1652 IShellLinkA_fnGetIDList,
1653 IShellLinkA_fnSetIDList,
1654 IShellLinkA_fnGetDescription,
1655 IShellLinkA_fnSetDescription,
1656 IShellLinkA_fnGetWorkingDirectory,
1657 IShellLinkA_fnSetWorkingDirectory,
1658 IShellLinkA_fnGetArguments,
1659 IShellLinkA_fnSetArguments,
1660 IShellLinkA_fnGetHotkey,
1661 IShellLinkA_fnSetHotkey,
1662 IShellLinkA_fnGetShowCmd,
1663 IShellLinkA_fnSetShowCmd,
1664 IShellLinkA_fnGetIconLocation,
1665 IShellLinkA_fnSetIconLocation,
1666 IShellLinkA_fnSetRelativePath,
1667 IShellLinkA_fnResolve,
1668 IShellLinkA_fnSetPath
1669 };
1670
1671
1672 /**************************************************************************
1673 * IShellLinkW_fnQueryInterface
1674 */
1675 static HRESULT WINAPI IShellLinkW_fnQueryInterface(
1676 IShellLinkW * iface, REFIID riid, LPVOID *ppvObj)
1677 {
1678 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1679 return ShellLink_QueryInterface( This, riid, ppvObj );
1680 }
1681
1682 /******************************************************************************
1683 * IShellLinkW_fnAddRef
1684 */
1685 static ULONG WINAPI IShellLinkW_fnAddRef(IShellLinkW * iface)
1686 {
1687 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1688 return ShellLink_AddRef( This );
1689 }
1690
1691 /******************************************************************************
1692 * IShellLinkW_fnRelease
1693 */
1694 static ULONG WINAPI IShellLinkW_fnRelease(IShellLinkW * iface)
1695 {
1696 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1697 return ShellLink_Release( This );
1698 }
1699
1700 static HRESULT WINAPI IShellLinkW_fnGetPath(IShellLinkW * iface, LPWSTR pszFile,INT cchMaxPath, WIN32_FIND_DATAW *pfd, DWORD fFlags)
1701 {
1702 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1703
1704 TRACE("(%p)->(pfile=%p len=%u find_data=%p flags=%lu)(%s)\n",
1705 This, pszFile, cchMaxPath, pfd, fFlags, debugstr_w(This->sPath));
1706
1707 if (This->sComponent || This->sProduct)
1708 return S_FALSE;
1709
1710 if (cchMaxPath)
1711 pszFile[0] = 0;
1712 if (This->sPath)
1713 lstrcpynW( pszFile, This->sPath, cchMaxPath );
1714
1715 if (pfd) FIXME("(%p): WIN32_FIND_DATA is not yet filled.\n", This);
1716
1717 return S_OK;
1718 }
1719
1720 static HRESULT WINAPI IShellLinkW_fnGetIDList(IShellLinkW * iface, LPITEMIDLIST * ppidl)
1721 {
1722 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1723
1724 TRACE("(%p)->(ppidl=%p)\n",This, ppidl);
1725
1726 if (!This->pPidl)
1727 return S_FALSE;
1728 *ppidl = ILClone(This->pPidl);
1729 return S_OK;
1730 }
1731
1732 static HRESULT WINAPI IShellLinkW_fnSetIDList(IShellLinkW * iface, LPCITEMIDLIST pidl)
1733 {
1734 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1735
1736 TRACE("(%p)->(pidl=%p)\n",This, pidl);
1737
1738 if( This->pPidl )
1739 ILFree( This->pPidl );
1740 This->pPidl = ILClone( pidl );
1741 if( !This->pPidl )
1742 return E_FAIL;
1743
1744 This->bDirty = TRUE;
1745
1746 return S_OK;
1747 }
1748
1749 static HRESULT WINAPI IShellLinkW_fnGetDescription(IShellLinkW * iface, LPWSTR pszName,INT cchMaxName)
1750 {
1751 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1752
1753 TRACE("(%p)->(%p len=%u)\n",This, pszName, cchMaxName);
1754
1755 pszName[0] = 0;
1756 if( This->sDescription )
1757 lstrcpynW( pszName, This->sDescription, cchMaxName );
1758
1759 return S_OK;
1760 }
1761
1762 static HRESULT WINAPI IShellLinkW_fnSetDescription(IShellLinkW * iface, LPCWSTR pszName)
1763 {
1764 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1765
1766 TRACE("(%p)->(desc=%s)\n",This, debugstr_w(pszName));
1767
1768 HeapFree(GetProcessHeap(), 0, This->sDescription);
1769 This->sDescription = HeapAlloc( GetProcessHeap(), 0,
1770 (lstrlenW( pszName )+1)*sizeof(WCHAR) );
1771 if ( !This->sDescription )
1772 return E_OUTOFMEMORY;
1773
1774 lstrcpyW( This->sDescription, pszName );
1775 This->bDirty = TRUE;
1776
1777 return S_OK;
1778 }
1779
1780 static HRESULT WINAPI IShellLinkW_fnGetWorkingDirectory(IShellLinkW * iface, LPWSTR pszDir,INT cchMaxPath)
1781 {
1782 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1783
1784 TRACE("(%p)->(%p len %u)\n", This, pszDir, cchMaxPath);
1785
1786 if( cchMaxPath )
1787 pszDir[0] = 0;
1788 if( This->sWorkDir )
1789 lstrcpynW( pszDir, This->sWorkDir, cchMaxPath );
1790
1791 return S_OK;
1792 }
1793
1794 static HRESULT WINAPI IShellLinkW_fnSetWorkingDirectory(IShellLinkW * iface, LPCWSTR pszDir)
1795 {
1796 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1797
1798 TRACE("(%p)->(dir=%s)\n",This, debugstr_w(pszDir));
1799
1800 HeapFree(GetProcessHeap(), 0, This->sWorkDir);
1801 This->sWorkDir = HeapAlloc( GetProcessHeap(), 0,
1802 (lstrlenW( pszDir )+1)*sizeof (WCHAR) );
1803 if ( !This->sWorkDir )
1804 return E_OUTOFMEMORY;
1805 lstrcpyW( This->sWorkDir, pszDir );
1806 This->bDirty = TRUE;
1807
1808 return S_OK;
1809 }
1810
1811 static HRESULT WINAPI IShellLinkW_fnGetArguments(IShellLinkW * iface, LPWSTR pszArgs,INT cchMaxPath)
1812 {
1813 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1814
1815 TRACE("(%p)->(%p len=%u)\n", This, pszArgs, cchMaxPath);
1816
1817 if( cchMaxPath )
1818 pszArgs[0] = 0;
1819 if( This->sArgs )
1820 lstrcpynW( pszArgs, This->sArgs, cchMaxPath );
1821
1822 return NOERROR;
1823 }
1824
1825 static HRESULT WINAPI IShellLinkW_fnSetArguments(IShellLinkW * iface, LPCWSTR pszArgs)
1826 {
1827 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1828
1829 TRACE("(%p)->(args=%s)\n",This, debugstr_w(pszArgs));
1830
1831 HeapFree(GetProcessHeap(), 0, This->sArgs);
1832 This->sArgs = HeapAlloc( GetProcessHeap(), 0,
1833 (lstrlenW( pszArgs )+1)*sizeof (WCHAR) );
1834 if ( !This->sArgs )
1835 return E_OUTOFMEMORY;
1836 lstrcpyW( This->sArgs, pszArgs );
1837 This->bDirty = TRUE;
1838
1839 return S_OK;
1840 }
1841
1842 static HRESULT WINAPI IShellLinkW_fnGetHotkey(IShellLinkW * iface, WORD *pwHotkey)
1843 {
1844 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1845
1846 TRACE("(%p)->(%p)\n",This, pwHotkey);
1847
1848 *pwHotkey=This->wHotKey;
1849
1850 return S_OK;
1851 }
1852
1853 static HRESULT WINAPI IShellLinkW_fnSetHotkey(IShellLinkW * iface, WORD wHotkey)
1854 {
1855 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1856
1857 TRACE("(%p)->(hotkey=%x)\n",This, wHotkey);
1858
1859 This->wHotKey = wHotkey;
1860 This->bDirty = TRUE;
1861
1862 return S_OK;
1863 }
1864
1865 static HRESULT WINAPI IShellLinkW_fnGetShowCmd(IShellLinkW * iface, INT *piShowCmd)
1866 {
1867 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1868
1869 TRACE("(%p)->(%p)\n",This, piShowCmd);
1870
1871 *piShowCmd = This->iShowCmd;
1872
1873 return S_OK;
1874 }
1875
1876 static HRESULT WINAPI IShellLinkW_fnSetShowCmd(IShellLinkW * iface, INT iShowCmd)
1877 {
1878 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1879
1880 This->iShowCmd = iShowCmd;
1881 This->bDirty = TRUE;
1882
1883 return S_OK;
1884 }
1885
1886 static HRESULT SHELL_PidlGeticonLocationW(IShellFolder* psf, LPITEMIDLIST pidl, LPWSTR pszIconPath, int cchIconPath, int* piIcon)
1887 {
1888 LPCITEMIDLIST pidlLast;
1889
1890 HRESULT hr = SHBindToParent(pidl, &IID_IShellFolder, (LPVOID*)&psf, &pidlLast);
1891
1892 if (SUCCEEDED(hr)) {
1893 IExtractIconW* pei;
1894
1895 hr = IShellFolder_GetUIObjectOf(psf, 0, 1, (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconW, NULL, (LPVOID*)&pei);
1896
1897 if (SUCCEEDED(hr)) {
1898 hr = IExtractIconW_GetIconLocation(pei, 0, pszIconPath, MAX_PATH, piIcon, NULL);
1899
1900 IExtractIconW_Release(pei);
1901 }
1902
1903 IShellFolder_Release(psf);
1904 }
1905
1906 return hr;
1907 }
1908
1909 static HRESULT WINAPI IShellLinkW_fnGetIconLocation(IShellLinkW * iface, LPWSTR pszIconPath,INT cchIconPath,INT *piIcon)
1910 {
1911 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1912
1913 TRACE("(%p)->(%p len=%u iicon=%p)\n", This, pszIconPath, cchIconPath, piIcon);
1914
1915 pszIconPath[0] = 0;
1916 *piIcon = This->iIcoNdx;
1917
1918 if (This->sIcoPath)
1919 {
1920 lstrcpynW(pszIconPath, This->sIcoPath, cchIconPath);
1921 return S_OK;
1922 }
1923
1924 if (This->pPidl || This->sPath)
1925 {
1926 IShellFolder* pdsk;
1927
1928 HRESULT hr = SHGetDesktopFolder(&pdsk);
1929
1930 if (SUCCEEDED(hr))
1931 {
1932 /* first look for an icon using the PIDL (if present) */
1933 if (This->pPidl)
1934 hr = SHELL_PidlGeticonLocationW(pdsk, This->pPidl, pszIconPath, cchIconPath, piIcon);
1935 else
1936 hr = E_FAIL;
1937
1938 /* if we couldn't find an icon yet, look for it using the file system path */
1939 if (FAILED(hr) && This->sPath)
1940 {
1941 LPITEMIDLIST pidl;
1942
1943 hr = IShellFolder_ParseDisplayName(pdsk, 0, NULL, This->sPath, NULL, &pidl, NULL);
1944
1945 if (SUCCEEDED(hr))
1946 {
1947 hr = SHELL_PidlGeticonLocationW(pdsk, pidl, pszIconPath, cchIconPath, piIcon);
1948
1949 SHFree(pidl);
1950 }
1951 }
1952
1953 IShellFolder_Release(pdsk);
1954 }
1955 return hr;
1956 }
1957 return S_OK;
1958 }
1959
1960 static HRESULT WINAPI IShellLinkW_fnSetIconLocation(IShellLinkW * iface, LPCWSTR pszIconPath,INT iIcon)
1961 {
1962 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1963
1964 TRACE("(%p)->(path=%s iicon=%u)\n",This, debugstr_w(pszIconPath), iIcon);
1965
1966 HeapFree(GetProcessHeap(), 0, This->sIcoPath);
1967 This->sIcoPath = HeapAlloc( GetProcessHeap(), 0,
1968 (lstrlenW( pszIconPath )+1)*sizeof (WCHAR) );
1969 if ( !This->sIcoPath )
1970 return E_OUTOFMEMORY;
1971 lstrcpyW( This->sIcoPath, pszIconPath );
1972
1973 This->iIcoNdx = iIcon;
1974 This->bDirty = TRUE;
1975
1976 return S_OK;
1977 }
1978
1979 static HRESULT WINAPI IShellLinkW_fnSetRelativePath(IShellLinkW * iface, LPCWSTR pszPathRel, DWORD dwReserved)
1980 {
1981 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
1982
1983 TRACE("(%p)->(path=%s %lx)\n",This, debugstr_w(pszPathRel), dwReserved);
1984
1985 HeapFree(GetProcessHeap(), 0, This->sPathRel);
1986 This->sPathRel = HeapAlloc( GetProcessHeap(), 0,
1987 (lstrlenW( pszPathRel )+1) * sizeof (WCHAR) );
1988 if ( !This->sPathRel )
1989 return E_OUTOFMEMORY;
1990 lstrcpyW( This->sPathRel, pszPathRel );
1991 This->bDirty = TRUE;
1992
1993 return ShellLink_UpdatePath(This->sPathRel, This->sPath, This->sWorkDir, &This->sPath);
1994 }
1995
1996 static HRESULT WINAPI IShellLinkW_fnResolve(IShellLinkW * iface, HWND hwnd, DWORD fFlags)
1997 {
1998 HRESULT hr = S_OK;
1999 BOOL bSuccess;
2000
2001 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
2002
2003 TRACE("(%p)->(hwnd=%p flags=%lx)\n",This, hwnd, fFlags);
2004
2005 /*FIXME: use IResolveShellLink interface */
2006
2007 if (!This->sPath && This->pPidl) {
2008 WCHAR buffer[MAX_PATH];
2009
2010 bSuccess = SHGetPathFromIDListW(This->pPidl, buffer);
2011
2012 if (bSuccess && *buffer) {
2013 This->sPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(buffer)+1)*sizeof(WCHAR));
2014 if (!This->sPath)
2015 return E_OUTOFMEMORY;
2016
2017 lstrcpyW(This->sPath, buffer);
2018
2019 This->bDirty = TRUE;
2020 } else
2021 hr = S_OK; /* don't report an error occurred while just caching information */
2022 }
2023
2024 if (!This->sIcoPath && This->sPath) {
2025 This->sIcoPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(This->sPath)+1)*sizeof(WCHAR));
2026 if (!This->sIcoPath)
2027 return E_OUTOFMEMORY;
2028
2029 lstrcpyW(This->sIcoPath, This->sPath);
2030 This->iIcoNdx = 0;
2031
2032 This->bDirty = TRUE;
2033 }
2034
2035 return hr;
2036 }
2037
2038 static LPWSTR ShellLink_GetAdvertisedArg(LPCWSTR str)
2039 {
2040 LPWSTR ret;
2041 LPCWSTR p;
2042 DWORD len;
2043
2044 if( !str )
2045 return NULL;
2046
2047 p = strchrW( str, ':' );
2048 if( !p )
2049 return NULL;
2050 len = p - str;
2051 ret = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
2052 if( !ret )
2053 return ret;
2054 memcpy( ret, str, sizeof(WCHAR)*len );
2055 ret[len] = 0;
2056 return ret;
2057 }
2058
2059 static HRESULT ShellLink_SetAdvertiseInfo(IShellLinkImpl *This, LPCWSTR str)
2060 {
2061 LPCWSTR szComponent = NULL, szProduct = NULL, p;
2062 WCHAR szGuid[39];
2063 HRESULT r;
2064 GUID guid;
2065 int len;
2066
2067 while( str[0] )
2068 {
2069 /* each segment must start with two colons */
2070 if( str[0] != ':' || str[1] != ':' )
2071 return E_FAIL;
2072
2073 /* the last segment is just two colons */
2074 if( !str[2] )
2075 break;
2076 str += 2;
2077
2078 /* there must be a colon straight after a guid */
2079 p = strchrW( str, ':' );
2080 if( !p )
2081 return E_FAIL;
2082 len = p - str;
2083 if( len != 38 )
2084 return E_FAIL;
2085
2086 /* get the guid, and check it's validly formatted */
2087 memcpy( szGuid, str, sizeof(WCHAR)*len );
2088 szGuid[len] = 0;
2089 r = CLSIDFromString( szGuid, &guid );
2090 if( r != S_OK )
2091 return r;
2092 str = p + 1;
2093
2094 /* match it up to a guid that we care about */
2095 if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutComponent ) && !szComponent )
2096 szComponent = str;
2097 else if( IsEqualGUID( &guid, &SHELL32_AdvtShortcutProduct ) && !szProduct )
2098 szProduct = str;
2099 else
2100 return E_FAIL;
2101
2102 /* skip to the next field */
2103 str = strchrW( str, ':' );
2104 if( !str )
2105 return E_FAIL;
2106 }
2107
2108 /* we have to have a component for an advertised shortcut */
2109 if( !szComponent )
2110 return E_FAIL;
2111
2112 This->sComponent = ShellLink_GetAdvertisedArg( szComponent );
2113 This->sProduct = ShellLink_GetAdvertisedArg( szProduct );
2114
2115 TRACE("Component = %s\n", debugstr_w(This->sComponent));
2116 TRACE("Product = %s\n", debugstr_w(This->sProduct));
2117
2118 return S_OK;
2119 }
2120
2121 static BOOL ShellLink_GetVolumeInfo(LPWSTR path, volume_info *volume)
2122 {
2123 const int label_sz = sizeof volume->label/sizeof volume->label[0];
2124 WCHAR drive[4] = { path[0], ':', '\\', 0 };
2125 BOOL r;
2126
2127 volume->type = GetDriveTypeW(drive);
2128 r = GetVolumeInformationW(drive, volume->label, label_sz,
2129 &volume->serial, NULL, NULL, NULL, 0);
2130 TRACE("r = %d type %ld serial %08lx name %s\n", r,
2131 volume->type, volume->serial, debugstr_w(volume->label));
2132 return r;
2133 }
2134
2135 static HRESULT WINAPI IShellLinkW_fnSetPath(IShellLinkW * iface, LPCWSTR pszFile)
2136 {
2137 _ICOM_THIS_From_IShellLinkW(IShellLinkImpl, iface);
2138 WCHAR buffer[MAX_PATH];
2139 LPWSTR fname;
2140 HRESULT hr = S_OK;
2141
2142 TRACE("(%p)->(path=%s)\n",This, debugstr_w(pszFile));
2143
2144 HeapFree(GetProcessHeap(), 0, This->sPath);
2145 This->sPath = NULL;
2146
2147 HeapFree(GetProcessHeap(), 0, This->sComponent);
2148 This->sComponent = NULL;
2149
2150 if (This->pPidl)
2151 ILFree(This->pPidl);
2152 This->pPidl = NULL;
2153
2154 if (S_OK != ShellLink_SetAdvertiseInfo( This, pszFile ))
2155 {
2156 if (*pszFile == '\0')
2157 *buffer = '\0';
2158 else if (!GetFullPathNameW(pszFile, MAX_PATH, buffer, &fname))
2159 return E_FAIL;
2160 else if(!PathFileExistsW(buffer))
2161 hr = S_FALSE;
2162
2163 This->pPidl = SHSimpleIDListFromPathW(pszFile);
2164 ShellLink_GetVolumeInfo(buffer, &This->volume);
2165
2166 This->sPath = HeapAlloc( GetProcessHeap(), 0,
2167 (lstrlenW( buffer )+1) * sizeof (WCHAR) );
2168 if (!This->sPath)
2169 return E_OUTOFMEMORY;
2170
2171 lstrcpyW(This->sPath, buffer);
2172 }
2173 This->bDirty = TRUE;
2174
2175 return hr;
2176 }
2177
2178 /**************************************************************************
2179 * IShellLinkW Implementation
2180 */
2181
2182 static const IShellLinkWVtbl slvtw =
2183 {
2184 IShellLinkW_fnQueryInterface,
2185 IShellLinkW_fnAddRef,
2186 IShellLinkW_fnRelease,
2187 IShellLinkW_fnGetPath,
2188 IShellLinkW_fnGetIDList,
2189 IShellLinkW_fnSetIDList,
2190 IShellLinkW_fnGetDescription,
2191 IShellLinkW_fnSetDescription,
2192 IShellLinkW_fnGetWorkingDirectory,
2193 IShellLinkW_fnSetWorkingDirectory,
2194 IShellLinkW_fnGetArguments,
2195 IShellLinkW_fnSetArguments,
2196 IShellLinkW_fnGetHotkey,
2197 IShellLinkW_fnSetHotkey,
2198 IShellLinkW_fnGetShowCmd,
2199 IShellLinkW_fnSetShowCmd,
2200 IShellLinkW_fnGetIconLocation,
2201 IShellLinkW_fnSetIconLocation,
2202 IShellLinkW_fnSetRelativePath,
2203 IShellLinkW_fnResolve,
2204 IShellLinkW_fnSetPath
2205 };
2206
2207 static HRESULT WINAPI
2208 ShellLink_DataList_QueryInterface( IShellLinkDataList* iface, REFIID riid, void** ppvObject)
2209 {
2210 _ICOM_THIS_From_IShellLinkDataList(IShellLinkImpl, iface);
2211 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2212 }
2213
2214 static ULONG WINAPI
2215 ShellLink_DataList_AddRef( IShellLinkDataList* iface )
2216 {
2217 _ICOM_THIS_From_IShellLinkDataList(IShellLinkImpl, iface);
2218 return IShellLinkA_AddRef((IShellLinkA*)This);
2219 }
2220
2221 static ULONG WINAPI
2222 ShellLink_DataList_Release( IShellLinkDataList* iface )
2223 {
2224 _ICOM_THIS_From_IShellLinkDataList(IShellLinkImpl, iface);
2225 return ShellLink_Release( This );
2226 }
2227
2228 static HRESULT WINAPI
2229 ShellLink_AddDataBlock( IShellLinkDataList* iface, void* pDataBlock )
2230 {
2231 FIXME("\n");
2232 return E_NOTIMPL;
2233 }
2234
2235 static HRESULT WINAPI
2236 ShellLink_CopyDataBlock( IShellLinkDataList* iface, DWORD dwSig, void** ppDataBlock )
2237 {
2238 FIXME("\n");
2239 return E_NOTIMPL;
2240 }
2241
2242 static HRESULT WINAPI
2243 ShellLink_RemoveDataBlock( IShellLinkDataList* iface, DWORD dwSig )
2244 {
2245 FIXME("\n");
2246 return E_NOTIMPL;
2247 }
2248
2249 static HRESULT WINAPI
2250 ShellLink_GetFlags( IShellLinkDataList* iface, DWORD* pdwFlags )
2251 {
2252 FIXME("\n");
2253 return E_NOTIMPL;
2254 }
2255
2256 static HRESULT WINAPI
2257 ShellLink_SetFlags( IShellLinkDataList* iface, DWORD dwFlags )
2258 {
2259 FIXME("\n");
2260 return E_NOTIMPL;
2261 }
2262
2263 static const IShellLinkDataListVtbl dlvt =
2264 {
2265 ShellLink_DataList_QueryInterface,
2266 ShellLink_DataList_AddRef,
2267 ShellLink_DataList_Release,
2268 ShellLink_AddDataBlock,
2269 ShellLink_CopyDataBlock,
2270 ShellLink_RemoveDataBlock,
2271 ShellLink_GetFlags,
2272 ShellLink_SetFlags
2273 };
2274
2275 static HRESULT WINAPI
2276 ShellLink_ExtInit_QueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
2277 {
2278 _ICOM_THIS_From_IShellExtInit(IShellLinkImpl, iface);
2279 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2280 }
2281
2282 static ULONG WINAPI
2283 ShellLink_ExtInit_AddRef( IShellExtInit* iface )
2284 {
2285 _ICOM_THIS_From_IShellExtInit(IShellLinkImpl, iface);
2286 return IShellLinkA_AddRef((IShellLinkA*)This);
2287 }
2288
2289 static ULONG WINAPI
2290 ShellLink_ExtInit_Release( IShellExtInit* iface )
2291 {
2292 _ICOM_THIS_From_IShellExtInit(IShellLinkImpl, iface);
2293 return ShellLink_Release( This );
2294 }
2295
2296 /**************************************************************************
2297 * ShellLink implementation of IShellExtInit::Initialize()
2298 *
2299 * Loads the shelllink from the dataobject the shell is pointing to.
2300 */
2301 static HRESULT WINAPI
2302 ShellLink_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
2303 IDataObject *pdtobj, HKEY hkeyProgID )
2304 {
2305 _ICOM_THIS_From_IShellExtInit(IShellLinkImpl, iface);
2306 FORMATETC format;
2307 STGMEDIUM stgm;
2308 UINT count;
2309 HRESULT r = E_FAIL;
2310
2311 TRACE("%p %p %p %p\n", This, pidlFolder, pdtobj, hkeyProgID );
2312
2313 if( !pdtobj )
2314 return r;
2315
2316 format.cfFormat = CF_HDROP;
2317 format.ptd = NULL;
2318 format.dwAspect = DVASPECT_CONTENT;
2319 format.lindex = -1;
2320 format.tymed = TYMED_HGLOBAL;
2321
2322 if( FAILED( IDataObject_GetData( pdtobj, &format, &stgm ) ) )
2323 return r;
2324
2325 count = DragQueryFileW( stgm.u.hGlobal, -1, NULL, 0 );
2326 if( count == 1 )
2327 {
2328 LPWSTR path;
2329
2330 count = DragQueryFileW( stgm.u.hGlobal, 0, NULL, 0 );
2331 count++;
2332 path = HeapAlloc( GetProcessHeap(), 0, count*sizeof(WCHAR) );
2333 if( path )
2334 {
2335 IPersistFile *pf = (IPersistFile*) &This->lpvtblPersistFile;
2336
2337 count = DragQueryFileW( stgm.u.hGlobal, 0, path, count );
2338 r = IPersistFile_Load( pf, path, 0 );
2339 HeapFree( GetProcessHeap(), 0, path );
2340 }
2341 }
2342 ReleaseStgMedium( &stgm );
2343
2344 return r;
2345 }
2346
2347 static const IShellExtInitVtbl eivt =
2348 {
2349 ShellLink_ExtInit_QueryInterface,
2350 ShellLink_ExtInit_AddRef,
2351 ShellLink_ExtInit_Release,
2352 ShellLink_ExtInit_Initialize
2353 };
2354
2355 static HRESULT WINAPI
2356 ShellLink_ContextMenu_QueryInterface( IContextMenu* iface, REFIID riid, void** ppvObject )
2357 {
2358 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2359 return IShellLinkA_QueryInterface((IShellLinkA*)This, riid, ppvObject);
2360 }
2361
2362 static ULONG WINAPI
2363 ShellLink_ContextMenu_AddRef( IContextMenu* iface )
2364 {
2365 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2366 return IShellLinkA_AddRef((IShellLinkA*)This);
2367 }
2368
2369 static ULONG WINAPI
2370 ShellLink_ContextMenu_Release( IContextMenu* iface )
2371 {
2372 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2373 return ShellLink_Release( This );
2374 }
2375
2376 static HRESULT WINAPI
2377 ShellLink_QueryContextMenu( IContextMenu* iface, HMENU hmenu, UINT indexMenu,
2378 UINT idCmdFirst, UINT idCmdLast, UINT uFlags )
2379 {
2380 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2381
2382 FIXME("%p %p %u %u %u %u\n", This,
2383 hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
2384
2385 return E_NOTIMPL;
2386 }
2387
2388 static HRESULT WINAPI
2389 ShellLink_InvokeCommand( IContextMenu* iface, LPCMINVOKECOMMANDINFO lpici )
2390 {
2391 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2392
2393 FIXME("%p %p\n", This, lpici );
2394
2395 return E_NOTIMPL;
2396 }
2397
2398 static HRESULT WINAPI
2399 ShellLink_GetCommandString( IContextMenu* iface, UINT idCmd, UINT uType,
2400 UINT* pwReserved, LPSTR pszName, UINT cchMax )
2401 {
2402 _ICOM_THIS_From_IContextMenu(IShellLinkImpl, iface);
2403
2404 FIXME("%p %u %u %p %p %u\n", This,
2405 idCmd, uType, pwReserved, pszName, cchMax );
2406
2407 return E_NOTIMPL;
2408 }
2409
2410 static const IContextMenuVtbl cmvt =
2411 {
2412 ShellLink_ContextMenu_QueryInterface,
2413 ShellLink_ContextMenu_AddRef,
2414 ShellLink_ContextMenu_Release,
2415 ShellLink_QueryContextMenu,
2416 ShellLink_InvokeCommand,
2417 ShellLink_GetCommandString
2418 };