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