?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winmm/tests: Accept MMSYSERR_ALLOCATED for more tests.
[wine/multimedia.git] / programs / winemenubuilder / winemenubuilder.c
blob592487fd79a74a8f9dcab21b26c3ece439f90037
1 /*
2 * Helper program to build unix menu entries
3 *
4 * Copyright 1997 Marcus Meissner
5 * Copyright 1998 Juergen Schmied
6 * Copyright 2003 Mike McCormack for CodeWeavers
7 * Copyright 2004 Dmitry Timoshkov
8 * Copyright 2005 Bill Medland
9 * Copyright 2008 Damjan Jovanovic
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 *
26 * This program is used to replicate the Windows desktop and start menu
27 * into the native desktop's copies. Desktop entries are merged directly
28 * into the native desktop. The Windows Start Menu corresponds to a Wine
29 * entry within the native "start" menu and replicates the whole tree
30 * structure of the Windows Start Menu. Currently it does not differentiate
31 * between the user's desktop/start menu and the "All Users" copies.
32 *
33 * This program will read a Windows shortcut file using the IShellLink
34 * interface, then create a KDE/GNOME menu entry for the shortcut.
35 *
36 * winemenubuilder [ -w ] <shortcut.lnk>
37 *
38 * If the -w parameter is passed, and the shortcut cannot be created,
39 * this program will wait for the parent process to finish and then try
40 * again. This covers the case when a ShortCut is created before the
41 * executable containing its icon.
42 *
43 * TODO
44 * Handle data lnk files. There is no icon in the file; the icon is in
45 * the handler for the file type (or pointed to by the lnk file). Also it
46 * might be better to use a native handler (e.g. a native acroread for pdf
47 * files).
48 * Differentiate between the user's entries and the "All Users" entries.
49 * If it is possible to add the desktop files to the native system's
50 * shared location for an "All Users" entry then do so. As a suggestion the
51 * shared menu Wine base could be writable to the wine group, or a wineadm
52 * group.
53 * Clean up fd.o menu icons and .directory files when the menu is deleted
54 * in Windows.
55 * Associate applications under HKCR\Applications to open any MIME type
56 * (by associating with application/octet-stream, or how?).
57 * Clean up fd.o MIME types when they are deleted in Windows, their icons
58 * too. Very hard - once we associate them with fd.o, we can't tell whether
59 * they are ours or not, and the extension <-> MIME type mapping isn't
60 * one-to-one either.
61 * Wine's HKCR is broken - it doesn't merge HKCU\Software\Classes, so apps
62 * that write associations there won't associate (#17019).
63 */
64
65 #include "config.h"
66 #include "wine/port.h"
67
68 #include <ctype.h>
69 #include <stdio.h>
70 #include <string.h>
71 #ifdef HAVE_UNISTD_H
72 #include <unistd.h>
73 #endif
74 #include <errno.h>
75 #include <stdarg.h>
76 #ifdef HAVE_FNMATCH_H
77 #include <fnmatch.h>
78 #endif
79
80 #define COBJMACROS
81 #define NONAMELESSUNION
82
83 #include <windows.h>
84 #include <shlobj.h>
85 #include <objidl.h>
86 #include <shlguid.h>
87 #include <appmgmt.h>
88 #include <tlhelp32.h>
89 #include <intshcut.h>
90 #include <shlwapi.h>
91 #include <initguid.h>
92 #include <wincodec.h>
93
94 #include "wine/unicode.h"
95 #include "wine/debug.h"
96 #include "wine/library.h"
97 #include "wine/list.h"
98 #include "wine/rbtree.h"
99
100 WINE_DEFAULT_DEBUG_CHANNEL(menubuilder);
101
102 #define in_desktop_dir(csidl) ((csidl)==CSIDL_DESKTOPDIRECTORY || \
103 (csidl)==CSIDL_COMMON_DESKTOPDIRECTORY)
104 #define in_startmenu(csidl) ((csidl)==CSIDL_STARTMENU || \
105 (csidl)==CSIDL_COMMON_STARTMENU)
106
107 /* link file formats */
108
109 #include "pshpack1.h"
110
111 typedef struct
112 {
113 BYTE bWidth;
114 BYTE bHeight;
115 BYTE bColorCount;
116 BYTE bReserved;
117 WORD wPlanes;
118 WORD wBitCount;
119 DWORD dwBytesInRes;
120 WORD nID;
121 } GRPICONDIRENTRY;
122
123 typedef struct
124 {
125 WORD idReserved;
126 WORD idType;
127 WORD idCount;
128 GRPICONDIRENTRY idEntries[1];
129 } GRPICONDIR;
130
131 typedef struct
132 {
133 BYTE bWidth;
134 BYTE bHeight;
135 BYTE bColorCount;
136 BYTE bReserved;
137 WORD wPlanes;
138 WORD wBitCount;
139 DWORD dwBytesInRes;
140 DWORD dwImageOffset;
141 } ICONDIRENTRY;
142
143 typedef struct
144 {
145 WORD idReserved;
146 WORD idType;
147 WORD idCount;
148 } ICONDIR;
149
150 typedef struct
151 {
152 WORD offset;
153 WORD length;
154 WORD flags;
155 WORD id;
156 WORD handle;
157 WORD usage;
158 } NE_NAMEINFO;
159
160 typedef struct
161 {
162 WORD type_id;
163 WORD count;
164 DWORD resloader;
165 } NE_TYPEINFO;
166
167 #define NE_RSCTYPE_ICON 0x8003
168 #define NE_RSCTYPE_GROUP_ICON 0x800e
169
170 #include "poppack.h"
171
172 typedef struct
173 {
174 HRSRC *pResInfo;
175 int nIndex;
176 } ENUMRESSTRUCT;
177
178 struct xdg_mime_type
179 {
180 char *mimeType;
181 char *glob;
182 char *lower_glob;
183 struct list entry;
184 };
185
186 struct rb_string_entry
187 {
188 char *string;
189 struct wine_rb_entry entry;
190 };
191
192 DEFINE_GUID(CLSID_WICIcnsEncoder, 0x312fb6f1,0xb767,0x409d,0x8a,0x6d,0x0f,0xc1,0x54,0xd4,0xf0,0x5c);
193
194 static char *xdg_config_dir;
195 static char *xdg_data_dir;
196 static char *xdg_desktop_dir;
197
198 static WCHAR* assoc_query(ASSOCSTR assocStr, LPCWSTR name, LPCWSTR extra);
199 static HRESULT open_icon(LPCWSTR filename, int index, BOOL bWait, IStream **ppStream);
200
201 /* Utility routines */
202 static unsigned short crc16(const char* string)
203 {
204 unsigned short crc = 0;
205 int i, j, xor_poly;
206
207 for (i = 0; string[i] != 0; i++)
208 {
209 char c = string[i];
210 for (j = 0; j < 8; c >>= 1, j++)
211 {
212 xor_poly = (c ^ crc) & 1;
213 crc >>= 1;
214 if (xor_poly)
215 crc ^= 0xa001;
216 }
217 }
218 return crc;
219 }
220
221 static char *strdupA( const char *str )
222 {
223 char *ret;
224
225 if (!str) return NULL;
226 if ((ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 ))) strcpy( ret, str );
227 return ret;
228 }
229
230 static char* heap_printf(const char *format, ...)
231 {
232 va_list args;
233 int size = 4096;
234 char *buffer, *ret;
235 int n;
236
237 while (1)
238 {
239 buffer = HeapAlloc(GetProcessHeap(), 0, size);
240 if (buffer == NULL)
241 break;
242 va_start(args, format);
243 n = vsnprintf(buffer, size, format, args);
244 va_end(args);
245 if (n == -1)
246 size *= 2;
247 else if (n >= size)
248 size = n + 1;
249 else
250 break;
251 HeapFree(GetProcessHeap(), 0, buffer);
252 }
253
254 if (!buffer) return NULL;
255 ret = HeapReAlloc(GetProcessHeap(), 0, buffer, strlen(buffer) + 1 );
256 if (!ret) ret = buffer;
257 return ret;
258 }
259
260 static int winemenubuilder_rb_string_compare(const void *key, const struct wine_rb_entry *entry)
261 {
262 const struct rb_string_entry *t = WINE_RB_ENTRY_VALUE(entry, const struct rb_string_entry, entry);
263
264 return strcmp((char*)key, t->string);
265 }
266
267 static void *winemenubuilder_rb_alloc(size_t size)
268 {
269 return HeapAlloc(GetProcessHeap(), 0, size);
270 }
271
272 static void *winemenubuilder_rb_realloc(void *ptr, size_t size)
273 {
274 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
275 }
276
277 static void winemenubuilder_rb_free(void *ptr)
278 {
279 HeapFree(GetProcessHeap(), 0, ptr);
280 }
281
282 static void winemenubuilder_rb_destroy(struct wine_rb_entry *entry, void *context)
283 {
284 struct rb_string_entry *t = WINE_RB_ENTRY_VALUE(entry, struct rb_string_entry, entry);
285 HeapFree(GetProcessHeap(), 0, t->string);
286 HeapFree(GetProcessHeap(), 0, t);
287 }
288
289 static const struct wine_rb_functions winemenubuilder_rb_functions =
290 {
291 winemenubuilder_rb_alloc,
292 winemenubuilder_rb_realloc,
293 winemenubuilder_rb_free,
294 winemenubuilder_rb_string_compare,
295 };
296
297 static void write_xml_text(FILE *file, const char *text)
298 {
299 int i;
300 for (i = 0; text[i]; i++)
301 {
302 if (text[i] == '&')
303 fputs("&amp;", file);
304 else if (text[i] == '<')
305 fputs("&lt;", file);
306 else if (text[i] == '>')
307 fputs("&gt;", file);
308 else if (text[i] == '\'')
309 fputs("&apos;", file);
310 else if (text[i] == '"')
311 fputs("&quot;", file);
312 else
313 fputc(text[i], file);
314 }
315 }
316
317 static BOOL create_directories(char *directory)
318 {
319 BOOL ret = TRUE;
320 int i;
321
322 for (i = 0; directory[i]; i++)
323 {
324 if (i > 0 && directory[i] == '/')
325 {
326 directory[i] = 0;
327 mkdir(directory, 0777);
328 directory[i] = '/';
329 }
330 }
331 if (mkdir(directory, 0777) && errno != EEXIST)
332 ret = FALSE;
333
334 return ret;
335 }
336
337 static char* wchars_to_utf8_chars(LPCWSTR string)
338 {
339 char *ret;
340 INT size = WideCharToMultiByte(CP_UTF8, 0, string, -1, NULL, 0, NULL, NULL);
341 ret = HeapAlloc(GetProcessHeap(), 0, size);
342 if (ret)
343 WideCharToMultiByte(CP_UTF8, 0, string, -1, ret, size, NULL, NULL);
344 return ret;
345 }
346
347 static char* wchars_to_unix_chars(LPCWSTR string)
348 {
349 char *ret;
350 INT size = WideCharToMultiByte(CP_UNIXCP, 0, string, -1, NULL, 0, NULL, NULL);
351 ret = HeapAlloc(GetProcessHeap(), 0, size);
352 if (ret)
353 WideCharToMultiByte(CP_UNIXCP, 0, string, -1, ret, size, NULL, NULL);
354 return ret;
355 }
356
357 static WCHAR* utf8_chars_to_wchars(LPCSTR string)
358 {
359 WCHAR *ret;
360 INT size = MultiByteToWideChar(CP_UTF8, 0, string, -1, NULL, 0);
361 ret = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
362 if (ret)
363 MultiByteToWideChar(CP_UTF8, 0, string, -1, ret, size);
364 return ret;
365 }
366
367 /* Icon extraction routines
368 *
369 * FIXME: should use PrivateExtractIcons and friends
370 * FIXME: should not use stdio
371 */
372
373 static HRESULT convert_to_native_icon(IStream *icoFile, int *indices, int numIndices,
374 const CLSID *outputFormat, const char *outputFileName, LPCWSTR commentW)
375 {
376 WCHAR *dosOutputFileName = NULL;
377 IWICImagingFactory *factory = NULL;
378 IWICBitmapDecoder *decoder = NULL;
379 IWICBitmapEncoder *encoder = NULL;
380 IWICBitmapScaler *scaler = NULL;
381 IStream *outputFile = NULL;
382 int i;
383 HRESULT hr = E_FAIL;
384
385 dosOutputFileName = wine_get_dos_file_name(outputFileName);
386 if (dosOutputFileName == NULL)
387 {
388 WINE_ERR("error converting %s to DOS file name\n", outputFileName);
389 goto end;
390 }
391 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
392 &IID_IWICImagingFactory, (void**)&factory);
393 if (FAILED(hr))
394 {
395 WINE_ERR("error 0x%08X creating IWICImagingFactory\n", hr);
396 goto end;
397 }
398 hr = IWICImagingFactory_CreateDecoderFromStream(factory, icoFile, NULL,
399 WICDecodeMetadataCacheOnDemand, &decoder);
400 if (FAILED(hr))
401 {
402 WINE_ERR("error 0x%08X creating IWICBitmapDecoder\n", hr);
403 goto end;
404 }
405 if (IsEqualCLSID(outputFormat,&CLSID_WICIcnsEncoder))
406 {
407 hr = IWICImagingFactory_CreateBitmapScaler(factory, &scaler);
408 if (FAILED(hr))
409 {
410 WINE_WARN("error 0x%08X creating IWICBitmapScaler\n", hr);
411 }
412 }
413 hr = CoCreateInstance(outputFormat, NULL, CLSCTX_INPROC_SERVER,
414 &IID_IWICBitmapEncoder, (void**)&encoder);
415 if (FAILED(hr))
416 {
417 WINE_ERR("error 0x%08X creating bitmap encoder\n", hr);
418 goto end;
419 }
420 hr = SHCreateStreamOnFileW(dosOutputFileName, STGM_CREATE | STGM_WRITE, &outputFile);
421 if (FAILED(hr))
422 {
423 WINE_ERR("error 0x%08X creating output file %s\n", hr, wine_dbgstr_w(dosOutputFileName));
424 goto end;
425 }
426 hr = IWICBitmapEncoder_Initialize(encoder, outputFile, GENERIC_WRITE);
427 if (FAILED(hr))
428 {
429 WINE_ERR("error 0x%08X initializing encoder\n", hr);
430 goto end;
431 }
432
433 for (i = 0; i < numIndices; i++)
434 {
435 IWICBitmapFrameDecode *sourceFrame = NULL;
436 IWICBitmapSource *sourceBitmap = NULL;
437 IWICBitmapFrameEncode *dstFrame = NULL;
438 IPropertyBag2 *options = NULL;
439 UINT width, height;
440
441 hr = IWICBitmapDecoder_GetFrame(decoder, indices[i], &sourceFrame);
442 if (FAILED(hr))
443 {
444 WINE_ERR("error 0x%08X getting frame %d\n", hr, indices[i]);
445 goto endloop;
446 }
447 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)sourceFrame, &sourceBitmap);
448 if (FAILED(hr))
449 {
450 WINE_ERR("error 0x%08X converting bitmap to 32bppBGRA\n", hr);
451 goto endloop;
452 }
453 if ( scaler)
454 {
455 IWICBitmapSource_GetSize(sourceBitmap, &width, &height);
456 if (width == 64) /* Classic Mode */
457 {
458 hr = IWICBitmapScaler_Initialize( scaler, sourceBitmap, 128, 128,
459 WICBitmapInterpolationModeNearestNeighbor);
460 if (FAILED(hr))
461 WINE_ERR("error 0x%08X scaling bitmap\n", hr);
462 else
463 {
464 IWICBitmapSource_Release(sourceBitmap);
465 IWICBitmapScaler_QueryInterface(scaler, &IID_IWICBitmapSource, (LPVOID)&sourceBitmap);
466 }
467 }
468 }
469 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &dstFrame, &options);
470 if (FAILED(hr))
471 {
472 WINE_ERR("error 0x%08X creating encoder frame\n", hr);
473 goto endloop;
474 }
475 hr = IWICBitmapFrameEncode_Initialize(dstFrame, options);
476 if (FAILED(hr))
477 {
478 WINE_ERR("error 0x%08X initializing encoder frame\n", hr);
479 goto endloop;
480 }
481 hr = IWICBitmapSource_GetSize(sourceBitmap, &width, &height);
482 if (FAILED(hr))
483 {
484 WINE_ERR("error 0x%08X getting source bitmap size\n", hr);
485 goto endloop;
486 }
487 hr = IWICBitmapFrameEncode_SetSize(dstFrame, width, height);
488 if (FAILED(hr))
489 {
490 WINE_ERR("error 0x%08X setting destination bitmap size\n", hr);
491 goto endloop;
492 }
493 hr = IWICBitmapFrameEncode_SetResolution(dstFrame, 96, 96);
494 if (FAILED(hr))
495 {
496 WINE_ERR("error 0x%08X setting destination bitmap resolution\n", hr);
497 goto endloop;
498 }
499 hr = IWICBitmapFrameEncode_WriteSource(dstFrame, sourceBitmap, NULL);
500 if (FAILED(hr))
501 {
502 WINE_ERR("error 0x%08X copying bitmaps\n", hr);
503 goto endloop;
504 }
505 hr = IWICBitmapFrameEncode_Commit(dstFrame);
506 if (FAILED(hr))
507 {
508 WINE_ERR("error 0x%08X committing frame\n", hr);
509 goto endloop;
510 }
511 endloop:
512 if (sourceFrame)
513 IWICBitmapFrameDecode_Release(sourceFrame);
514 if (sourceBitmap)
515 IWICBitmapSource_Release(sourceBitmap);
516 if (dstFrame)
517 IWICBitmapFrameEncode_Release(dstFrame);
518 }
519
520 hr = IWICBitmapEncoder_Commit(encoder);
521 if (FAILED(hr))
522 {
523 WINE_ERR("error 0x%08X committing encoder\n", hr);
524 goto end;
525 }
526
527 end:
528 HeapFree(GetProcessHeap(), 0, dosOutputFileName);
529 if (factory)
530 IWICImagingFactory_Release(factory);
531 if (decoder)
532 IWICBitmapDecoder_Release(decoder);
533 if (scaler)
534 IWICBitmapScaler_Release(scaler);
535 if (encoder)
536 IWICBitmapEncoder_Release(encoder);
537 if (outputFile)
538 IStream_Release(outputFile);
539 return hr;
540 }
541
542 struct IconData16 {
543 BYTE *fileBytes;
544 DWORD fileSize;
545 NE_TYPEINFO *iconResources;
546 WORD alignmentShiftCount;
547 };
548
549 static int populate_module16_icons(struct IconData16 *iconData16, GRPICONDIR *grpIconDir, ICONDIRENTRY *iconDirEntries, BYTE *icons, SIZE_T *iconOffset)
550 {
551 int i, j;
552 int validEntries = 0;
553
554 for (i = 0; i < grpIconDir->idCount; i++)
555 {
556 BYTE *iconPtr = (BYTE*)iconData16->iconResources;
557 NE_NAMEINFO *matchingIcon = NULL;
558 iconPtr += sizeof(NE_TYPEINFO);
559 for (j = 0; j < iconData16->iconResources->count; j++)
560 {
561 NE_NAMEINFO *iconInfo = (NE_NAMEINFO*)iconPtr;
562 if ((((BYTE*)iconPtr) + sizeof(NE_NAMEINFO)) > (iconData16->fileBytes + iconData16->fileSize))
563 {
564 WINE_WARN("file too small for icon NE_NAMEINFO\n");
565 break;
566 }
567 if (iconInfo->id == (0x8000 | grpIconDir->idEntries[i].nID))
568 {
569 matchingIcon = iconInfo;
570 break;
571 }
572 iconPtr += sizeof(NE_NAMEINFO);
573 }
574
575 if (matchingIcon == NULL)
576 continue;
577 if (((matchingIcon->offset << iconData16->alignmentShiftCount) + grpIconDir->idEntries[i].dwBytesInRes) > iconData16->fileSize)
578 {
579 WINE_WARN("file too small for icon contents\n");
580 break;
581 }
582
583 iconDirEntries[validEntries].bWidth = grpIconDir->idEntries[i].bWidth;
584 iconDirEntries[validEntries].bHeight = grpIconDir->idEntries[i].bHeight;
585 iconDirEntries[validEntries].bColorCount = grpIconDir->idEntries[i].bColorCount;
586 iconDirEntries[validEntries].bReserved = grpIconDir->idEntries[i].bReserved;
587 iconDirEntries[validEntries].wPlanes = grpIconDir->idEntries[i].wPlanes;
588 iconDirEntries[validEntries].wBitCount = grpIconDir->idEntries[i].wBitCount;
589 iconDirEntries[validEntries].dwBytesInRes = grpIconDir->idEntries[i].dwBytesInRes;
590 iconDirEntries[validEntries].dwImageOffset = *iconOffset;
591 validEntries++;
592 memcpy(&icons[*iconOffset], &iconData16->fileBytes[matchingIcon->offset << iconData16->alignmentShiftCount], grpIconDir->idEntries[i].dwBytesInRes);
593 *iconOffset += grpIconDir->idEntries[i].dwBytesInRes;
594 }
595 return validEntries;
596 }
597
598 static int populate_module_icons(HMODULE hModule, GRPICONDIR *grpIconDir, ICONDIRENTRY *iconDirEntries, BYTE *icons, SIZE_T *iconOffset)
599 {
600 int i;
601 int validEntries = 0;
602
603 for (i = 0; i < grpIconDir->idCount; i++)
604 {
605 HRSRC hResInfo;
606 LPCWSTR lpName = MAKEINTRESOURCEW(grpIconDir->idEntries[i].nID);
607 if ((hResInfo = FindResourceW(hModule, lpName, (LPCWSTR)RT_ICON)))
608 {
609 HGLOBAL hResData;
610 if ((hResData = LoadResource(hModule, hResInfo)))
611 {
612 BITMAPINFO *pIcon;
613 if ((pIcon = LockResource(hResData)))
614 {
615 iconDirEntries[validEntries].bWidth = grpIconDir->idEntries[i].bWidth;
616 iconDirEntries[validEntries].bHeight = grpIconDir->idEntries[i].bHeight;
617 iconDirEntries[validEntries].bColorCount = grpIconDir->idEntries[i].bColorCount;
618 iconDirEntries[validEntries].bReserved = grpIconDir->idEntries[i].bReserved;
619 iconDirEntries[validEntries].wPlanes = grpIconDir->idEntries[i].wPlanes;
620 iconDirEntries[validEntries].wBitCount = grpIconDir->idEntries[i].wBitCount;
621 iconDirEntries[validEntries].dwBytesInRes = grpIconDir->idEntries[i].dwBytesInRes;
622 iconDirEntries[validEntries].dwImageOffset = *iconOffset;
623 validEntries++;
624 memcpy(&icons[*iconOffset], pIcon, grpIconDir->idEntries[i].dwBytesInRes);
625 *iconOffset += grpIconDir->idEntries[i].dwBytesInRes;
626 }
627 FreeResource(hResData);
628 }
629 }
630 }
631 return validEntries;
632 }
633
634 static IStream *add_module_icons_to_stream(struct IconData16 *iconData16, HMODULE hModule, GRPICONDIR *grpIconDir)
635 {
636 int i;
637 SIZE_T iconsSize = 0;
638 BYTE *icons = NULL;
639 ICONDIRENTRY *iconDirEntries = NULL;
640 IStream *stream = NULL;
641 HRESULT hr = E_FAIL;
642 ULONG bytesWritten;
643 ICONDIR iconDir;
644 SIZE_T iconOffset;
645 int validEntries = 0;
646 LARGE_INTEGER zero;
647
648 for (i = 0; i < grpIconDir->idCount; i++)
649 iconsSize += grpIconDir->idEntries[i].dwBytesInRes;
650 icons = HeapAlloc(GetProcessHeap(), 0, iconsSize);
651 if (icons == NULL)
652 {
653 WINE_ERR("out of memory allocating icon\n");
654 goto end;
655 }
656
657 iconDirEntries = HeapAlloc(GetProcessHeap(), 0, grpIconDir->idCount*sizeof(ICONDIRENTRY));
658 if (iconDirEntries == NULL)
659 {
660 WINE_ERR("out of memory allocating icon dir entries\n");
661 goto end;
662 }
663
664 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
665 if (FAILED(hr))
666 {
667 WINE_ERR("error creating icon stream\n");
668 goto end;
669 }
670
671 iconOffset = 0;
672 if (iconData16)
673 validEntries = populate_module16_icons(iconData16, grpIconDir, iconDirEntries, icons, &iconOffset);
674 else if (hModule)
675 validEntries = populate_module_icons(hModule, grpIconDir, iconDirEntries, icons, &iconOffset);
676
677 if (validEntries == 0)
678 {
679 WINE_ERR("no valid icon entries\n");
680 goto end;
681 }
682
683 iconDir.idReserved = 0;
684 iconDir.idType = 1;
685 iconDir.idCount = validEntries;
686 hr = IStream_Write(stream, &iconDir, sizeof(iconDir), &bytesWritten);
687 if (FAILED(hr) || bytesWritten != sizeof(iconDir))
688 {
689 WINE_ERR("error 0x%08X writing icon stream\n", hr);
690 goto end;
691 }
692 for (i = 0; i < validEntries; i++)
693 iconDirEntries[i].dwImageOffset += sizeof(ICONDIR) + validEntries*sizeof(ICONDIRENTRY);
694 hr = IStream_Write(stream, iconDirEntries, validEntries*sizeof(ICONDIRENTRY), &bytesWritten);
695 if (FAILED(hr) || bytesWritten != validEntries*sizeof(ICONDIRENTRY))
696 {
697 WINE_ERR("error 0x%08X writing icon dir entries to stream\n", hr);
698 goto end;
699 }
700 hr = IStream_Write(stream, icons, iconOffset, &bytesWritten);
701 if (FAILED(hr) || bytesWritten != iconOffset)
702 {
703 WINE_ERR("error 0x%08X writing icon images to stream\n", hr);
704 goto end;
705 }
706 zero.QuadPart = 0;
707 hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
708
709 end:
710 HeapFree(GetProcessHeap(), 0, icons);
711 HeapFree(GetProcessHeap(), 0, iconDirEntries);
712 if (FAILED(hr) && stream != NULL)
713 {
714 IStream_Release(stream);
715 stream = NULL;
716 }
717 return stream;
718 }
719
720 static HRESULT open_module16_icon(LPCWSTR szFileName, int nIndex, IStream **ppStream)
721 {
722 HANDLE hFile = INVALID_HANDLE_VALUE;
723 HANDLE hFileMapping = NULL;
724 DWORD fileSize;
725 BYTE *fileBytes = NULL;
726 IMAGE_DOS_HEADER *dosHeader;
727 IMAGE_OS2_HEADER *neHeader;
728 BYTE *rsrcTab;
729 NE_TYPEINFO *iconGroupResources;
730 NE_TYPEINFO *iconResources;
731 NE_NAMEINFO *iconDirPtr;
732 GRPICONDIR *iconDir;
733 WORD alignmentShiftCount;
734 struct IconData16 iconData16;
735 HRESULT hr = E_FAIL;
736
737 hFile = CreateFileW(szFileName, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
738 OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, NULL);
739 if (hFile == INVALID_HANDLE_VALUE)
740 {
741 WINE_WARN("opening %s failed with error %d\n", wine_dbgstr_w(szFileName), GetLastError());
742 goto end;
743 }
744
745 hFileMapping = CreateFileMappingW(hFile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
746 if (hFileMapping == NULL)
747 {
748 WINE_WARN("CreateFileMapping failed, error %d\n", GetLastError());
749 goto end;
750 }
751
752 fileSize = GetFileSize(hFile, NULL);
753
754 fileBytes = MapViewOfFile(hFileMapping, FILE_MAP_READ, 0, 0, 0);
755 if (fileBytes == NULL)
756 {
757 WINE_WARN("MapViewOfFile failed, error %d\n", GetLastError());
758 goto end;
759 }
760
761 dosHeader = (IMAGE_DOS_HEADER*)fileBytes;
762 if (sizeof(IMAGE_DOS_HEADER) >= fileSize || dosHeader->e_magic != IMAGE_DOS_SIGNATURE)
763 {
764 WINE_WARN("file too small for MZ header\n");
765 goto end;
766 }
767
768 neHeader = (IMAGE_OS2_HEADER*)(fileBytes + dosHeader->e_lfanew);
769 if ((((BYTE*)neHeader) + sizeof(IMAGE_OS2_HEADER)) > (fileBytes + fileSize) ||
770 neHeader->ne_magic != IMAGE_OS2_SIGNATURE)
771 {
772 WINE_WARN("file too small for NE header\n");
773 goto end;
774 }
775
776 rsrcTab = ((BYTE*)neHeader) + neHeader->ne_rsrctab;
777 if ((rsrcTab + 2) > (fileBytes + fileSize))
778 {
779 WINE_WARN("file too small for resource table\n");
780 goto end;
781 }
782
783 alignmentShiftCount = *(WORD*)rsrcTab;
784 rsrcTab += 2;
785 iconGroupResources = NULL;
786 iconResources = NULL;
787 for (;;)
788 {
789 NE_TYPEINFO *neTypeInfo = (NE_TYPEINFO*)rsrcTab;
790 if ((rsrcTab + sizeof(NE_TYPEINFO)) > (fileBytes + fileSize))
791 {
792 WINE_WARN("file too small for resource table\n");
793 goto end;
794 }
795 if (neTypeInfo->type_id == 0)
796 break;
797 else if (neTypeInfo->type_id == NE_RSCTYPE_GROUP_ICON)
798 iconGroupResources = neTypeInfo;
799 else if (neTypeInfo->type_id == NE_RSCTYPE_ICON)
800 iconResources = neTypeInfo;
801 rsrcTab += sizeof(NE_TYPEINFO) + neTypeInfo->count*sizeof(NE_NAMEINFO);
802 }
803 if (iconGroupResources == NULL)
804 {
805 WINE_WARN("no group icon resource type found\n");
806 goto end;
807 }
808 if (iconResources == NULL)
809 {
810 WINE_WARN("no icon resource type found\n");
811 goto end;
812 }
813
814 if (nIndex >= iconGroupResources->count)
815 {
816 WINE_WARN("icon index out of range\n");
817 goto end;
818 }
819
820 iconDirPtr = (NE_NAMEINFO*)(((BYTE*)iconGroupResources) + sizeof(NE_TYPEINFO) + nIndex*sizeof(NE_NAMEINFO));
821 if ((((BYTE*)iconDirPtr) + sizeof(NE_NAMEINFO)) > (fileBytes + fileSize))
822 {
823 WINE_WARN("file too small for icon group NE_NAMEINFO\n");
824 goto end;
825 }
826 iconDir = (GRPICONDIR*)(fileBytes + (iconDirPtr->offset << alignmentShiftCount));
827 if ((((BYTE*)iconDir) + sizeof(GRPICONDIR) + iconDir->idCount*sizeof(GRPICONDIRENTRY)) > (fileBytes + fileSize))
828 {
829 WINE_WARN("file too small for GRPICONDIR\n");
830 goto end;
831 }
832
833 iconData16.fileBytes = fileBytes;
834 iconData16.fileSize = fileSize;
835 iconData16.iconResources = iconResources;
836 iconData16.alignmentShiftCount = alignmentShiftCount;
837 *ppStream = add_module_icons_to_stream(&iconData16, NULL, iconDir);
838 if (*ppStream)
839 hr = S_OK;
840
841 end:
842 if (hFile != INVALID_HANDLE_VALUE)
843 CloseHandle(hFile);
844 if (hFileMapping != NULL)
845 CloseHandle(hFileMapping);
846 if (fileBytes != NULL)
847 UnmapViewOfFile(fileBytes);
848 return hr;
849 }
850
851 static BOOL CALLBACK EnumResNameProc(HMODULE hModule, LPCWSTR lpszType, LPWSTR lpszName, LONG_PTR lParam)
852 {
853 ENUMRESSTRUCT *sEnumRes = (ENUMRESSTRUCT *) lParam;
854
855 if (!sEnumRes->nIndex--)
856 {
857 *sEnumRes->pResInfo = FindResourceW(hModule, lpszName, (LPCWSTR)RT_GROUP_ICON);
858 return FALSE;
859 }
860 else
861 return TRUE;
862 }
863
864 static HRESULT open_module_icon(LPCWSTR szFileName, int nIndex, IStream **ppStream)
865 {
866 HMODULE hModule;
867 HRSRC hResInfo;
868 HGLOBAL hResData;
869 GRPICONDIR *pIconDir;
870 ENUMRESSTRUCT sEnumRes;
871 HRESULT hr = E_FAIL;
872
873 hModule = LoadLibraryExW(szFileName, 0, LOAD_LIBRARY_AS_DATAFILE);
874 if (!hModule)
875 {
876 if (GetLastError() == ERROR_BAD_EXE_FORMAT)
877 return open_module16_icon(szFileName, nIndex, ppStream);
878 else
879 {
880 WINE_WARN("LoadLibraryExW (%s) failed, error %d\n",
881 wine_dbgstr_w(szFileName), GetLastError());
882 return HRESULT_FROM_WIN32(GetLastError());
883 }
884 }
885
886 if (nIndex < 0)
887 {
888 hResInfo = FindResourceW(hModule, MAKEINTRESOURCEW(-nIndex), (LPCWSTR)RT_GROUP_ICON);
889 WINE_TRACE("FindResourceW (%s) called, return %p, error %d\n",
890 wine_dbgstr_w(szFileName), hResInfo, GetLastError());
891 }
892 else
893 {
894 hResInfo=NULL;
895 sEnumRes.pResInfo = &hResInfo;
896 sEnumRes.nIndex = nIndex;
897 if (!EnumResourceNamesW(hModule, (LPCWSTR)RT_GROUP_ICON,
898 EnumResNameProc, (LONG_PTR)&sEnumRes) &&
899 sEnumRes.nIndex != -1)
900 {
901 WINE_TRACE("EnumResourceNamesW failed, error %d\n", GetLastError());
902 }
903 }
904
905 if (hResInfo)
906 {
907 if ((hResData = LoadResource(hModule, hResInfo)))
908 {
909 if ((pIconDir = LockResource(hResData)))
910 {
911 *ppStream = add_module_icons_to_stream(0, hModule, pIconDir);
912 if (*ppStream)
913 hr = S_OK;
914 }
915
916 FreeResource(hResData);
917 }
918 }
919 else
920 {
921 WINE_WARN("found no icon\n");
922 FreeLibrary(hModule);
923 return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
924 }
925
926 FreeLibrary(hModule);
927 return hr;
928 }
929
930 static HRESULT read_ico_direntries(IStream *icoStream, ICONDIRENTRY **ppIconDirEntries, int *numEntries)
931 {
932 ICONDIR iconDir;
933 ULONG bytesRead;
934 HRESULT hr;
935
936 *ppIconDirEntries = NULL;
937
938 hr = IStream_Read(icoStream, &iconDir, sizeof(ICONDIR), &bytesRead);
939 if (FAILED(hr) || bytesRead != sizeof(ICONDIR) ||
940 (iconDir.idReserved != 0) || (iconDir.idType != 1))
941 {
942 WINE_WARN("Invalid ico file format (hr=0x%08X, bytesRead=%d)\n", hr, bytesRead);
943 hr = E_FAIL;
944 goto end;
945 }
946 *numEntries = iconDir.idCount;
947
948 if ((*ppIconDirEntries = HeapAlloc(GetProcessHeap(), 0, sizeof(ICONDIRENTRY)*iconDir.idCount)) == NULL)
949 {
950 hr = E_OUTOFMEMORY;
951 goto end;
952 }
953 hr = IStream_Read(icoStream, *ppIconDirEntries, sizeof(ICONDIRENTRY)*iconDir.idCount, &bytesRead);
954 if (FAILED(hr) || bytesRead != sizeof(ICONDIRENTRY)*iconDir.idCount)
955 {
956 if (SUCCEEDED(hr)) hr = E_FAIL;
957 goto end;
958 }
959
960 end:
961 if (FAILED(hr))
962 HeapFree(GetProcessHeap(), 0, *ppIconDirEntries);
963 return hr;
964 }
965
966 static HRESULT write_native_icon(IStream *iconStream, const char *icon_name, LPCWSTR szFileName)
967 {
968 ICONDIRENTRY *pIconDirEntry = NULL;
969 int numEntries;
970 int nMax = 0, nMaxBits = 0;
971 int nIndex = 0;
972 int i;
973 LARGE_INTEGER position;
974 HRESULT hr;
975
976 hr = read_ico_direntries(iconStream, &pIconDirEntry, &numEntries);
977 if (FAILED(hr))
978 goto end;
979
980 for (i = 0; i < numEntries; i++)
981 {
982 WINE_TRACE("[%d]: %d x %d @ %d\n", i, pIconDirEntry[i].bWidth, pIconDirEntry[i].bHeight, pIconDirEntry[i].wBitCount);
983 if (pIconDirEntry[i].wBitCount >= nMaxBits &&
984 (pIconDirEntry[i].bHeight * pIconDirEntry[i].bWidth) >= nMax)
985 {
986 nIndex = i;
987 nMax = pIconDirEntry[i].bHeight * pIconDirEntry[i].bWidth;
988 nMaxBits = pIconDirEntry[i].wBitCount;
989 }
990 }
991 WINE_TRACE("Selected: %d\n", nIndex);
992
993 position.QuadPart = 0;
994 hr = IStream_Seek(iconStream, position, STREAM_SEEK_SET, NULL);
995 if (FAILED(hr))
996 goto end;
997 hr = convert_to_native_icon(iconStream, &nIndex, 1, &CLSID_WICPngEncoder, icon_name, szFileName);
998
999 end:
1000 HeapFree(GetProcessHeap(), 0, pIconDirEntry);
1001 return hr;
1002 }
1003
1004 static HRESULT open_file_type_icon(LPCWSTR szFileName, IStream **ppStream)
1005 {
1006 static const WCHAR openW[] = {'o','p','e','n',0};
1007 WCHAR *extension;
1008 WCHAR *icon = NULL;
1009 WCHAR *comma;
1010 WCHAR *executable = NULL;
1011 int index = 0;
1012 char *output_path = NULL;
1013 HRESULT hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
1014
1015 extension = strrchrW(szFileName, '.');
1016 if (extension == NULL)
1017 goto end;
1018
1019 icon = assoc_query(ASSOCSTR_DEFAULTICON, extension, NULL);
1020 if (icon)
1021 {
1022 comma = strrchrW(icon, ',');
1023 if (comma)
1024 {
1025 *comma = 0;
1026 index = atoiW(comma + 1);
1027 }
1028 hr = open_icon(icon, index, FALSE, ppStream);
1029 }
1030 else
1031 {
1032 executable = assoc_query(ASSOCSTR_EXECUTABLE, extension, openW);
1033 if (executable)
1034 hr = open_icon(executable, 0, FALSE, ppStream);
1035 }
1036
1037 end:
1038 HeapFree(GetProcessHeap(), 0, icon);
1039 HeapFree(GetProcessHeap(), 0, executable);
1040 HeapFree(GetProcessHeap(), 0, output_path);
1041 return hr;
1042 }
1043
1044 static HRESULT open_default_icon(IStream **ppStream)
1045 {
1046 static const WCHAR user32W[] = {'u','s','e','r','3','2',0};
1047
1048 return open_module_icon(user32W, -(INT_PTR)IDI_WINLOGO, ppStream);
1049 }
1050
1051 static HRESULT open_icon(LPCWSTR filename, int index, BOOL bWait, IStream **ppStream)
1052 {
1053 HRESULT hr;
1054
1055 hr = open_module_icon(filename, index, ppStream);
1056 if (FAILED(hr))
1057 {
1058 if(bWait && hr == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND))
1059 {
1060 WINE_WARN("Can't find file: %s, give a chance to parent process to create it\n",
1061 wine_dbgstr_w(filename));
1062 return hr;
1063 }
1064 else
1065 {
1066 static const WCHAR dot_icoW[] = {'.','i','c','o',0};
1067 int len = strlenW(filename);
1068 if (len >= 4 && strcmpiW(&filename[len - 4], dot_icoW) == 0)
1069 hr = SHCreateStreamOnFileW(filename, STGM_READ, ppStream);
1070 }
1071 }
1072 if (FAILED(hr))
1073 hr = open_file_type_icon(filename, ppStream);
1074 if (FAILED(hr) && !bWait)
1075 hr = open_default_icon(ppStream);
1076 return hr;
1077 }
1078
1079 static char* compute_native_identifier(int exeIndex, LPCWSTR icoPathW)
1080 {
1081 char* nativeIdentifier;
1082 char *icoPathA;
1083 unsigned short crc;
1084 char *basename, *ext;
1085
1086 icoPathA = wchars_to_utf8_chars(icoPathW);
1087 if (icoPathA == NULL)
1088 return NULL;
1089
1090 crc = crc16(icoPathA);
1091 basename = strrchr(icoPathA, '\\');
1092 if (basename == NULL)
1093 basename = icoPathA;
1094 else
1095 {
1096 *basename = 0;
1097 basename++;
1098 }
1099 ext = strrchr(basename, '.');
1100 if (ext)
1101 *ext = 0;
1102
1103 nativeIdentifier = heap_printf("%04X_%s.%d", crc, basename, exeIndex);
1104 HeapFree(GetProcessHeap(), 0, icoPathA);
1105 return nativeIdentifier;
1106 }
1107
1108 #ifdef __APPLE__
1109 #define ICNS_SLOTS 6
1110
1111 static inline int size_to_slot(int size)
1112 {
1113 switch (size)
1114 {
1115 case 16: return 0;
1116 case 32: return 1;
1117 case 48: return 2;
1118 case 64: return -2; /* Classic Mode */
1119 case 128: return 3;
1120 case 256: return 4;
1121 case 512: return 5;
1122 }
1123
1124 return -1;
1125 }
1126
1127 #define CLASSIC_SLOT 3
1128
1129 static HRESULT platform_write_icon(IStream *icoStream, int exeIndex, LPCWSTR icoPathW,
1130 const char *destFilename, char **nativeIdentifier)
1131 {
1132 ICONDIRENTRY *iconDirEntries = NULL;
1133 int numEntries;
1134 struct {
1135 int index;
1136 int maxBits;
1137 BOOL scaled;
1138 } best[ICNS_SLOTS];
1139 int indexes[ICNS_SLOTS];
1140 int i;
1141 char *icnsPath = NULL;
1142 LARGE_INTEGER zero;
1143 HRESULT hr;
1144
1145 hr = read_ico_direntries(icoStream, &iconDirEntries, &numEntries);
1146 if (FAILED(hr))
1147 goto end;
1148 for (i = 0; i < ICNS_SLOTS; i++)
1149 {
1150 best[i].index = -1;
1151 best[i].maxBits = 0;
1152 }
1153 for (i = 0; i < numEntries; i++)
1154 {
1155 int slot;
1156 int width = iconDirEntries[i].bWidth ? iconDirEntries[i].bWidth : 256;
1157 int height = iconDirEntries[i].bHeight ? iconDirEntries[i].bHeight : 256;
1158 BOOL scaled = FALSE;
1159
1160 WINE_TRACE("[%d]: %d x %d @ %d\n", i, width, height, iconDirEntries[i].wBitCount);
1161 if (height != width)
1162 continue;
1163 slot = size_to_slot(width);
1164 if (slot == -2)
1165 {
1166 scaled = TRUE;
1167 slot = CLASSIC_SLOT;
1168 }
1169 else if (slot < 0)
1170 continue;
1171 if (scaled && best[slot].maxBits && !best[slot].scaled)
1172 continue; /* don't replace unscaled with scaled */
1173 if (iconDirEntries[i].wBitCount >= best[slot].maxBits || (!scaled && best[slot].scaled))
1174 {
1175 best[slot].index = i;
1176 best[slot].maxBits = iconDirEntries[i].wBitCount;
1177 best[slot].scaled = scaled;
1178 }
1179 }
1180 /* remove the scaled icon if a larger unscaled icon exists */
1181 if (best[CLASSIC_SLOT].scaled)
1182 {
1183 for (i = CLASSIC_SLOT+1; i < ICNS_SLOTS; i++)
1184 if (best[i].index >= 0 && !best[i].scaled)
1185 {
1186 best[CLASSIC_SLOT].index = -1;
1187 break;
1188 }
1189 }
1190
1191 numEntries = 0;
1192 for (i = 0; i < ICNS_SLOTS; i++)
1193 {
1194 if (best[i].index >= 0)
1195 {
1196 indexes[numEntries] = best[i].index;
1197 numEntries++;
1198 }
1199 }
1200
1201 if (destFilename)
1202 *nativeIdentifier = heap_printf("%s", destFilename);
1203 else
1204 *nativeIdentifier = compute_native_identifier(exeIndex, icoPathW);
1205 if (*nativeIdentifier == NULL)
1206 {
1207 hr = E_OUTOFMEMORY;
1208 goto end;
1209 }
1210 icnsPath = heap_printf("/tmp/%s.icns", *nativeIdentifier);
1211 if (icnsPath == NULL)
1212 {
1213 hr = E_OUTOFMEMORY;
1214 WINE_WARN("out of memory creating ICNS path\n");
1215 goto end;
1216 }
1217 zero.QuadPart = 0;
1218 hr = IStream_Seek(icoStream, zero, STREAM_SEEK_SET, NULL);
1219 if (FAILED(hr))
1220 {
1221 WINE_WARN("seeking icon stream failed, error 0x%08X\n", hr);
1222 goto end;
1223 }
1224 hr = convert_to_native_icon(icoStream, indexes, numEntries, &CLSID_WICIcnsEncoder,
1225 icnsPath, icoPathW);
1226 if (FAILED(hr))
1227 {
1228 WINE_WARN("converting %s to %s failed, error 0x%08X\n",
1229 wine_dbgstr_w(icoPathW), wine_dbgstr_a(icnsPath), hr);
1230 goto end;
1231 }
1232
1233 end:
1234 HeapFree(GetProcessHeap(), 0, iconDirEntries);
1235 HeapFree(GetProcessHeap(), 0, icnsPath);
1236 return hr;
1237 }
1238 #else
1239 static void refresh_icon_cache(const char *iconsDir)
1240 {
1241 /* The icon theme spec only requires the mtime on the "toplevel"
1242 * directory (whatever that is) to be changed for a refresh,
1243 * but on GNOME you have to create a file in that directory
1244 * instead. Creating a file also works on KDE, Xfce and LXDE.
1245 */
1246 char *filename = heap_printf("%s/.wine-refresh-XXXXXX", iconsDir);
1247 if (filename != NULL)
1248 {
1249 int fd = mkstemps(filename, 0);
1250 if (fd >= 0)
1251 {
1252 close(fd);
1253 unlink(filename);
1254 }
1255 HeapFree(GetProcessHeap(), 0, filename);
1256 }
1257 }
1258
1259 static HRESULT platform_write_icon(IStream *icoStream, int exeIndex, LPCWSTR icoPathW,
1260 const char *destFilename, char **nativeIdentifier)
1261 {
1262 ICONDIRENTRY *iconDirEntries = NULL;
1263 int numEntries;
1264 int i;
1265 char *iconsDir = NULL;
1266 HRESULT hr = S_OK;
1267 LARGE_INTEGER zero;
1268
1269 hr = read_ico_direntries(icoStream, &iconDirEntries, &numEntries);
1270 if (FAILED(hr))
1271 goto end;
1272
1273 if (destFilename)
1274 *nativeIdentifier = heap_printf("%s", destFilename);
1275 else
1276 *nativeIdentifier = compute_native_identifier(exeIndex, icoPathW);
1277 if (*nativeIdentifier == NULL)
1278 {
1279 hr = E_OUTOFMEMORY;
1280 goto end;
1281 }
1282 iconsDir = heap_printf("%s/icons/hicolor", xdg_data_dir);
1283 if (iconsDir == NULL)
1284 {
1285 hr = E_OUTOFMEMORY;
1286 goto end;
1287 }
1288
1289 for (i = 0; i < numEntries; i++)
1290 {
1291 int bestIndex = i;
1292 int j;
1293 BOOLEAN duplicate = FALSE;
1294 int w, h;
1295 char *iconDir = NULL;
1296 char *pngPath = NULL;
1297
1298 WINE_TRACE("[%d]: %d x %d @ %d\n", i, iconDirEntries[i].bWidth,
1299 iconDirEntries[i].bHeight, iconDirEntries[i].wBitCount);
1300
1301 for (j = 0; j < i; j++)
1302 {
1303 if (iconDirEntries[j].bWidth == iconDirEntries[i].bWidth &&
1304 iconDirEntries[j].bHeight == iconDirEntries[i].bHeight)
1305 {
1306 duplicate = TRUE;
1307 break;
1308 }
1309 }
1310 if (duplicate)
1311 continue;
1312 for (j = i + 1; j < numEntries; j++)
1313 {
1314 if (iconDirEntries[j].bWidth == iconDirEntries[i].bWidth &&
1315 iconDirEntries[j].bHeight == iconDirEntries[i].bHeight &&
1316 iconDirEntries[j].wBitCount >= iconDirEntries[bestIndex].wBitCount)
1317 {
1318 bestIndex = j;
1319 }
1320 }
1321 WINE_TRACE("Selected: %d\n", bestIndex);
1322
1323 w = iconDirEntries[bestIndex].bWidth ? iconDirEntries[bestIndex].bWidth : 256;
1324 h = iconDirEntries[bestIndex].bHeight ? iconDirEntries[bestIndex].bHeight : 256;
1325 iconDir = heap_printf("%s/%dx%d/apps", iconsDir, w, h);
1326 if (iconDir == NULL)
1327 {
1328 hr = E_OUTOFMEMORY;
1329 goto endloop;
1330 }
1331 create_directories(iconDir);
1332 pngPath = heap_printf("%s/%s.png", iconDir, *nativeIdentifier);
1333 if (pngPath == NULL)
1334 {
1335 hr = E_OUTOFMEMORY;
1336 goto endloop;
1337 }
1338 zero.QuadPart = 0;
1339 hr = IStream_Seek(icoStream, zero, STREAM_SEEK_SET, NULL);
1340 if (FAILED(hr))
1341 goto endloop;
1342 hr = convert_to_native_icon(icoStream, &bestIndex, 1, &CLSID_WICPngEncoder,
1343 pngPath, icoPathW);
1344
1345 endloop:
1346 HeapFree(GetProcessHeap(), 0, iconDir);
1347 HeapFree(GetProcessHeap(), 0, pngPath);
1348 }
1349 refresh_icon_cache(iconsDir);
1350
1351 end:
1352 HeapFree(GetProcessHeap(), 0, iconDirEntries);
1353 HeapFree(GetProcessHeap(), 0, iconsDir);
1354 return hr;
1355 }
1356 #endif /* defined(__APPLE__) */
1357
1358 /* extract an icon from an exe or icon file; helper for IPersistFile_fnSave */
1359 static char *extract_icon(LPCWSTR icoPathW, int index, const char *destFilename, BOOL bWait)
1360 {
1361 IStream *stream = NULL;
1362 HRESULT hr;
1363 char *nativeIdentifier = NULL;
1364
1365 WINE_TRACE("path=[%s] index=%d destFilename=[%s]\n", wine_dbgstr_w(icoPathW), index, wine_dbgstr_a(destFilename));
1366
1367 hr = open_icon(icoPathW, index, bWait, &stream);
1368 if (FAILED(hr))
1369 {
1370 WINE_WARN("opening icon %s index %d failed, hr=0x%08X\n", wine_dbgstr_w(icoPathW), index, hr);
1371 goto end;
1372 }
1373 hr = platform_write_icon(stream, index, icoPathW, destFilename, &nativeIdentifier);
1374 if (FAILED(hr))
1375 WINE_WARN("writing icon failed, error 0x%08X\n", hr);
1376
1377 end:
1378 if (stream)
1379 IStream_Release(stream);
1380 if (FAILED(hr))
1381 {
1382 HeapFree(GetProcessHeap(), 0, nativeIdentifier);
1383 nativeIdentifier = NULL;
1384 }
1385 return nativeIdentifier;
1386 }
1387
1388 static HKEY open_menus_reg_key(void)
1389 {
1390 static const WCHAR Software_Wine_FileOpenAssociationsW[] = {
1391 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','M','e','n','u','F','i','l','e','s',0};
1392 HKEY assocKey;
1393 DWORD ret;
1394 ret = RegCreateKeyW(HKEY_CURRENT_USER, Software_Wine_FileOpenAssociationsW, &assocKey);
1395 if (ret == ERROR_SUCCESS)
1396 return assocKey;
1397 SetLastError(ret);
1398 return NULL;
1399 }
1400
1401 static DWORD register_menus_entry(const char *unix_file, const char *windows_file)
1402 {
1403 WCHAR *unix_fileW;
1404 WCHAR *windows_fileW;
1405 INT size;
1406 DWORD ret;
1407
1408 size = MultiByteToWideChar(CP_UNIXCP, 0, unix_file, -1, NULL, 0);
1409 unix_fileW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1410 if (unix_fileW)
1411 {
1412 MultiByteToWideChar(CP_UNIXCP, 0, unix_file, -1, unix_fileW, size);
1413 size = MultiByteToWideChar(CP_UNIXCP, 0, windows_file, -1, NULL, 0);
1414 windows_fileW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1415 if (windows_fileW)
1416 {
1417 HKEY hkey;
1418 MultiByteToWideChar(CP_UNIXCP, 0, windows_file, -1, windows_fileW, size);
1419 hkey = open_menus_reg_key();
1420 if (hkey)
1421 {
1422 ret = RegSetValueExW(hkey, unix_fileW, 0, REG_SZ, (const BYTE*)windows_fileW,
1423 (strlenW(windows_fileW) + 1) * sizeof(WCHAR));
1424 RegCloseKey(hkey);
1425 }
1426 else
1427 ret = GetLastError();
1428 HeapFree(GetProcessHeap(), 0, windows_fileW);
1429 }
1430 else
1431 ret = ERROR_NOT_ENOUGH_MEMORY;
1432 HeapFree(GetProcessHeap(), 0, unix_fileW);
1433 }
1434 else
1435 ret = ERROR_NOT_ENOUGH_MEMORY;
1436 return ret;
1437 }
1438
1439 static BOOL write_desktop_entry(const char *unix_link, const char *location, const char *linkname,
1440 const char *path, const char *args, const char *descr,
1441 const char *workdir, const char *icon)
1442 {
1443 FILE *file;
1444
1445 WINE_TRACE("(%s,%s,%s,%s,%s,%s,%s,%s)\n", wine_dbgstr_a(unix_link), wine_dbgstr_a(location),
1446 wine_dbgstr_a(linkname), wine_dbgstr_a(path), wine_dbgstr_a(args),
1447 wine_dbgstr_a(descr), wine_dbgstr_a(workdir), wine_dbgstr_a(icon));
1448
1449 file = fopen(location, "w");
1450 if (file == NULL)
1451 return FALSE;
1452
1453 fprintf(file, "[Desktop Entry]\n");
1454 fprintf(file, "Name=%s\n", linkname);
1455 fprintf(file, "Exec=env WINEPREFIX=\"%s\" wine %s %s\n",
1456 wine_get_config_dir(), path, args);
1457 fprintf(file, "Type=Application\n");
1458 fprintf(file, "StartupNotify=true\n");
1459 if (descr && lstrlenA(descr))
1460 fprintf(file, "Comment=%s\n", descr);
1461 if (workdir && lstrlenA(workdir))
1462 fprintf(file, "Path=%s\n", workdir);
1463 if (icon && lstrlenA(icon))
1464 fprintf(file, "Icon=%s\n", icon);
1465
1466 fclose(file);
1467
1468 if (unix_link)
1469 {
1470 DWORD ret = register_menus_entry(location, unix_link);
1471 if (ret != ERROR_SUCCESS)
1472 return FALSE;
1473 }
1474
1475 return TRUE;
1476 }
1477
1478 static BOOL write_directory_entry(const char *directory, const char *location)
1479 {
1480 FILE *file;
1481
1482 WINE_TRACE("(%s,%s)\n", wine_dbgstr_a(directory), wine_dbgstr_a(location));
1483
1484 file = fopen(location, "w");
1485 if (file == NULL)
1486 return FALSE;
1487
1488 fprintf(file, "[Desktop Entry]\n");
1489 fprintf(file, "Type=Directory\n");
1490 if (strcmp(directory, "wine") == 0)
1491 {
1492 fprintf(file, "Name=Wine\n");
1493 fprintf(file, "Icon=wine\n");
1494 }
1495 else
1496 {
1497 fprintf(file, "Name=%s\n", directory);
1498 fprintf(file, "Icon=folder\n");
1499 }
1500
1501 fclose(file);
1502 return TRUE;
1503 }
1504
1505 static BOOL write_menu_file(const char *unix_link, const char *filename)
1506 {
1507 char *tempfilename;
1508 FILE *tempfile = NULL;
1509 char *lastEntry;
1510 char *name = NULL;
1511 char *menuPath = NULL;
1512 int i;
1513 int count = 0;
1514 BOOL ret = FALSE;
1515
1516 WINE_TRACE("(%s)\n", wine_dbgstr_a(filename));
1517
1518 while (1)
1519 {
1520 tempfilename = heap_printf("%s/wine-menu-XXXXXX", xdg_config_dir);
1521 if (tempfilename)
1522 {
1523 int tempfd = mkstemps(tempfilename, 0);
1524 if (tempfd >= 0)
1525 {
1526 tempfile = fdopen(tempfd, "w");
1527 if (tempfile)
1528 break;
1529 close(tempfd);
1530 goto end;
1531 }
1532 else if (errno == EEXIST)
1533 {
1534 HeapFree(GetProcessHeap(), 0, tempfilename);
1535 continue;
1536 }
1537 HeapFree(GetProcessHeap(), 0, tempfilename);
1538 }
1539 return FALSE;
1540 }
1541
1542 fprintf(tempfile, "<!DOCTYPE Menu PUBLIC \"-//freedesktop//DTD Menu 1.0//EN\"\n");
1543 fprintf(tempfile, "\"http://www.freedesktop.org/standards/menu-spec/menu-1.0.dtd\">\n");
1544 fprintf(tempfile, "<Menu>\n");
1545 fprintf(tempfile, " <Name>Applications</Name>\n");
1546
1547 name = HeapAlloc(GetProcessHeap(), 0, lstrlenA(filename) + 1);
1548 if (name == NULL) goto end;
1549 lastEntry = name;
1550 for (i = 0; filename[i]; i++)
1551 {
1552 name[i] = filename[i];
1553 if (filename[i] == '/')
1554 {
1555 char *dir_file_name;
1556 struct stat st;
1557 name[i] = 0;
1558 fprintf(tempfile, " <Menu>\n");
1559 fprintf(tempfile, " <Name>%s", count ? "" : "wine-");
1560 write_xml_text(tempfile, name);
1561 fprintf(tempfile, "</Name>\n");
1562 fprintf(tempfile, " <Directory>%s", count ? "" : "wine-");
1563 write_xml_text(tempfile, name);
1564 fprintf(tempfile, ".directory</Directory>\n");
1565 dir_file_name = heap_printf("%s/desktop-directories/%s%s.directory",
1566 xdg_data_dir, count ? "" : "wine-", name);
1567 if (dir_file_name)
1568 {
1569 if (stat(dir_file_name, &st) != 0 && errno == ENOENT)
1570 write_directory_entry(lastEntry, dir_file_name);
1571 HeapFree(GetProcessHeap(), 0, dir_file_name);
1572 }
1573 name[i] = '-';
1574 lastEntry = &name[i+1];
1575 ++count;
1576 }
1577 }
1578 name[i] = 0;
1579
1580 fprintf(tempfile, " <Include>\n");
1581 fprintf(tempfile, " <Filename>");
1582 write_xml_text(tempfile, name);
1583 fprintf(tempfile, "</Filename>\n");
1584 fprintf(tempfile, " </Include>\n");
1585 for (i = 0; i < count; i++)
1586 fprintf(tempfile, " </Menu>\n");
1587 fprintf(tempfile, "</Menu>\n");
1588
1589 menuPath = heap_printf("%s/%s", xdg_config_dir, name);
1590 if (menuPath == NULL) goto end;
1591 strcpy(menuPath + strlen(menuPath) - strlen(".desktop"), ".menu");
1592 ret = TRUE;
1593
1594 end:
1595 if (tempfile)
1596 fclose(tempfile);
1597 if (ret)
1598 ret = (rename(tempfilename, menuPath) == 0);
1599 if (!ret && tempfilename)
1600 remove(tempfilename);
1601 HeapFree(GetProcessHeap(), 0, tempfilename);
1602 if (ret)
1603 register_menus_entry(menuPath, unix_link);
1604 HeapFree(GetProcessHeap(), 0, name);
1605 HeapFree(GetProcessHeap(), 0, menuPath);
1606 return ret;
1607 }
1608
1609 static BOOL write_menu_entry(const char *unix_link, const char *link, const char *path, const char *args,
1610 const char *descr, const char *workdir, const char *icon)
1611 {
1612 const char *linkname;
1613 char *desktopPath = NULL;
1614 char *desktopDir;
1615 char *filename = NULL;
1616 BOOL ret = TRUE;
1617
1618 WINE_TRACE("(%s, %s, %s, %s, %s, %s, %s)\n", wine_dbgstr_a(unix_link), wine_dbgstr_a(link),
1619 wine_dbgstr_a(path), wine_dbgstr_a(args), wine_dbgstr_a(descr),
1620 wine_dbgstr_a(workdir), wine_dbgstr_a(icon));
1621
1622 linkname = strrchr(link, '/');
1623 if (linkname == NULL)
1624 linkname = link;
1625 else
1626 ++linkname;
1627
1628 desktopPath = heap_printf("%s/applications/wine/%s.desktop", xdg_data_dir, link);
1629 if (!desktopPath)
1630 {
1631 WINE_WARN("out of memory creating menu entry\n");
1632 ret = FALSE;
1633 goto end;
1634 }
1635 desktopDir = strrchr(desktopPath, '/');
1636 *desktopDir = 0;
1637 if (!create_directories(desktopPath))
1638 {
1639 WINE_WARN("couldn't make parent directories for %s\n", wine_dbgstr_a(desktopPath));
1640 ret = FALSE;
1641 goto end;
1642 }
1643 *desktopDir = '/';
1644 if (!write_desktop_entry(unix_link, desktopPath, linkname, path, args, descr, workdir, icon))
1645 {
1646 WINE_WARN("couldn't make desktop entry %s\n", wine_dbgstr_a(desktopPath));
1647 ret = FALSE;
1648 goto end;
1649 }
1650
1651 filename = heap_printf("wine/%s.desktop", link);
1652 if (!filename || !write_menu_file(unix_link, filename))
1653 {
1654 WINE_WARN("couldn't make menu file %s\n", wine_dbgstr_a(filename));
1655 ret = FALSE;
1656 }
1657
1658 end:
1659 HeapFree(GetProcessHeap(), 0, desktopPath);
1660 HeapFree(GetProcessHeap(), 0, filename);
1661 return ret;
1662 }
1663
1664 /* This escapes reserved characters in .desktop files' Exec keys. */
1665 static LPSTR escape(LPCWSTR arg)
1666 {
1667 int i, j;
1668 WCHAR *escaped_string;
1669 char *utf8_string;
1670
1671 escaped_string = HeapAlloc(GetProcessHeap(), 0, (4 * strlenW(arg) + 1) * sizeof(WCHAR));
1672 if (escaped_string == NULL) return NULL;
1673 for (i = j = 0; arg[i]; i++)
1674 {
1675 switch (arg[i])
1676 {
1677 case '\\':
1678 escaped_string[j++] = '\\';
1679 escaped_string[j++] = '\\';
1680 escaped_string[j++] = '\\';
1681 escaped_string[j++] = '\\';
1682 break;
1683 case ' ':
1684 case '\t':
1685 case '\n':
1686 case '"':
1687 case '\'':
1688 case '>':
1689 case '<':
1690 case '~':
1691 case '|':
1692 case '&':
1693 case ';':
1694 case '$':
1695 case '*':
1696 case '?':
1697 case '#':
1698 case '(':
1699 case ')':
1700 case '`':
1701 escaped_string[j++] = '\\';
1702 escaped_string[j++] = '\\';
1703 /* fall through */
1704 default:
1705 escaped_string[j++] = arg[i];
1706 break;
1707 }
1708 }
1709 escaped_string[j] = 0;
1710
1711 utf8_string = wchars_to_utf8_chars(escaped_string);
1712 if (utf8_string == NULL)
1713 {
1714 WINE_ERR("out of memory\n");
1715 goto end;
1716 }
1717
1718 end:
1719 HeapFree(GetProcessHeap(), 0, escaped_string);
1720 return utf8_string;
1721 }
1722
1723 /* Return a heap-allocated copy of the unix format difference between the two
1724 * Windows-format paths.
1725 * locn is the owning location
1726 * link is within locn
1727 */
1728 static char *relative_path( LPCWSTR link, LPCWSTR locn )
1729 {
1730 char *unix_locn, *unix_link;
1731 char *relative = NULL;
1732
1733 unix_locn = wine_get_unix_file_name(locn);
1734 unix_link = wine_get_unix_file_name(link);
1735 if (unix_locn && unix_link)
1736 {
1737 size_t len_unix_locn, len_unix_link;
1738 len_unix_locn = strlen (unix_locn);
1739 len_unix_link = strlen (unix_link);
1740 if (len_unix_locn < len_unix_link && memcmp (unix_locn, unix_link, len_unix_locn) == 0 && unix_link[len_unix_locn] == '/')
1741 {
1742 size_t len_rel;
1743 char *p = strrchr (unix_link + len_unix_locn, '/');
1744 p = strrchr (p, '.');
1745 if (p)
1746 {
1747 *p = '\0';
1748 len_unix_link = p - unix_link;
1749 }
1750 len_rel = len_unix_link - len_unix_locn;
1751 relative = HeapAlloc(GetProcessHeap(), 0, len_rel);
1752 if (relative)
1753 {
1754 memcpy (relative, unix_link + len_unix_locn + 1, len_rel);
1755 }
1756 }
1757 }
1758 if (!relative)
1759 WINE_WARN("Could not separate the relative link path of %s in %s\n", wine_dbgstr_w(link), wine_dbgstr_w(locn));
1760 HeapFree(GetProcessHeap(), 0, unix_locn);
1761 HeapFree(GetProcessHeap(), 0, unix_link);
1762 return relative;
1763 }
1764
1765 /***********************************************************************
1766 *
1767 * GetLinkLocation
1768 *
1769 * returns TRUE if successful
1770 * *loc will contain CS_DESKTOPDIRECTORY, CS_STARTMENU, CS_STARTUP etc.
1771 * *relative will contain the address of a heap-allocated copy of the portion
1772 * of the filename that is within the specified location, in unix form
1773 */
1774 static BOOL GetLinkLocation( LPCWSTR linkfile, DWORD *loc, char **relative )
1775 {
1776 WCHAR filename[MAX_PATH], shortfilename[MAX_PATH], buffer[MAX_PATH];
1777 DWORD len, i, r, filelen;
1778 const DWORD locations[] = {
1779 CSIDL_STARTUP, CSIDL_DESKTOPDIRECTORY, CSIDL_STARTMENU,
1780 CSIDL_COMMON_STARTUP, CSIDL_COMMON_DESKTOPDIRECTORY,
1781 CSIDL_COMMON_STARTMENU };
1782
1783 WINE_TRACE("%s\n", wine_dbgstr_w(linkfile));
1784 filelen=GetFullPathNameW( linkfile, MAX_PATH, shortfilename, NULL );
1785 if (filelen==0 || filelen>MAX_PATH)
1786 return FALSE;
1787
1788 WINE_TRACE("%s\n", wine_dbgstr_w(shortfilename));
1789
1790 /* the CSLU Toolkit uses a short path name when creating .lnk files;
1791 * expand or our hardcoded list won't match.
1792 */
1793 filelen=GetLongPathNameW(shortfilename, filename, MAX_PATH);
1794 if (filelen==0 || filelen>MAX_PATH)
1795 return FALSE;
1796
1797 WINE_TRACE("%s\n", wine_dbgstr_w(filename));
1798
1799 for( i=0; i<sizeof(locations)/sizeof(locations[0]); i++ )
1800 {
1801 if (!SHGetSpecialFolderPathW( 0, buffer, locations[i], FALSE ))
1802 continue;
1803
1804 len = lstrlenW(buffer);
1805 if (len >= MAX_PATH)
1806 continue; /* We've just trashed memory! Hopefully we are OK */
1807
1808 if (len > filelen || filename[len]!='\\')
1809 continue;
1810 /* do a lstrcmpinW */
1811 filename[len] = 0;
1812 r = lstrcmpiW( filename, buffer );
1813 filename[len] = '\\';
1814 if ( r )
1815 continue;
1816
1817 /* return the remainder of the string and link type */
1818 *loc = locations[i];
1819 *relative = relative_path (filename, buffer);
1820 return (*relative != NULL);
1821 }
1822
1823 return FALSE;
1824 }
1825
1826 /* gets the target path directly or through MSI */
1827 static HRESULT get_cmdline( IShellLinkW *sl, LPWSTR szPath, DWORD pathSize,
1828 LPWSTR szArgs, DWORD argsSize)
1829 {
1830 IShellLinkDataList *dl = NULL;
1831 EXP_DARWIN_LINK *dar = NULL;
1832 HRESULT hr;
1833
1834 szPath[0] = 0;
1835 szArgs[0] = 0;
1836
1837 hr = IShellLinkW_GetPath( sl, szPath, pathSize, NULL, SLGP_RAWPATH );
1838 if (hr == S_OK && szPath[0])
1839 {
1840 IShellLinkW_GetArguments( sl, szArgs, argsSize );
1841 return hr;
1842 }
1843
1844 hr = IShellLinkW_QueryInterface( sl, &IID_IShellLinkDataList, (LPVOID*) &dl );
1845 if (FAILED(hr))
1846 return hr;
1847
1848 hr = IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG, (LPVOID*) &dar );
1849 if (SUCCEEDED(hr))
1850 {
1851 WCHAR* szCmdline;
1852 DWORD cmdSize;
1853
1854 cmdSize=0;
1855 hr = CommandLineFromMsiDescriptor( dar->szwDarwinID, NULL, &cmdSize );
1856 if (hr == ERROR_SUCCESS)
1857 {
1858 cmdSize++;
1859 szCmdline = HeapAlloc( GetProcessHeap(), 0, cmdSize*sizeof(WCHAR) );
1860 hr = CommandLineFromMsiDescriptor( dar->szwDarwinID, szCmdline, &cmdSize );
1861 WINE_TRACE(" command : %s\n", wine_dbgstr_w(szCmdline));
1862 if (hr == ERROR_SUCCESS)
1863 {
1864 WCHAR *s, *d;
1865 int bcount = 0;
1866 BOOL in_quotes = FALSE;
1867
1868 /* Extract the application path */
1869 s=szCmdline;
1870 d=szPath;
1871 while (*s)
1872 {
1873 if ((*s==0x0009 || *s==0x0020) && !in_quotes)
1874 {
1875 /* skip the remaining spaces */
1876 do {
1877 s++;
1878 } while (*s==0x0009 || *s==0x0020);
1879 break;
1880 }
1881 else if (*s==0x005c)
1882 {
1883 /* '\\' */
1884 *d++=*s++;
1885 bcount++;
1886 }
1887 else if (*s==0x0022)
1888 {
1889 /* '"' */
1890 if ((bcount & 1)==0)
1891 {
1892 /* Preceded by an even number of '\', this is
1893 * half that number of '\', plus a quote which
1894 * we erase.
1895 */
1896 d-=bcount/2;
1897 in_quotes=!in_quotes;
1898 s++;
1899 }
1900 else
1901 {
1902 /* Preceded by an odd number of '\', this is
1903 * half that number of '\' followed by a '"'
1904 */
1905 d=d-bcount/2-1;
1906 *d++='"';
1907 s++;
1908 }
1909 bcount=0;
1910 }
1911 else
1912 {
1913 /* a regular character */
1914 *d++=*s++;
1915 bcount=0;
1916 }
1917 if ((d-szPath) == pathSize)
1918 {
1919 /* Keep processing the path till we get to the
1920 * arguments, but 'stand still'
1921 */
1922 d--;
1923 }
1924 }
1925 /* Close the application path */
1926 *d=0;
1927
1928 lstrcpynW(szArgs, s, argsSize);
1929 }
1930 HeapFree( GetProcessHeap(), 0, szCmdline );
1931 }
1932 LocalFree( dar );
1933 }
1934
1935 IShellLinkDataList_Release( dl );
1936 return hr;
1937 }
1938
1939 static WCHAR* assoc_query(ASSOCSTR assocStr, LPCWSTR name, LPCWSTR extra)
1940 {
1941 HRESULT hr;
1942 WCHAR *value = NULL;
1943 DWORD size = 0;
1944 hr = AssocQueryStringW(0, assocStr, name, extra, NULL, &size);
1945 if (SUCCEEDED(hr))
1946 {
1947 value = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1948 if (value)
1949 {
1950 hr = AssocQueryStringW(0, assocStr, name, extra, value, &size);
1951 if (FAILED(hr))
1952 {
1953 HeapFree(GetProcessHeap(), 0, value);
1954 value = NULL;
1955 }
1956 }
1957 }
1958 return value;
1959 }
1960
1961 static char *slashes_to_minuses(const char *string)
1962 {
1963 int i;
1964 char *ret = HeapAlloc(GetProcessHeap(), 0, lstrlenA(string) + 1);
1965 if (ret)
1966 {
1967 for (i = 0; string[i]; i++)
1968 {
1969 if (string[i] == '/')
1970 ret[i] = '-';
1971 else
1972 ret[i] = string[i];
1973 }
1974 ret[i] = 0;
1975 return ret;
1976 }
1977 return NULL;
1978 }
1979
1980 static BOOL next_line(FILE *file, char **line, int *size)
1981 {
1982 int pos = 0;
1983 char *cr;
1984 if (*line == NULL)
1985 {
1986 *size = 4096;
1987 *line = HeapAlloc(GetProcessHeap(), 0, *size);
1988 }
1989 while (*line != NULL)
1990 {
1991 if (fgets(&(*line)[pos], *size - pos, file) == NULL)
1992 {
1993 HeapFree(GetProcessHeap(), 0, *line);
1994 *line = NULL;
1995 if (feof(file))
1996 return TRUE;
1997 return FALSE;
1998 }
1999 pos = strlen(*line);
2000 cr = strchr(*line, '\n');
2001 if (cr == NULL)
2002 {
2003 char *line2;
2004 (*size) *= 2;
2005 line2 = HeapReAlloc(GetProcessHeap(), 0, *line, *size);
2006 if (line2)
2007 *line = line2;
2008 else
2009 {
2010 HeapFree(GetProcessHeap(), 0, *line);
2011 *line = NULL;
2012 }
2013 }
2014 else
2015 {
2016 *cr = 0;
2017 return TRUE;
2018 }
2019 }
2020 return FALSE;
2021 }
2022
2023 static BOOL add_mimes(const char *xdg_data_dir, struct list *mime_types)
2024 {
2025 char *globs_filename = NULL;
2026 BOOL ret = TRUE;
2027 globs_filename = heap_printf("%s/mime/globs", xdg_data_dir);
2028 if (globs_filename)
2029 {
2030 FILE *globs_file = fopen(globs_filename, "r");
2031 if (globs_file) /* doesn't have to exist */
2032 {
2033 char *line = NULL;
2034 int size = 0;
2035 while (ret && (ret = next_line(globs_file, &line, &size)) && line)
2036 {
2037 char *pos;
2038 struct xdg_mime_type *mime_type_entry = NULL;
2039 if (line[0] != '#' && (pos = strchr(line, ':')))
2040 {
2041 mime_type_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct xdg_mime_type));
2042 if (mime_type_entry)
2043 {
2044 *pos = 0;
2045 mime_type_entry->mimeType = strdupA(line);
2046 mime_type_entry->glob = strdupA(pos + 1);
2047 mime_type_entry->lower_glob = strdupA(pos + 1);
2048 if (mime_type_entry->lower_glob)
2049 {
2050 char *l;
2051 for (l = mime_type_entry->lower_glob; *l; l++)
2052 *l = tolower(*l);
2053 }
2054 if (mime_type_entry->mimeType && mime_type_entry->glob && mime_type_entry->lower_glob)
2055 list_add_tail(mime_types, &mime_type_entry->entry);
2056 else
2057 {
2058 HeapFree(GetProcessHeap(), 0, mime_type_entry->mimeType);
2059 HeapFree(GetProcessHeap(), 0, mime_type_entry->glob);
2060 HeapFree(GetProcessHeap(), 0, mime_type_entry->lower_glob);
2061 HeapFree(GetProcessHeap(), 0, mime_type_entry);
2062 ret = FALSE;
2063 }
2064 }
2065 else
2066 ret = FALSE;
2067 }
2068 }
2069 HeapFree(GetProcessHeap(), 0, line);
2070 fclose(globs_file);
2071 }
2072 HeapFree(GetProcessHeap(), 0, globs_filename);
2073 }
2074 else
2075 ret = FALSE;
2076 return ret;
2077 }
2078
2079 static void free_native_mime_types(struct list *native_mime_types)
2080 {
2081 struct xdg_mime_type *mime_type_entry, *mime_type_entry2;
2082
2083 LIST_FOR_EACH_ENTRY_SAFE(mime_type_entry, mime_type_entry2, native_mime_types, struct xdg_mime_type, entry)
2084 {
2085 list_remove(&mime_type_entry->entry);
2086 HeapFree(GetProcessHeap(), 0, mime_type_entry->glob);
2087 HeapFree(GetProcessHeap(), 0, mime_type_entry->lower_glob);
2088 HeapFree(GetProcessHeap(), 0, mime_type_entry->mimeType);
2089 HeapFree(GetProcessHeap(), 0, mime_type_entry);
2090 }
2091 HeapFree(GetProcessHeap(), 0, native_mime_types);
2092 }
2093
2094 static BOOL build_native_mime_types(const char *xdg_data_home, struct list **mime_types)
2095 {
2096 char *xdg_data_dirs;
2097 BOOL ret;
2098
2099 *mime_types = NULL;
2100
2101 xdg_data_dirs = getenv("XDG_DATA_DIRS");
2102 if (xdg_data_dirs == NULL)
2103 xdg_data_dirs = heap_printf("/usr/local/share/:/usr/share/");
2104 else
2105 xdg_data_dirs = strdupA(xdg_data_dirs);
2106
2107 if (xdg_data_dirs)
2108 {
2109 *mime_types = HeapAlloc(GetProcessHeap(), 0, sizeof(struct list));
2110 if (*mime_types)
2111 {
2112 const char *begin;
2113 char *end;
2114
2115 list_init(*mime_types);
2116 ret = add_mimes(xdg_data_home, *mime_types);
2117 if (ret)
2118 {
2119 for (begin = xdg_data_dirs; (end = strchr(begin, ':')); begin = end + 1)
2120 {
2121 *end = '\0';
2122 ret = add_mimes(begin, *mime_types);
2123 *end = ':';
2124 if (!ret)
2125 break;
2126 }
2127 if (ret)
2128 ret = add_mimes(begin, *mime_types);
2129 }
2130 }
2131 else
2132 ret = FALSE;
2133 HeapFree(GetProcessHeap(), 0, xdg_data_dirs);
2134 }
2135 else
2136 ret = FALSE;
2137 if (!ret && *mime_types)
2138 {
2139 free_native_mime_types(*mime_types);
2140 *mime_types = NULL;
2141 }
2142 return ret;
2143 }
2144
2145 static BOOL match_glob(struct list *native_mime_types, const char *extension,
2146 int ignoreGlobCase, char **match)
2147 {
2148 #ifdef HAVE_FNMATCH
2149 struct xdg_mime_type *mime_type_entry;
2150 int matchLength = 0;
2151
2152 *match = NULL;
2153
2154 LIST_FOR_EACH_ENTRY(mime_type_entry, native_mime_types, struct xdg_mime_type, entry)
2155 {
2156 const char *glob = ignoreGlobCase ? mime_type_entry->lower_glob : mime_type_entry->glob;
2157 if (fnmatch(glob, extension, 0) == 0)
2158 {
2159 if (*match == NULL || matchLength < strlen(glob))
2160 {
2161 *match = mime_type_entry->mimeType;
2162 matchLength = strlen(glob);
2163 }
2164 }
2165 }
2166
2167 if (*match != NULL)
2168 {
2169 *match = strdupA(*match);
2170 if (*match == NULL)
2171 return FALSE;
2172 }
2173 #else
2174 *match = NULL;
2175 #endif
2176 return TRUE;
2177 }
2178
2179 static BOOL freedesktop_mime_type_for_extension(struct list *native_mime_types,
2180 const char *extensionA,
2181 LPCWSTR extensionW,
2182 char **mime_type)
2183 {
2184 WCHAR *lower_extensionW;
2185 INT len;
2186 BOOL ret = match_glob(native_mime_types, extensionA, 0, mime_type);
2187 if (ret == FALSE || *mime_type != NULL)
2188 return ret;
2189 len = strlenW(extensionW);
2190 lower_extensionW = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
2191 if (lower_extensionW)
2192 {
2193 char *lower_extensionA;
2194 memcpy(lower_extensionW, extensionW, (len + 1)*sizeof(WCHAR));
2195 strlwrW(lower_extensionW);
2196 lower_extensionA = wchars_to_utf8_chars(lower_extensionW);
2197 if (lower_extensionA)
2198 {
2199 ret = match_glob(native_mime_types, lower_extensionA, 1, mime_type);
2200 HeapFree(GetProcessHeap(), 0, lower_extensionA);
2201 }
2202 else
2203 {
2204 ret = FALSE;
2205 WINE_FIXME("out of memory\n");
2206 }
2207 HeapFree(GetProcessHeap(), 0, lower_extensionW);
2208 }
2209 else
2210 {
2211 ret = FALSE;
2212 WINE_FIXME("out of memory\n");
2213 }
2214 return ret;
2215 }
2216
2217 static WCHAR* reg_get_valW(HKEY key, LPCWSTR subkey, LPCWSTR name)
2218 {
2219 DWORD size;
2220 if (RegGetValueW(key, subkey, name, RRF_RT_REG_SZ, NULL, NULL, &size) == ERROR_SUCCESS)
2221 {
2222 WCHAR *ret = HeapAlloc(GetProcessHeap(), 0, size);
2223 if (ret)
2224 {
2225 if (RegGetValueW(key, subkey, name, RRF_RT_REG_SZ, NULL, ret, &size) == ERROR_SUCCESS)
2226 return ret;
2227 }
2228 HeapFree(GetProcessHeap(), 0, ret);
2229 }
2230 return NULL;
2231 }
2232
2233 static CHAR* reg_get_val_utf8(HKEY key, LPCWSTR subkey, LPCWSTR name)
2234 {
2235 WCHAR *valW = reg_get_valW(key, subkey, name);
2236 if (valW)
2237 {
2238 char *val = wchars_to_utf8_chars(valW);
2239 HeapFree(GetProcessHeap(), 0, valW);
2240 return val;
2241 }
2242 return NULL;
2243 }
2244
2245 static HKEY open_associations_reg_key(void)
2246 {
2247 static const WCHAR Software_Wine_FileOpenAssociationsW[] = {
2248 'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','F','i','l','e','O','p','e','n','A','s','s','o','c','i','a','t','i','o','n','s',0};
2249 HKEY assocKey;
2250 if (RegCreateKeyW(HKEY_CURRENT_USER, Software_Wine_FileOpenAssociationsW, &assocKey) == ERROR_SUCCESS)
2251 return assocKey;
2252 return NULL;
2253 }
2254
2255 static BOOL has_association_changed(LPCWSTR extensionW, LPCSTR mimeType, LPCWSTR progId,
2256 LPCSTR appName, LPCSTR openWithIcon)
2257 {
2258 static const WCHAR ProgIDW[] = {'P','r','o','g','I','D',0};
2259 static const WCHAR MimeTypeW[] = {'M','i','m','e','T','y','p','e',0};
2260 static const WCHAR AppNameW[] = {'A','p','p','N','a','m','e',0};
2261 static const WCHAR OpenWithIconW[] = {'O','p','e','n','W','i','t','h','I','c','o','n',0};
2262 HKEY assocKey;
2263 BOOL ret;
2264
2265 if ((assocKey = open_associations_reg_key()))
2266 {
2267 CHAR *valueA;
2268 WCHAR *value;
2269
2270 ret = FALSE;
2271
2272 valueA = reg_get_val_utf8(assocKey, extensionW, MimeTypeW);
2273 if (!valueA || lstrcmpA(valueA, mimeType))
2274 ret = TRUE;
2275 HeapFree(GetProcessHeap(), 0, valueA);
2276
2277 value = reg_get_valW(assocKey, extensionW, ProgIDW);
2278 if (!value || strcmpW(value, progId))
2279 ret = TRUE;
2280 HeapFree(GetProcessHeap(), 0, value);
2281
2282 valueA = reg_get_val_utf8(assocKey, extensionW, AppNameW);
2283 if (!valueA || lstrcmpA(valueA, appName))
2284 ret = TRUE;
2285 HeapFree(GetProcessHeap(), 0, valueA);
2286
2287 valueA = reg_get_val_utf8(assocKey, extensionW, OpenWithIconW);
2288 if ((openWithIcon && !valueA) ||
2289 (!openWithIcon && valueA) ||
2290 (openWithIcon && valueA && lstrcmpA(valueA, openWithIcon)))
2291 ret = TRUE;
2292 HeapFree(GetProcessHeap(), 0, valueA);
2293
2294 RegCloseKey(assocKey);
2295 }
2296 else
2297 {
2298 WINE_ERR("error opening associations registry key\n");
2299 ret = FALSE;
2300 }
2301 return ret;
2302 }
2303
2304 static void update_association(LPCWSTR extension, LPCSTR mimeType, LPCWSTR progId,
2305 LPCSTR appName, LPCSTR desktopFile, LPCSTR openWithIcon)
2306 {
2307 static const WCHAR ProgIDW[] = {'P','r','o','g','I','D',0};
2308 static const WCHAR MimeTypeW[] = {'M','i','m','e','T','y','p','e',0};
2309 static const WCHAR AppNameW[] = {'A','p','p','N','a','m','e',0};
2310 static const WCHAR DesktopFileW[] = {'D','e','s','k','t','o','p','F','i','l','e',0};
2311 static const WCHAR OpenWithIconW[] = {'O','p','e','n','W','i','t','h','I','c','o','n',0};
2312 HKEY assocKey = NULL;
2313 HKEY subkey = NULL;
2314 WCHAR *mimeTypeW = NULL;
2315 WCHAR *appNameW = NULL;
2316 WCHAR *desktopFileW = NULL;
2317 WCHAR *openWithIconW = NULL;
2318
2319 assocKey = open_associations_reg_key();
2320 if (assocKey == NULL)
2321 {
2322 WINE_ERR("could not open file associations key\n");
2323 goto done;
2324 }
2325
2326 if (RegCreateKeyW(assocKey, extension, &subkey) != ERROR_SUCCESS)
2327 {
2328 WINE_ERR("could not create extension subkey\n");
2329 goto done;
2330 }
2331
2332 mimeTypeW = utf8_chars_to_wchars(mimeType);
2333 if (mimeTypeW == NULL)
2334 {
2335 WINE_ERR("out of memory\n");
2336 goto done;
2337 }
2338
2339 appNameW = utf8_chars_to_wchars(appName);
2340 if (appNameW == NULL)
2341 {
2342 WINE_ERR("out of memory\n");
2343 goto done;
2344 }
2345
2346 desktopFileW = utf8_chars_to_wchars(desktopFile);
2347 if (desktopFileW == NULL)
2348 {
2349 WINE_ERR("out of memory\n");
2350 goto done;
2351 }
2352
2353 if (openWithIcon)
2354 {
2355 openWithIconW = utf8_chars_to_wchars(openWithIcon);
2356 if (openWithIconW == NULL)
2357 {
2358 WINE_ERR("out of memory\n");
2359 goto done;
2360 }
2361 }
2362
2363 RegSetValueExW(subkey, MimeTypeW, 0, REG_SZ, (const BYTE*) mimeTypeW, (lstrlenW(mimeTypeW) + 1) * sizeof(WCHAR));
2364 RegSetValueExW(subkey, ProgIDW, 0, REG_SZ, (const BYTE*) progId, (lstrlenW(progId) + 1) * sizeof(WCHAR));
2365 RegSetValueExW(subkey, AppNameW, 0, REG_SZ, (const BYTE*) appNameW, (lstrlenW(appNameW) + 1) * sizeof(WCHAR));
2366 RegSetValueExW(subkey, DesktopFileW, 0, REG_SZ, (const BYTE*) desktopFileW, (lstrlenW(desktopFileW) + 1) * sizeof(WCHAR));
2367 if (openWithIcon)
2368 RegSetValueExW(subkey, OpenWithIconW, 0, REG_SZ, (const BYTE*) openWithIconW, (lstrlenW(openWithIconW) + 1) * sizeof(WCHAR));
2369 else
2370 RegDeleteValueW(subkey, OpenWithIconW);
2371
2372 done:
2373 RegCloseKey(assocKey);
2374 RegCloseKey(subkey);
2375 HeapFree(GetProcessHeap(), 0, mimeTypeW);
2376 HeapFree(GetProcessHeap(), 0, appNameW);
2377 HeapFree(GetProcessHeap(), 0, desktopFileW);
2378 HeapFree(GetProcessHeap(), 0, openWithIconW);
2379 }
2380
2381 static BOOL cleanup_associations(void)
2382 {
2383 static const WCHAR openW[] = {'o','p','e','n',0};
2384 static const WCHAR DesktopFileW[] = {'D','e','s','k','t','o','p','F','i','l','e',0};
2385 HKEY assocKey;
2386 BOOL hasChanged = FALSE;
2387 if ((assocKey = open_associations_reg_key()))
2388 {
2389 int i;
2390 BOOL done = FALSE;
2391 for (i = 0; !done;)
2392 {
2393 WCHAR *extensionW = NULL;
2394 DWORD size = 1024;
2395 LSTATUS ret;
2396
2397 do
2398 {
2399 HeapFree(GetProcessHeap(), 0, extensionW);
2400 extensionW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
2401 if (extensionW == NULL)
2402 {
2403 WINE_ERR("out of memory\n");
2404 ret = ERROR_OUTOFMEMORY;
2405 break;
2406 }
2407 ret = RegEnumKeyExW(assocKey, i, extensionW, &size, NULL, NULL, NULL, NULL);
2408 size *= 2;
2409 } while (ret == ERROR_MORE_DATA);
2410
2411 if (ret == ERROR_SUCCESS)
2412 {
2413 WCHAR *command;
2414 command = assoc_query(ASSOCSTR_COMMAND, extensionW, openW);
2415 if (command == NULL)
2416 {
2417 char *desktopFile = reg_get_val_utf8(assocKey, extensionW, DesktopFileW);
2418 if (desktopFile)
2419 {
2420 WINE_TRACE("removing file type association for %s\n", wine_dbgstr_w(extensionW));
2421 remove(desktopFile);
2422 }
2423 RegDeleteKeyW(assocKey, extensionW);
2424 hasChanged = TRUE;
2425 HeapFree(GetProcessHeap(), 0, desktopFile);
2426 }
2427 else
2428 i++;
2429 HeapFree(GetProcessHeap(), 0, command);
2430 }
2431 else
2432 {
2433 if (ret != ERROR_NO_MORE_ITEMS)
2434 WINE_ERR("error %d while reading registry\n", ret);
2435 done = TRUE;
2436 }
2437 HeapFree(GetProcessHeap(), 0, extensionW);
2438 }
2439 RegCloseKey(assocKey);
2440 }
2441 else
2442 WINE_ERR("could not open file associations key\n");
2443 return hasChanged;
2444 }
2445
2446 static BOOL write_freedesktop_mime_type_entry(const char *packages_dir, const char *dot_extension,
2447 const char *mime_type, const char *comment)
2448 {
2449 BOOL ret = FALSE;
2450 char *filename;
2451
2452 WINE_TRACE("writing MIME type %s, extension=%s, comment=%s\n", wine_dbgstr_a(mime_type),
2453 wine_dbgstr_a(dot_extension), wine_dbgstr_a(comment));
2454
2455 filename = heap_printf("%s/x-wine-extension-%s.xml", packages_dir, &dot_extension[1]);
2456 if (filename)
2457 {
2458 FILE *packageFile = fopen(filename, "w");
2459 if (packageFile)
2460 {
2461 fprintf(packageFile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
2462 fprintf(packageFile, "<mime-info xmlns=\"http://www.freedesktop.org/standards/shared-mime-info\">\n");
2463 fprintf(packageFile, " <mime-type type=\"");
2464 write_xml_text(packageFile, mime_type);
2465 fprintf(packageFile, "\">\n");
2466 fprintf(packageFile, " <glob pattern=\"*");
2467 write_xml_text(packageFile, dot_extension);
2468 fprintf(packageFile, "\"/>\n");
2469 if (comment)
2470 {
2471 fprintf(packageFile, " <comment>");
2472 write_xml_text(packageFile, comment);
2473 fprintf(packageFile, "</comment>\n");
2474 }
2475 fprintf(packageFile, " </mime-type>\n");
2476 fprintf(packageFile, "</mime-info>\n");
2477 ret = TRUE;
2478 fclose(packageFile);
2479 }
2480 else
2481 WINE_ERR("error writing file %s\n", filename);
2482 HeapFree(GetProcessHeap(), 0, filename);
2483 }
2484 else
2485 WINE_ERR("out of memory\n");
2486 return ret;
2487 }
2488
2489 static BOOL is_extension_blacklisted(LPCWSTR extension)
2490 {
2491 /* These are managed through external tools like wine.desktop, to evade malware created file type associations */
2492 static const WCHAR comW[] = {'.','c','o','m',0};
2493 static const WCHAR exeW[] = {'.','e','x','e',0};
2494 static const WCHAR msiW[] = {'.','m','s','i',0};
2495
2496 if (!strcmpiW(extension, comW) ||
2497 !strcmpiW(extension, exeW) ||
2498 !strcmpiW(extension, msiW))
2499 return TRUE;
2500 return FALSE;
2501 }
2502
2503 static const char* get_special_mime_type(LPCWSTR extension)
2504 {
2505 static const WCHAR lnkW[] = {'.','l','n','k',0};
2506 if (!strcmpiW(extension, lnkW))
2507 return "application/x-ms-shortcut";
2508 return NULL;
2509 }
2510
2511 static BOOL write_freedesktop_association_entry(const char *desktopPath, const char *dot_extension,
2512 const char *friendlyAppName, const char *mimeType,
2513 const char *progId, const char *openWithIcon)
2514 {
2515 BOOL ret = FALSE;
2516 FILE *desktop;
2517
2518 WINE_TRACE("writing association for file type %s, friendlyAppName=%s, MIME type %s, progID=%s, icon=%s to file %s\n",
2519 wine_dbgstr_a(dot_extension), wine_dbgstr_a(friendlyAppName), wine_dbgstr_a(mimeType),
2520 wine_dbgstr_a(progId), wine_dbgstr_a(openWithIcon), wine_dbgstr_a(desktopPath));
2521
2522 desktop = fopen(desktopPath, "w");
2523 if (desktop)
2524 {
2525 fprintf(desktop, "[Desktop Entry]\n");
2526 fprintf(desktop, "Type=Application\n");
2527 fprintf(desktop, "Name=%s\n", friendlyAppName);
2528 fprintf(desktop, "MimeType=%s;\n", mimeType);
2529 fprintf(desktop, "Exec=env WINEPREFIX=\"%s\" wine start /ProgIDOpen %s %%f\n", wine_get_config_dir(), progId);
2530 fprintf(desktop, "NoDisplay=true\n");
2531 fprintf(desktop, "StartupNotify=true\n");
2532 if (openWithIcon)
2533 fprintf(desktop, "Icon=%s\n", openWithIcon);
2534 ret = TRUE;
2535 fclose(desktop);
2536 }
2537 else
2538 WINE_ERR("error writing association file %s\n", wine_dbgstr_a(desktopPath));
2539 return ret;
2540 }
2541
2542 static BOOL generate_associations(const char *xdg_data_home, const char *packages_dir, const char *applications_dir)
2543 {
2544 static const WCHAR openW[] = {'o','p','e','n',0};
2545 struct wine_rb_tree mimeProgidTree;
2546 struct list *nativeMimeTypes = NULL;
2547 LSTATUS ret = 0;
2548 int i;
2549 BOOL hasChanged = FALSE;
2550
2551 if (wine_rb_init(&mimeProgidTree, &winemenubuilder_rb_functions))
2552 {
2553 WINE_ERR("wine_rb_init failed\n");
2554 return FALSE;
2555 }
2556 if (!build_native_mime_types(xdg_data_home, &nativeMimeTypes))
2557 {
2558 WINE_ERR("could not build native MIME types\n");
2559 return FALSE;
2560 }
2561
2562 for (i = 0; ; i++)
2563 {
2564 WCHAR *extensionW = NULL;
2565 DWORD size = 1024;
2566
2567 do
2568 {
2569 HeapFree(GetProcessHeap(), 0, extensionW);
2570 extensionW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
2571 if (extensionW == NULL)
2572 {
2573 WINE_ERR("out of memory\n");
2574 ret = ERROR_OUTOFMEMORY;
2575 break;
2576 }
2577 ret = RegEnumKeyExW(HKEY_CLASSES_ROOT, i, extensionW, &size, NULL, NULL, NULL, NULL);
2578 size *= 2;
2579 } while (ret == ERROR_MORE_DATA);
2580
2581 if (ret == ERROR_SUCCESS && extensionW[0] == '.' && !is_extension_blacklisted(extensionW))
2582 {
2583 char *extensionA = NULL;
2584 WCHAR *commandW = NULL;
2585 WCHAR *executableW = NULL;
2586 char *openWithIconA = NULL;
2587 WCHAR *friendlyDocNameW = NULL;
2588 char *friendlyDocNameA = NULL;
2589 WCHAR *iconW = NULL;
2590 char *iconA = NULL;
2591 WCHAR *contentTypeW = NULL;
2592 char *mimeTypeA = NULL;
2593 WCHAR *friendlyAppNameW = NULL;
2594 char *friendlyAppNameA = NULL;
2595 WCHAR *progIdW = NULL;
2596 char *progIdA = NULL;
2597 char *mimeProgId = NULL;
2598
2599 extensionA = wchars_to_utf8_chars(strlwrW(extensionW));
2600 if (extensionA == NULL)
2601 {
2602 WINE_ERR("out of memory\n");
2603 goto end;
2604 }
2605
2606 friendlyDocNameW = assoc_query(ASSOCSTR_FRIENDLYDOCNAME, extensionW, NULL);
2607 if (friendlyDocNameW)
2608 {
2609 friendlyDocNameA = wchars_to_utf8_chars(friendlyDocNameW);
2610 if (friendlyDocNameA == NULL)
2611 {
2612 WINE_ERR("out of memory\n");
2613 goto end;
2614 }
2615 }
2616
2617 iconW = assoc_query(ASSOCSTR_DEFAULTICON, extensionW, NULL);
2618
2619 contentTypeW = assoc_query(ASSOCSTR_CONTENTTYPE, extensionW, NULL);
2620 if (contentTypeW)
2621 strlwrW(contentTypeW);
2622
2623 if (!freedesktop_mime_type_for_extension(nativeMimeTypes, extensionA, extensionW, &mimeTypeA))
2624 goto end;
2625
2626 if (mimeTypeA == NULL)
2627 {
2628 if (contentTypeW != NULL && strchrW(contentTypeW, '/'))
2629 mimeTypeA = wchars_to_utf8_chars(contentTypeW);
2630 else if ((get_special_mime_type(extensionW)))
2631 mimeTypeA = strdupA(get_special_mime_type(extensionW));
2632 else
2633 mimeTypeA = heap_printf("application/x-wine-extension-%s", &extensionA[1]);
2634
2635 if (mimeTypeA != NULL)
2636 {
2637 /* GNOME seems to ignore the <icon> tag in MIME packages,
2638 * and the default name is more intuitive anyway.
2639 */
2640 if (iconW)
2641 {
2642 char *flattened_mime = slashes_to_minuses(mimeTypeA);
2643 if (flattened_mime)
2644 {
2645 int index = 0;
2646 WCHAR *comma = strrchrW(iconW, ',');
2647 if (comma)
2648 {
2649 *comma = 0;
2650 index = atoiW(comma + 1);
2651 }
2652 iconA = extract_icon(iconW, index, flattened_mime, FALSE);
2653 HeapFree(GetProcessHeap(), 0, flattened_mime);
2654 }
2655 }
2656
2657 write_freedesktop_mime_type_entry(packages_dir, extensionA, mimeTypeA, friendlyDocNameA);
2658 hasChanged = TRUE;
2659 }
2660 else
2661 {
2662 WINE_FIXME("out of memory\n");
2663 goto end;
2664 }
2665 }
2666
2667 commandW = assoc_query(ASSOCSTR_COMMAND, extensionW, openW);
2668 if (commandW == NULL)
2669 /* no command => no application is associated */
2670 goto end;
2671
2672 executableW = assoc_query(ASSOCSTR_EXECUTABLE, extensionW, openW);
2673 if (executableW)
2674 openWithIconA = extract_icon(executableW, 0, NULL, FALSE);
2675
2676 friendlyAppNameW = assoc_query(ASSOCSTR_FRIENDLYAPPNAME, extensionW, openW);
2677 if (friendlyAppNameW)
2678 {
2679 friendlyAppNameA = wchars_to_utf8_chars(friendlyAppNameW);
2680 if (friendlyAppNameA == NULL)
2681 {
2682 WINE_ERR("out of memory\n");
2683 goto end;
2684 }
2685 }
2686 else
2687 {
2688 friendlyAppNameA = heap_printf("A Wine application");
2689 if (friendlyAppNameA == NULL)
2690 {
2691 WINE_ERR("out of memory\n");
2692 goto end;
2693 }
2694 }
2695
2696 progIdW = reg_get_valW(HKEY_CLASSES_ROOT, extensionW, NULL);
2697 if (progIdW)
2698 {
2699 progIdA = escape(progIdW);
2700 if (progIdA == NULL)
2701 {
2702 WINE_ERR("out of memory\n");
2703 goto end;
2704 }
2705 }
2706 else
2707 goto end; /* no progID => not a file type association */
2708
2709 /* Do not allow duplicate ProgIDs for a MIME type, it causes unnecessary duplication in Open dialogs */
2710 mimeProgId = heap_printf("%s=>%s", mimeTypeA, progIdA);
2711 if (mimeProgId)
2712 {
2713 struct rb_string_entry *entry;
2714 if (wine_rb_get(&mimeProgidTree, mimeProgId))
2715 {
2716 HeapFree(GetProcessHeap(), 0, mimeProgId);
2717 goto end;
2718 }
2719 entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct rb_string_entry));
2720 if (!entry)
2721 {
2722 WINE_ERR("out of memory allocating rb_string_entry\n");
2723 goto end;
2724 }
2725 entry->string = mimeProgId;
2726 if (wine_rb_put(&mimeProgidTree, mimeProgId, &entry->entry))
2727 {
2728 WINE_ERR("error updating rb tree\n");
2729 goto end;
2730 }
2731 }
2732
2733 if (has_association_changed(extensionW, mimeTypeA, progIdW, friendlyAppNameA, openWithIconA))
2734 {
2735 char *desktopPath = heap_printf("%s/wine-extension-%s.desktop", applications_dir, &extensionA[1]);
2736 if (desktopPath)
2737 {
2738 if (write_freedesktop_association_entry(desktopPath, extensionA, friendlyAppNameA, mimeTypeA, progIdA, openWithIconA))
2739 {
2740 hasChanged = TRUE;
2741 update_association(extensionW, mimeTypeA, progIdW, friendlyAppNameA, desktopPath, openWithIconA);
2742 }
2743 HeapFree(GetProcessHeap(), 0, desktopPath);
2744 }
2745 }
2746
2747 end:
2748 HeapFree(GetProcessHeap(), 0, extensionA);
2749 HeapFree(GetProcessHeap(), 0, commandW);
2750 HeapFree(GetProcessHeap(), 0, executableW);
2751 HeapFree(GetProcessHeap(), 0, openWithIconA);
2752 HeapFree(GetProcessHeap(), 0, friendlyDocNameW);
2753 HeapFree(GetProcessHeap(), 0, friendlyDocNameA);
2754 HeapFree(GetProcessHeap(), 0, iconW);
2755 HeapFree(GetProcessHeap(), 0, iconA);
2756 HeapFree(GetProcessHeap(), 0, contentTypeW);
2757 HeapFree(GetProcessHeap(), 0, mimeTypeA);
2758 HeapFree(GetProcessHeap(), 0, friendlyAppNameW);
2759 HeapFree(GetProcessHeap(), 0, friendlyAppNameA);
2760 HeapFree(GetProcessHeap(), 0, progIdW);
2761 HeapFree(GetProcessHeap(), 0, progIdA);
2762 }
2763 HeapFree(GetProcessHeap(), 0, extensionW);
2764 if (ret != ERROR_SUCCESS)
2765 break;
2766 }
2767
2768 wine_rb_destroy(&mimeProgidTree, winemenubuilder_rb_destroy, NULL);
2769 free_native_mime_types(nativeMimeTypes);
2770 return hasChanged;
2771 }
2772
2773 static char *get_start_exe_path(void)
2774 {
2775 static const WCHAR startW[] = {'\\','c','o','m','m','a','n','d',
2776 '\\','s','t','a','r','t','.','e','x','e',0};
2777 WCHAR start_path[MAX_PATH];
2778 GetWindowsDirectoryW(start_path, MAX_PATH);
2779 lstrcatW(start_path, startW);
2780 return escape(start_path);
2781 }
2782
2783 static char* escape_unix_link_arg(LPCSTR unix_link)
2784 {
2785 char *ret = NULL;
2786 WCHAR *unix_linkW = utf8_chars_to_wchars(unix_link);
2787 if (unix_linkW)
2788 {
2789 char *escaped_lnk = escape(unix_linkW);
2790 if (escaped_lnk)
2791 {
2792 ret = heap_printf("/Unix %s", escaped_lnk);
2793 HeapFree(GetProcessHeap(), 0, escaped_lnk);
2794 }
2795 HeapFree(GetProcessHeap(), 0, unix_linkW);
2796 }
2797 return ret;
2798 }
2799
2800 static BOOL InvokeShellLinker( IShellLinkW *sl, LPCWSTR link, BOOL bWait )
2801 {
2802 static const WCHAR startW[] = {'\\','c','o','m','m','a','n','d',
2803 '\\','s','t','a','r','t','.','e','x','e',0};
2804 char *link_name = NULL, *icon_name = NULL, *work_dir = NULL;
2805 char *escaped_path = NULL, *escaped_args = NULL, *description = NULL;
2806 WCHAR szTmp[INFOTIPSIZE];
2807 WCHAR szDescription[INFOTIPSIZE], szPath[MAX_PATH], szWorkDir[MAX_PATH];
2808 WCHAR szArgs[INFOTIPSIZE], szIconPath[MAX_PATH];
2809 int iIconId = 0, r = -1;
2810 DWORD csidl = -1;
2811 HANDLE hsem = NULL;
2812 char *unix_link = NULL;
2813 char *start_path = NULL;
2814
2815 if ( !link )
2816 {
2817 WINE_ERR("Link name is null\n");
2818 return FALSE;
2819 }
2820
2821 if( !GetLinkLocation( link, &csidl, &link_name ) )
2822 {
2823 WINE_WARN("Unknown link location %s. Ignoring.\n",wine_dbgstr_w(link));
2824 return TRUE;
2825 }
2826 if (!in_desktop_dir(csidl) && !in_startmenu(csidl))
2827 {
2828 WINE_WARN("Not under desktop or start menu. Ignoring.\n");
2829 return TRUE;
2830 }
2831 WINE_TRACE("Link : %s\n", wine_dbgstr_a(link_name));
2832
2833 szTmp[0] = 0;
2834 IShellLinkW_GetWorkingDirectory( sl, szTmp, MAX_PATH );
2835 ExpandEnvironmentStringsW(szTmp, szWorkDir, MAX_PATH);
2836 WINE_TRACE("workdir : %s\n", wine_dbgstr_w(szWorkDir));
2837
2838 szTmp[0] = 0;
2839 IShellLinkW_GetDescription( sl, szTmp, INFOTIPSIZE );
2840 ExpandEnvironmentStringsW(szTmp, szDescription, INFOTIPSIZE);
2841 WINE_TRACE("description: %s\n", wine_dbgstr_w(szDescription));
2842
2843 get_cmdline( sl, szTmp, MAX_PATH, szArgs, INFOTIPSIZE);
2844 ExpandEnvironmentStringsW(szTmp, szPath, MAX_PATH);
2845 WINE_TRACE("path : %s\n", wine_dbgstr_w(szPath));
2846 WINE_TRACE("args : %s\n", wine_dbgstr_w(szArgs));
2847
2848 szTmp[0] = 0;
2849 IShellLinkW_GetIconLocation( sl, szTmp, MAX_PATH, &iIconId );
2850 ExpandEnvironmentStringsW(szTmp, szIconPath, MAX_PATH);
2851 WINE_TRACE("icon file : %s\n", wine_dbgstr_w(szIconPath) );
2852
2853 if( !szPath[0] )
2854 {
2855 LPITEMIDLIST pidl = NULL;
2856 IShellLinkW_GetIDList( sl, &pidl );
2857 if( pidl && SHGetPathFromIDListW( pidl, szPath ) )
2858 WINE_TRACE("pidl path : %s\n", wine_dbgstr_w(szPath));
2859 }
2860
2861 /* extract the icon */
2862 if( szIconPath[0] )
2863 icon_name = extract_icon( szIconPath , iIconId, NULL, bWait );
2864 else
2865 icon_name = extract_icon( szPath, iIconId, NULL, bWait );
2866
2867 /* fail - try once again after parent process exit */
2868 if( !icon_name )
2869 {
2870 if (bWait)
2871 {
2872 WINE_WARN("Unable to extract icon, deferring.\n");
2873 goto cleanup;
2874 }
2875 WINE_ERR("failed to extract icon from %s\n",
2876 wine_dbgstr_w( szIconPath[0] ? szIconPath : szPath ));
2877 }
2878
2879 unix_link = wine_get_unix_file_name(link);
2880 if (unix_link == NULL)
2881 {
2882 WINE_WARN("couldn't find unix path of %s\n", wine_dbgstr_w(link));
2883 goto cleanup;
2884 }
2885
2886 /* check the path */
2887 if( szPath[0] )
2888 {
2889 static const WCHAR exeW[] = {'.','e','x','e',0};
2890 WCHAR *p;
2891
2892 /* check for .exe extension */
2893 if (!(p = strrchrW( szPath, '.' )) ||
2894 strchrW( p, '\\' ) || strchrW( p, '/' ) ||
2895 lstrcmpiW( p, exeW ))
2896 {
2897 /* Not .exe - use 'start.exe' to launch this file */
2898 p = szArgs + lstrlenW(szPath) + 2;
2899 if (szArgs[0])
2900 {
2901 p[0] = ' ';
2902 memmove( p+1, szArgs, min( (lstrlenW(szArgs) + 1) * sizeof(szArgs[0]),
2903 sizeof(szArgs) - (p + 1 - szArgs) * sizeof(szArgs[0]) ) );
2904 }
2905 else
2906 p[0] = 0;
2907
2908 szArgs[0] = '"';
2909 lstrcpyW(szArgs + 1, szPath);
2910 p[-1] = '"';
2911
2912 GetWindowsDirectoryW(szPath, MAX_PATH);
2913 lstrcatW(szPath, startW);
2914 }
2915
2916 /* convert app working dir */
2917 if (szWorkDir[0])
2918 work_dir = wine_get_unix_file_name( szWorkDir );
2919 }
2920 else
2921 {
2922 /* if there's no path... try run the link itself */
2923 lstrcpynW(szArgs, link, MAX_PATH);
2924 GetWindowsDirectoryW(szPath, MAX_PATH);
2925 lstrcatW(szPath, startW);
2926 }
2927
2928 /* escape the path and parameters */
2929 escaped_path = escape(szPath);
2930 escaped_args = escape(szArgs);
2931 description = wchars_to_utf8_chars(szDescription);
2932 if (escaped_path == NULL || escaped_args == NULL || description == NULL)
2933 {
2934 WINE_ERR("out of memory allocating/escaping parameters\n");
2935 goto cleanup;
2936 }
2937
2938 start_path = get_start_exe_path();
2939 if (start_path == NULL)
2940 {
2941 WINE_ERR("out of memory\n");
2942 goto cleanup;
2943 }
2944
2945 /* building multiple menus concurrently has race conditions */
2946 hsem = CreateSemaphoreA( NULL, 1, 1, "winemenubuilder_semaphore");
2947 if( WAIT_OBJECT_0 != MsgWaitForMultipleObjects( 1, &hsem, FALSE, INFINITE, QS_ALLINPUT ) )
2948 {
2949 WINE_ERR("failed wait for semaphore\n");
2950 goto cleanup;
2951 }
2952
2953 if (in_desktop_dir(csidl))
2954 {
2955 char *location;
2956 const char *lastEntry;
2957 lastEntry = strrchr(link_name, '/');
2958 if (lastEntry == NULL)
2959 lastEntry = link_name;
2960 else
2961 ++lastEntry;
2962 location = heap_printf("%s/%s.desktop", xdg_desktop_dir, lastEntry);
2963 if (location)
2964 {
2965 if (csidl == CSIDL_COMMON_DESKTOPDIRECTORY)
2966 {
2967 char *link_arg = escape_unix_link_arg(unix_link);
2968 if (link_arg)
2969 {
2970 r = !write_desktop_entry(unix_link, location, lastEntry,
2971 start_path, link_arg, description, work_dir, icon_name);
2972 HeapFree(GetProcessHeap(), 0, link_arg);
2973 }
2974 }
2975 else
2976 r = !write_desktop_entry(NULL, location, lastEntry, escaped_path, escaped_args, description, work_dir, icon_name);
2977 if (r == 0)
2978 chmod(location, 0755);
2979 HeapFree(GetProcessHeap(), 0, location);
2980 }
2981 }
2982 else
2983 {
2984 char *link_arg = escape_unix_link_arg(unix_link);
2985 if (link_arg)
2986 {
2987 r = !write_menu_entry(unix_link, link_name, start_path, link_arg, description, work_dir, icon_name);
2988 HeapFree(GetProcessHeap(), 0, link_arg);
2989 }
2990 }
2991
2992 ReleaseSemaphore( hsem, 1, NULL );
2993
2994 cleanup:
2995 if (hsem) CloseHandle( hsem );
2996 HeapFree( GetProcessHeap(), 0, icon_name );
2997 HeapFree( GetProcessHeap(), 0, work_dir );
2998 HeapFree( GetProcessHeap(), 0, link_name );
2999 HeapFree( GetProcessHeap(), 0, escaped_args );
3000 HeapFree( GetProcessHeap(), 0, escaped_path );
3001 HeapFree( GetProcessHeap(), 0, description );
3002 HeapFree( GetProcessHeap(), 0, unix_link );
3003 HeapFree( GetProcessHeap(), 0, start_path );
3004
3005 if (r && !bWait)
3006 WINE_ERR("failed to build the menu\n" );
3007
3008 return ( r == 0 );
3009 }
3010
3011 static BOOL InvokeShellLinkerForURL( IUniformResourceLocatorW *url, LPCWSTR link, BOOL bWait )
3012 {
3013 char *link_name = NULL, *icon_name = NULL;
3014 DWORD csidl = -1;
3015 LPWSTR urlPath = NULL;
3016 char *escaped_urlPath = NULL;
3017 HRESULT hr;
3018 HANDLE hSem = NULL;
3019 BOOL ret = TRUE;
3020 int r = -1;
3021 char *unix_link = NULL;
3022 IPropertySetStorage *pPropSetStg;
3023 IPropertyStorage *pPropStg;
3024 PROPSPEC ps[2];
3025 PROPVARIANT pv[2];
3026 char *start_path = NULL;
3027 BOOL has_icon = FALSE;
3028
3029 if ( !link )
3030 {
3031 WINE_ERR("Link name is null\n");
3032 return TRUE;
3033 }
3034
3035 if( !GetLinkLocation( link, &csidl, &link_name ) )
3036 {
3037 WINE_WARN("Unknown link location %s. Ignoring.\n",wine_dbgstr_w(link));
3038 return TRUE;
3039 }
3040 if (!in_desktop_dir(csidl) && !in_startmenu(csidl))
3041 {
3042 WINE_WARN("Not under desktop or start menu. Ignoring.\n");
3043 ret = TRUE;
3044 goto cleanup;
3045 }
3046 WINE_TRACE("Link : %s\n", wine_dbgstr_a(link_name));
3047
3048 hr = url->lpVtbl->GetURL(url, &urlPath);
3049 if (FAILED(hr))
3050 {
3051 ret = TRUE;
3052 goto cleanup;
3053 }
3054 WINE_TRACE("path : %s\n", wine_dbgstr_w(urlPath));
3055
3056 unix_link = wine_get_unix_file_name(link);
3057 if (unix_link == NULL)
3058 {
3059 WINE_WARN("couldn't find unix path of %s\n", wine_dbgstr_w(link));
3060 goto cleanup;
3061 }
3062
3063 escaped_urlPath = escape(urlPath);
3064 if (escaped_urlPath == NULL)
3065 {
3066 WINE_ERR("couldn't escape url, out of memory\n");
3067 goto cleanup;
3068 }
3069
3070 start_path = get_start_exe_path();
3071 if (start_path == NULL)
3072 {
3073 WINE_ERR("out of memory\n");
3074 goto cleanup;
3075 }
3076
3077 ps[0].ulKind = PRSPEC_PROPID;
3078 ps[0].u.propid = PID_IS_ICONFILE;
3079 ps[1].ulKind = PRSPEC_PROPID;
3080 ps[1].u.propid = PID_IS_ICONINDEX;
3081
3082 hr = url->lpVtbl->QueryInterface(url, &IID_IPropertySetStorage, (void **) &pPropSetStg);
3083 if (SUCCEEDED(hr))
3084 {
3085 hr = IPropertySetStorage_Open(pPropSetStg, &FMTID_Intshcut, STGM_READ | STGM_SHARE_EXCLUSIVE, &pPropStg);
3086 if (SUCCEEDED(hr))
3087 {
3088 hr = IPropertyStorage_ReadMultiple(pPropStg, 2, ps, pv);
3089 if (SUCCEEDED(hr))
3090 {
3091 if (pv[0].vt == VT_LPWSTR && pv[0].u.pwszVal && pv[0].u.pwszVal[0])
3092 {
3093 has_icon = TRUE;
3094 icon_name = extract_icon( pv[0].u.pwszVal, pv[1].u.iVal, NULL, bWait );
3095
3096 WINE_TRACE("URL icon path: %s icon index: %d icon name: %s\n", wine_dbgstr_w(pv[0].u.pwszVal), pv[1].u.iVal, icon_name);
3097 }
3098 PropVariantClear(&pv[0]);
3099 PropVariantClear(&pv[1]);
3100 }
3101 IPropertyStorage_Release(pPropStg);
3102 }
3103 IPropertySetStorage_Release(pPropSetStg);
3104 }
3105
3106 /* fail - try once again after parent process exit */
3107 if( has_icon && !icon_name )
3108 {
3109 if (bWait)
3110 {
3111 WINE_WARN("Unable to extract icon, deferring.\n");
3112 ret = FALSE;
3113 goto cleanup;
3114 }
3115 WINE_ERR("failed to extract icon from %s\n",
3116 wine_dbgstr_w( pv[0].u.pwszVal ));
3117 }
3118
3119 hSem = CreateSemaphoreA( NULL, 1, 1, "winemenubuilder_semaphore");
3120 if( WAIT_OBJECT_0 != MsgWaitForMultipleObjects( 1, &hSem, FALSE, INFINITE, QS_ALLINPUT ) )
3121 {
3122 WINE_ERR("failed wait for semaphore\n");
3123 goto cleanup;
3124 }
3125 if (in_desktop_dir(csidl))
3126 {
3127 char *location;
3128 const char *lastEntry;
3129 lastEntry = strrchr(link_name, '/');
3130 if (lastEntry == NULL)
3131 lastEntry = link_name;
3132 else
3133 ++lastEntry;
3134 location = heap_printf("%s/%s.desktop", xdg_desktop_dir, lastEntry);
3135 if (location)
3136 {
3137 r = !write_desktop_entry(NULL, location, lastEntry, start_path, escaped_urlPath, NULL, NULL, icon_name);
3138 if (r == 0)
3139 chmod(location, 0755);
3140 HeapFree(GetProcessHeap(), 0, location);
3141 }
3142 }
3143 else
3144 r = !write_menu_entry(unix_link, link_name, start_path, escaped_urlPath, NULL, NULL, icon_name);
3145 ret = (r == 0);
3146 ReleaseSemaphore(hSem, 1, NULL);
3147
3148 cleanup:
3149 if (hSem)
3150 CloseHandle(hSem);
3151 HeapFree( GetProcessHeap(), 0, icon_name );
3152 HeapFree(GetProcessHeap(), 0, link_name);
3153 CoTaskMemFree( urlPath );
3154 HeapFree(GetProcessHeap(), 0, escaped_urlPath);
3155 HeapFree(GetProcessHeap(), 0, unix_link);
3156 return ret;
3157 }
3158
3159 static BOOL WaitForParentProcess( void )
3160 {
3161 PROCESSENTRY32 procentry;
3162 HANDLE hsnapshot = NULL, hprocess = NULL;
3163 DWORD ourpid = GetCurrentProcessId();
3164 BOOL ret = FALSE, rc;
3165
3166 WINE_TRACE("Waiting for parent process\n");
3167 if ((hsnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 )) ==
3168 INVALID_HANDLE_VALUE)
3169 {
3170 WINE_ERR("CreateToolhelp32Snapshot failed, error %d\n", GetLastError());
3171 goto done;
3172 }
3173
3174 procentry.dwSize = sizeof(PROCESSENTRY32);
3175 rc = Process32First( hsnapshot, &procentry );
3176 while (rc)
3177 {
3178 if (procentry.th32ProcessID == ourpid) break;
3179 rc = Process32Next( hsnapshot, &procentry );
3180 }
3181 if (!rc)
3182 {
3183 WINE_WARN("Unable to find current process id %d when listing processes\n", ourpid);
3184 goto done;
3185 }
3186
3187 if ((hprocess = OpenProcess( SYNCHRONIZE, FALSE, procentry.th32ParentProcessID )) ==
3188 NULL)
3189 {
3190 WINE_WARN("OpenProcess failed pid=%d, error %d\n", procentry.th32ParentProcessID,
3191 GetLastError());
3192 goto done;
3193 }
3194
3195 if (MsgWaitForMultipleObjects( 1, &hprocess, FALSE, INFINITE, QS_ALLINPUT ) == WAIT_OBJECT_0)
3196 ret = TRUE;
3197 else
3198 WINE_ERR("Unable to wait for parent process, error %d\n", GetLastError());
3199
3200 done:
3201 if (hprocess) CloseHandle( hprocess );
3202 if (hsnapshot) CloseHandle( hsnapshot );
3203 return ret;
3204 }
3205
3206 static BOOL Process_Link( LPCWSTR linkname, BOOL bWait )
3207 {
3208 IShellLinkW *sl;
3209 IPersistFile *pf;
3210 HRESULT r;
3211 WCHAR fullname[MAX_PATH];
3212 DWORD len;
3213
3214 WINE_TRACE("%s, wait %d\n", wine_dbgstr_w(linkname), bWait);
3215
3216 if( !linkname[0] )
3217 {
3218 WINE_ERR("link name missing\n");
3219 return 1;
3220 }
3221
3222 len=GetFullPathNameW( linkname, MAX_PATH, fullname, NULL );
3223 if (len==0 || len>MAX_PATH)
3224 {
3225 WINE_ERR("couldn't get full path of link file\n");
3226 return 1;
3227 }
3228
3229 r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3230 &IID_IShellLinkW, (LPVOID *) &sl );
3231 if( FAILED( r ) )
3232 {
3233 WINE_ERR("No IID_IShellLink\n");
3234 return 1;
3235 }
3236
3237 r = IShellLinkW_QueryInterface( sl, &IID_IPersistFile, (LPVOID*) &pf );
3238 if( FAILED( r ) )
3239 {
3240 WINE_ERR("No IID_IPersistFile\n");
3241 return 1;
3242 }
3243
3244 r = IPersistFile_Load( pf, fullname, STGM_READ );
3245 if( SUCCEEDED( r ) )
3246 {
3247 /* If something fails (eg. Couldn't extract icon)
3248 * wait for parent process and try again
3249 */
3250 if( ! InvokeShellLinker( sl, fullname, bWait ) && bWait )
3251 {
3252 WaitForParentProcess();
3253 InvokeShellLinker( sl, fullname, FALSE );
3254 }
3255 }
3256 else
3257 {
3258 WINE_ERR("unable to load %s\n", wine_dbgstr_w(linkname));
3259 }
3260
3261 IPersistFile_Release( pf );
3262 IShellLinkW_Release( sl );
3263
3264 return !r;
3265 }
3266
3267 static BOOL Process_URL( LPCWSTR urlname, BOOL bWait )
3268 {
3269 IUniformResourceLocatorW *url;
3270 IPersistFile *pf;
3271 HRESULT r;
3272 WCHAR fullname[MAX_PATH];
3273 DWORD len;
3274
3275 WINE_TRACE("%s, wait %d\n", wine_dbgstr_w(urlname), bWait);
3276
3277 if( !urlname[0] )
3278 {
3279 WINE_ERR("URL name missing\n");
3280 return 1;
3281 }
3282
3283 len=GetFullPathNameW( urlname, MAX_PATH, fullname, NULL );
3284 if (len==0 || len>MAX_PATH)
3285 {
3286 WINE_ERR("couldn't get full path of URL file\n");
3287 return 1;
3288 }
3289
3290 r = CoCreateInstance( &CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER,
3291 &IID_IUniformResourceLocatorW, (LPVOID *) &url );
3292 if( FAILED( r ) )
3293 {
3294 WINE_ERR("No IID_IUniformResourceLocatorW\n");
3295 return 1;
3296 }
3297
3298 r = url->lpVtbl->QueryInterface( url, &IID_IPersistFile, (LPVOID*) &pf );
3299 if( FAILED( r ) )
3300 {
3301 WINE_ERR("No IID_IPersistFile\n");
3302 return 1;
3303 }
3304 r = IPersistFile_Load( pf, fullname, STGM_READ );
3305 if( SUCCEEDED( r ) )
3306 {
3307 /* If something fails (eg. Couldn't extract icon)
3308 * wait for parent process and try again
3309 */
3310 if( ! InvokeShellLinkerForURL( url, fullname, bWait ) && bWait )
3311 {
3312 WaitForParentProcess();
3313 InvokeShellLinkerForURL( url, fullname, FALSE );
3314 }
3315 }
3316
3317 IPersistFile_Release( pf );
3318 url->lpVtbl->Release( url );
3319
3320 return !r;
3321 }
3322
3323 static void RefreshFileTypeAssociations(void)
3324 {
3325 HANDLE hSem = NULL;
3326 char *mime_dir = NULL;
3327 char *packages_dir = NULL;
3328 char *applications_dir = NULL;
3329 BOOL hasChanged;
3330
3331 hSem = CreateSemaphoreA( NULL, 1, 1, "winemenubuilder_semaphore");
3332 if( WAIT_OBJECT_0 != MsgWaitForMultipleObjects( 1, &hSem, FALSE, INFINITE, QS_ALLINPUT ) )
3333 {
3334 WINE_ERR("failed wait for semaphore\n");
3335 CloseHandle(hSem);
3336 hSem = NULL;
3337 goto end;
3338 }
3339
3340 mime_dir = heap_printf("%s/mime", xdg_data_dir);
3341 if (mime_dir == NULL)
3342 {
3343 WINE_ERR("out of memory\n");
3344 goto end;
3345 }
3346 create_directories(mime_dir);
3347
3348 packages_dir = heap_printf("%s/packages", mime_dir);
3349 if (packages_dir == NULL)
3350 {
3351 WINE_ERR("out of memory\n");
3352 goto end;
3353 }
3354 create_directories(packages_dir);
3355
3356 applications_dir = heap_printf("%s/applications", xdg_data_dir);
3357 if (applications_dir == NULL)
3358 {
3359 WINE_ERR("out of memory\n");
3360 goto end;
3361 }
3362 create_directories(applications_dir);
3363
3364 hasChanged = generate_associations(xdg_data_dir, packages_dir, applications_dir);
3365 hasChanged |= cleanup_associations();
3366 if (hasChanged)
3367 {
3368 const char *argv[3];
3369
3370 argv[0] = "update-mime-database";
3371 argv[1] = mime_dir;
3372 argv[2] = NULL;
3373 _spawnvp( _P_DETACH, argv[0], argv );
3374
3375 argv[0] = "update-desktop-database";
3376 argv[1] = applications_dir;
3377 _spawnvp( _P_DETACH, argv[0], argv );
3378 }
3379
3380 end:
3381 if (hSem)
3382 {
3383 ReleaseSemaphore(hSem, 1, NULL);
3384 CloseHandle(hSem);
3385 }
3386 HeapFree(GetProcessHeap(), 0, mime_dir);
3387 HeapFree(GetProcessHeap(), 0, packages_dir);
3388 HeapFree(GetProcessHeap(), 0, applications_dir);
3389 }
3390
3391 static void cleanup_menus(void)
3392 {
3393 HKEY hkey;
3394
3395 hkey = open_menus_reg_key();
3396 if (hkey)
3397 {
3398 int i;
3399 LSTATUS lret = ERROR_SUCCESS;
3400 for (i = 0; lret == ERROR_SUCCESS; )
3401 {
3402 WCHAR *value = NULL;
3403 WCHAR *data = NULL;
3404 DWORD valueSize = 4096;
3405 DWORD dataSize = 4096;
3406 while (1)
3407 {
3408 lret = ERROR_OUTOFMEMORY;
3409 value = HeapAlloc(GetProcessHeap(), 0, valueSize * sizeof(WCHAR));
3410 if (value == NULL)
3411 break;
3412 data = HeapAlloc(GetProcessHeap(), 0, dataSize * sizeof(WCHAR));
3413 if (data == NULL)
3414 break;
3415 lret = RegEnumValueW(hkey, i, value, &valueSize, NULL, NULL, (BYTE*)data, &dataSize);
3416 if (lret == ERROR_SUCCESS || lret != ERROR_MORE_DATA)
3417 break;
3418 valueSize *= 2;
3419 dataSize *= 2;
3420 HeapFree(GetProcessHeap(), 0, value);
3421 HeapFree(GetProcessHeap(), 0, data);
3422 value = data = NULL;
3423 }
3424 if (lret == ERROR_SUCCESS)
3425 {
3426 char *unix_file;
3427 char *windows_file;
3428 unix_file = wchars_to_unix_chars(value);
3429 windows_file = wchars_to_unix_chars(data);
3430 if (unix_file != NULL && windows_file != NULL)
3431 {
3432 struct stat filestats;
3433 if (stat(windows_file, &filestats) < 0 && errno == ENOENT)
3434 {
3435 WINE_TRACE("removing menu related file %s\n", unix_file);
3436 remove(unix_file);
3437 RegDeleteValueW(hkey, value);
3438 }
3439 else
3440 i++;
3441 }
3442 else
3443 {
3444 WINE_ERR("out of memory enumerating menus\n");
3445 lret = ERROR_OUTOFMEMORY;
3446 }
3447 HeapFree(GetProcessHeap(), 0, unix_file);
3448 HeapFree(GetProcessHeap(), 0, windows_file);
3449 }
3450 else if (lret != ERROR_NO_MORE_ITEMS)
3451 WINE_ERR("error %d reading registry\n", lret);
3452 HeapFree(GetProcessHeap(), 0, value);
3453 HeapFree(GetProcessHeap(), 0, data);
3454 }
3455 RegCloseKey(hkey);
3456 }
3457 else
3458 WINE_ERR("error opening registry key, menu cleanup failed\n");
3459 }
3460
3461 static void thumbnail_lnk(LPCWSTR lnkPath, LPCWSTR outputPath)
3462 {
3463 char *utf8lnkPath = NULL;
3464 char *utf8OutputPath = NULL;
3465 WCHAR *winLnkPath = NULL;
3466 IShellLinkW *shellLink = NULL;
3467 IPersistFile *persistFile = NULL;
3468 WCHAR szTmp[MAX_PATH];
3469 WCHAR szPath[MAX_PATH];
3470 WCHAR szArgs[INFOTIPSIZE];
3471 WCHAR szIconPath[MAX_PATH];
3472 int iconId;
3473 IStream *stream = NULL;
3474 HRESULT hr;
3475
3476 utf8lnkPath = wchars_to_utf8_chars(lnkPath);
3477 if (utf8lnkPath == NULL)
3478 {
3479 WINE_ERR("out of memory converting paths\n");
3480 goto end;
3481 }
3482
3483 utf8OutputPath = wchars_to_utf8_chars(outputPath);
3484 if (utf8OutputPath == NULL)
3485 {
3486 WINE_ERR("out of memory converting paths\n");
3487 goto end;
3488 }
3489
3490 winLnkPath = wine_get_dos_file_name(utf8lnkPath);
3491 if (winLnkPath == NULL)
3492 {
3493 WINE_ERR("could not convert %s to DOS path\n", utf8lnkPath);
3494 goto end;
3495 }
3496
3497 hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3498 &IID_IShellLinkW, (LPVOID*)&shellLink);
3499 if (FAILED(hr))
3500 {
3501 WINE_ERR("could not create IShellLinkW, error 0x%08X\n", hr);
3502 goto end;
3503 }
3504
3505 hr = IShellLinkW_QueryInterface(shellLink, &IID_IPersistFile, (LPVOID)&persistFile);
3506 if (FAILED(hr))
3507 {
3508 WINE_ERR("could not query IPersistFile, error 0x%08X\n", hr);
3509 goto end;
3510 }
3511
3512 hr = IPersistFile_Load(persistFile, winLnkPath, STGM_READ);
3513 if (FAILED(hr))
3514 {
3515 WINE_ERR("could not read .lnk, error 0x%08X\n", hr);
3516 goto end;
3517 }
3518
3519 get_cmdline(shellLink, szTmp, MAX_PATH, szArgs, INFOTIPSIZE);
3520 ExpandEnvironmentStringsW(szTmp, szPath, MAX_PATH);
3521 szTmp[0] = 0;
3522 IShellLinkW_GetIconLocation(shellLink, szTmp, MAX_PATH, &iconId);
3523 ExpandEnvironmentStringsW(szTmp, szIconPath, MAX_PATH);
3524
3525 if(!szPath[0])
3526 {
3527 LPITEMIDLIST pidl = NULL;
3528 IShellLinkW_GetIDList(shellLink, &pidl);
3529 if (pidl && SHGetPathFromIDListW(pidl, szPath))
3530 WINE_TRACE("pidl path : %s\n", wine_dbgstr_w(szPath));
3531 }
3532
3533 if (szIconPath[0])
3534 {
3535 hr = open_icon(szIconPath, iconId, FALSE, &stream);
3536 if (SUCCEEDED(hr))
3537 hr = write_native_icon(stream, utf8OutputPath, NULL);
3538 }
3539 else
3540 {
3541 hr = open_icon(szPath, iconId, FALSE, &stream);
3542 if (SUCCEEDED(hr))
3543 hr = write_native_icon(stream, utf8OutputPath, NULL);
3544 }
3545
3546 end:
3547 HeapFree(GetProcessHeap(), 0, utf8lnkPath);
3548 HeapFree(GetProcessHeap(), 0, utf8OutputPath);
3549 HeapFree(GetProcessHeap(), 0, winLnkPath);
3550 if (shellLink != NULL)
3551 IShellLinkW_Release(shellLink);
3552 if (persistFile != NULL)
3553 IPersistFile_Release(persistFile);
3554 if (stream != NULL)
3555 IStream_Release(stream);
3556 }
3557
3558 static WCHAR *next_token( LPWSTR *p )
3559 {
3560 LPWSTR token = NULL, t = *p;
3561
3562 if( !t )
3563 return NULL;
3564
3565 while( t && !token )
3566 {
3567 switch( *t )
3568 {
3569 case ' ':
3570 t++;
3571 continue;
3572 case '"':
3573 /* unquote the token */
3574 token = ++t;
3575 t = strchrW( token, '"' );
3576 if( t )
3577 *t++ = 0;
3578 break;
3579 case 0:
3580 t = NULL;
3581 break;
3582 default:
3583 token = t;
3584 t = strchrW( token, ' ' );
3585 if( t )
3586 *t++ = 0;
3587 break;
3588 }
3589 }
3590 *p = t;
3591 return token;
3592 }
3593
3594 static BOOL init_xdg(void)
3595 {
3596 WCHAR shellDesktopPath[MAX_PATH];
3597 HRESULT hr = SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, SHGFP_TYPE_CURRENT, shellDesktopPath);
3598 if (SUCCEEDED(hr))
3599 xdg_desktop_dir = wine_get_unix_file_name(shellDesktopPath);
3600 if (xdg_desktop_dir == NULL)
3601 {
3602 WINE_ERR("error looking up the desktop directory\n");
3603 return FALSE;
3604 }
3605
3606 if (getenv("XDG_CONFIG_HOME"))
3607 xdg_config_dir = heap_printf("%s/menus/applications-merged", getenv("XDG_CONFIG_HOME"));
3608 else
3609 xdg_config_dir = heap_printf("%s/.config/menus/applications-merged", getenv("HOME"));
3610 if (xdg_config_dir)
3611 {
3612 create_directories(xdg_config_dir);
3613 if (getenv("XDG_DATA_HOME"))
3614 xdg_data_dir = strdupA(getenv("XDG_DATA_HOME"));
3615 else
3616 xdg_data_dir = heap_printf("%s/.local/share", getenv("HOME"));
3617 if (xdg_data_dir)
3618 {
3619 char *buffer;
3620 create_directories(xdg_data_dir);
3621 buffer = heap_printf("%s/desktop-directories", xdg_data_dir);
3622 if (buffer)
3623 {
3624 mkdir(buffer, 0777);
3625 HeapFree(GetProcessHeap(), 0, buffer);
3626 }
3627 return TRUE;
3628 }
3629 HeapFree(GetProcessHeap(), 0, xdg_config_dir);
3630 }
3631 WINE_ERR("out of memory\n");
3632 return FALSE;
3633 }
3634
3635 /***********************************************************************
3636 *
3637 * wWinMain
3638 */
3639 int PASCAL wWinMain (HINSTANCE hInstance, HINSTANCE prev, LPWSTR cmdline, int show)
3640 {
3641 static const WCHAR dash_aW[] = {'-','a',0};
3642 static const WCHAR dash_rW[] = {'-','r',0};
3643 static const WCHAR dash_tW[] = {'-','t',0};
3644 static const WCHAR dash_uW[] = {'-','u',0};
3645 static const WCHAR dash_wW[] = {'-','w',0};
3646
3647 LPWSTR token = NULL, p;
3648 BOOL bWait = FALSE;
3649 BOOL bURL = FALSE;
3650 HRESULT hr;
3651 int ret = 0;
3652
3653 if (!init_xdg())
3654 return 1;
3655
3656 hr = CoInitialize(NULL);
3657 if (FAILED(hr))
3658 {
3659 WINE_ERR("could not initialize COM, error 0x%08X\n", hr);
3660 return 1;
3661 }
3662
3663 for( p = cmdline; p && *p; )
3664 {
3665 token = next_token( &p );
3666 if( !token )
3667 break;
3668 if( !strcmpW( token, dash_aW ) )
3669 {
3670 RefreshFileTypeAssociations();
3671 continue;
3672 }
3673 if( !strcmpW( token, dash_rW ) )
3674 {
3675 cleanup_menus();
3676 continue;
3677 }
3678 if( !strcmpW( token, dash_wW ) )
3679 bWait = TRUE;
3680 else if ( !strcmpW( token, dash_uW ) )
3681 bURL = TRUE;
3682 else if ( !strcmpW( token, dash_tW ) )
3683 {
3684 WCHAR *lnkFile = next_token( &p );
3685 if (lnkFile)
3686 {
3687 WCHAR *outputFile = next_token( &p );
3688 if (outputFile)
3689 thumbnail_lnk(lnkFile, outputFile);
3690 }
3691 }
3692 else if( token[0] == '-' )
3693 {
3694 WINE_ERR( "unknown option %s\n", wine_dbgstr_w(token) );
3695 }
3696 else
3697 {
3698 BOOL bRet;
3699
3700 if (bURL)
3701 bRet = Process_URL( token, bWait );
3702 else
3703 bRet = Process_Link( token, bWait );
3704 if (!bRet)
3705 {
3706 WINE_ERR( "failed to build menu item for %s\n", wine_dbgstr_w(token) );
3707 ret = 1;
3708 }
3709 }
3710 }
3711
3712 CoUninitialize();
3713 return ret;
3714 }
Maarten's multimedia branch